|| ||           || Doxygen's  

---

HxQCollection.h

/*
 *  Copyright (c) 2002, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *  Author(s):
 *  Frans Verster (verster@science.uva.nl)
 */

#ifndef HxQCollection_h_
#define HxQCollection_h_

/*
collection of queues for queue based pattern

interface must be:



template


*/
//#include <string>
#include <set> 
#include <queue> 
#include <stack> 

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 Container::iterator iterator;
    //typedef Container::const_iterator const_iterator;
    Qset() {}
    ~Qset() {}
    bool empty() const { return container.empty(); }
    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 Container::reference reference;
    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/*(__FILE__)*/;
public:
    Qpriority_queue() {}
    ~Qpriority_queue() {}
    bool empty() const { return container.empty(); }
    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()
*/
template<class Ty, class  C> 
class msvcqueue : public std::queue<Ty, C> {
public:
#ifdef WIN32
    value_type& top() { return (c.front()); }
    const value_type& top() const { return (c.front()); }
#else
    reference top() { return (c.front()); }
    const_reference top() const { return (c.front()); }
#endif
    //void clear() { c.clear(); } // too unclear if std::queue has more state to clear than just that member
};


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(); }
    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(); }
    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; }
};



#endif

---