|| || || || || || || ||

---

QCollection.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_QCollection_h
#define Impala_Core_Array_Pattern_QCollection_h

#include <iostream>
#include <string>
#include <set> 
#include <queue> 
#include <stack> 
#include <map>

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Pattern
{


template <class T> 
class Qset {
private:
    typedef std::set<T> Container;
    Container container;
    Qset(const Qset &);
    Qset& operator= (const Qset &);
public:
    //typedef Container::size_type size_type;
    typedef typename Container::iterator iterator;
    //typedef Container::const_iterator const_iterator;
    Qset() {}
    ~Qset() {}
    bool empty() const { return container.empty(); }
    typename Container::size_type size() const { return container.size(); }
    void clear() { container.clear(); }
    void push(const T &val) { container.insert(val); }
    void erase(iterator iter) { container.erase(iter); }
    iterator after_upper_bound(const T &val) { 
        iterator iter=container.upper_bound(val); 
        if (iter!=container.end()) iter++; 
        return iter; 
    }
    iterator lower_bound(const T &val) { return container.lower_bound(val); }
    void pop() { container.erase(container.begin()); }
    //T & top() { return *container.begin(); }
    typedef typename Container::const_reference const_reference;
    const_reference top() { return *container.begin(); }
};

class Int {
private:
    int val;
public:
    Int() : val(0) {}
    void operator ++ (int) { val++; } // Postfix increment operator
    operator int() const { return val; }
};

class Bugs {
private:
    std::map<int,Int> m;
    //Bugs();
    Bugs(const Bugs &);
    Bugs & operator = (const Bugs &);
    std::string fn;
public:
    Bugs(const char *cc=__FILE__) : fn(cc) {}
    void plusplus(int i) { m[i]++; }
    ~Bugs() { 
        if (!m.empty()) {
            std::cout << m.size() << "Bugs founds in file " << fn << std::endl;
        }
        for (std::map<int,Int>::const_iterator iter=m.begin(); iter!=m.end();
             iter++) {
            std::cout << "error in line " << iter->first <<", #=" << iter->second 
                      << std::endl;
        }
    }
};

template <class T>
class Qpriority_queue {
private:
    typedef std::priority_queue<T> Container;
    Container container;
    Qpriority_queue(const Qpriority_queue &);
    Qpriority_queue & operator = (const Qpriority_queue &);
    Bugs bugs;
public:
    Qpriority_queue() {}
    ~Qpriority_queue() {}
    bool empty() const { return container.empty(); }
    typename Container::size_type size() const { return container.size(); }
    void push(const T &val) { container.push(val); }
    void pop() { container.pop(); }
    T & top() { return container.top(); }
    // stuff below is not valid !!
    typedef T *iterator;
    void clear() { bugs.plusplus(__LINE__); }
    void erase(iterator iter) { bugs.plusplus(__LINE__); }
    iterator lower_bound(const T &val) { bugs.plusplus(__LINE__); return NULL; }
    iterator after_upper_bound(const T &val) { bugs.plusplus(__LINE__); return NULL; }
};

/*
BUG: the MS VC file <queue> doesnt implement std::queue::top()
and I'd like to have clear()
This bug is probably fixed in VS2005 and beyond, workaround breaks NVCC2.3win
*/
template<class Ty, class  C> 
class msvcqueue : public std::queue<Ty, C> {
};


template <class T>
class Qqueue {
private:
    //typedef std::queue<T> Container;
    //typedef msvcqueue<T, std::vector<T> > Container; //damn container.pop() --> c.pop_front() which is not a member of std::vector<T>
    typedef msvcqueue<T, std::deque<T> > Container; 
    Container container;
    Qqueue(const Qqueue &);
    Qqueue & operator = (const Qqueue &);
    Bugs bugs;
public:
    Qqueue() {}
    ~Qqueue() {}
    bool empty() const { return container.empty(); }
    typename Container::size_type size() const { return container.size(); }
    void push(const T &val) { container.push(val); }
    void pop() { container.pop(); }
    T & top() { return container.top(); }
    // stuff below is not valid !!
    typedef T *iterator;
    void clear() { bugs.plusplus(__LINE__); }
    //void clear() { container.clear(); }
    void erase(iterator iter) { bugs.plusplus(__LINE__); }
    iterator lower_bound(const T &val) { bugs.plusplus(__LINE__); return NULL; }
    iterator after_upper_bound(const T &val) { bugs.plusplus(__LINE__); return NULL; }
};

/*
I'd like to have clear()
*/
template<class Ty, class C>
class msvcstack : public std::stack<Ty, C> {
public:
    //void clear() { c.clear(); } // untested
};


template <class T>
class Qstack {
private:
    //typedef std::stack<T> Container;
    //typedef msvcstack<T, std::deque<T> > Container;
    typedef msvcstack<T, std::vector<T> > Container;
    Container container;
    Qstack(const Qstack &);
    Qstack & operator = (const Qstack &);
    Bugs bugs;
public:
    Qstack() {}
    ~Qstack() {}
    bool empty() const { return container.empty(); }
    typename Container::size_type size() const { return container.size(); }
    void push(const T &val) { container.push(val); }
    void pop() { container.pop(); }
    T & top() { return container.top(); }
    // stuff below is not valid !!
    typedef T* iterator;
    void clear() { bugs.plusplus(__LINE__); }
    //void clear() { container.clear(); }
    void erase(iterator iter) { bugs.plusplus(__LINE__); }
    iterator lower_bound(const T &val) { bugs.plusplus(__LINE__); return NULL; }
    iterator after_upper_bound(const T &val) { bugs.plusplus(__LINE__); return NULL; }
};

} // namespace Pattern
} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---