concepts.h

/*
 *  $Id$
 *  Concepts documentation
 *
 *  This file is part of OTAWA
 *  Copyright (c) 2007-08, IRIT UPS.
 * 
 *  OTAWA is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  OTAWA is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with OTAWA; if not, write to the Free Software 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <elm/util/Equiv.h>

namespace elm { namespace concept {

template <class T>
class Iterator {
public:

    Iterator(const Iterator& iterator);
    
    bool ended(void);
    
    void next(void);
    
    const T& item(void);
    
    operator bool(void);
    
    operator const T& (void);
    
    Iterator& operator++(int);
    
    Iterator& operator=(const Iterator& iterator);
};


template <class T, template <class _> class E = Equiv<T> >
class Collection {
public:

    int count(void);
    
    bool contains(const T& item);
    
    template <template <class _> class C>
    bool containsAll(const C<T>& collection);
    
    bool isEmpty(void);
    
    operator bool(void);
    
    class Iterator: public concept::Iterator<T> {
    public:
    
        Iter(const Collection<T>& collection);
    
        Iter(const Collection<T> *collection);
    };
};


template <class T>
class MutableCollection: public  Collection<T> {
public:

    void clear(void);
    
    void add(const T& item);
    
    void addAll(const Collection<T>& items);
    
    void remove(const T& item);
    
    void removeAll(const Collection<T>& items);
    
    void remove(const Iterator<T>& iter);   
};


template <class T>
class Set: public MutableCollection<T> {
public:
    
    void insert(const T& item);
};


template <class T>
class Array: public  Collection<T> {
public:

    int length(void);
    
    const T& get(int index) const;
    
    int indexOf(const T& value, int start = 0) const;

    int lastIndexOf(const T& value, int start = -1) const;
    
    const T& operator[](int index) const;   
};


template <class T>
class MutableArray: public  Array<T>, public  MutableCollection<T> {
public:

    void shrink(int length);

    void set(int index, const T& item);

    void set(const Iterator& iter, const T& item);
    
     T& get(int index);
    
    T& operator[](int index);
    
    void insert(int index, const T& item);
    
    void insert(const Iterator& iter, const T& item);
    
    void removeAt(int index);
    
    void removeAt(const Iterator& iter);
};


template <class T>
class Stack {
public:
    
    bool isEmpty(void) const;
    
    const T& top(void) const;
    
    T pop(void);
    
    void push(const T& item);
    
    void reset(void);
};


template <class T>
class Queue {
public:

    bool isEmpty(void) const;
    
    const T& head(void) const;
    
    T get(void);
    
    void put(const T& item);
    
    void reset(void);

};


template <class T>
class Hash {
public:

    static unsigned long hash(const T& object);
    
    static inline bool equals(const T& object1, const T& object2);
};


template <class T>
class Comparator {
public:

    static int compare(const T& object1, const T& object2);
};


template <class T>
class Equiv {
public:
    
    static bool equals(const T& val1, const T& val2);
};


template <class T>
class PartialComparator {
public:

    static const int EQUAL = 0x001;
    
    static const int LESS = 0x010;
    
    static const int GREATER = 0x100;
    
    static const int UNCOMP = 0x000;
    
    static bool equals(const T& v1, const T& v2);
    
    static bool greaterThan(const T& v1, const T& v2);

    static bool lessThan(const T& v1, const T& v2);

    static int compare(const T& v1, const T& v2);
};


template <class K, class T>
class Map: public  Collection<Pair<K, T> > {
public:
    
    Option<const T&> get(const K& key) const;
    
    const T& get(const K& key, const T& def) const;

    bool hasKey(const K& key) const;

    class KeyIterator: public Iterator<K> {
    public:
    
        KeyIterator(const Map<K, T>& map);
        
        KeyIterator(const KeyIterator& iter);
    };
    
    class PairIterator: public Iterator<Pair<K, T> > {
    public:
    
        PairIterator(const Map<K, T>& map);
        
        PairIterator(const ValueIterator& iter);
    };
};


template <class K, class T>
class MutableMap: public  Map<K, T>, public Collection<Pair<K, T> > {
public:
    
    void put(const K& key, const T& value);
    
    void remove(const K& key);
    
    void remove(const PairIterator& iter);
};


template <class T>
class List: public Collection<T> {
public:
    
    const T& first(void);
    
    const T& last(void);
    
    Iterator<T> find(const T& item);

    Iterator<T> find(const T& item, const Iterator& start);
};


template <class T>
class MutableList: public List<T>, public MutableCollection<T> {
public:
    
    void addFirst(const T& item);
    
    void addLast(const T& item);
    
    void removeFirst(void);
    
    void removeLast(void);
    
    void addAfter(const Iterator<T>& pos, const T& item);
    
    void addBefore(const Iterator<T>& pos, const T& item);
    
    void set(const Iterator<T>& pos, const T& item);
};


template <class T>
class BiDiList: public List<T> {
public:
    
    class Iterator: public List<T>::Iterator {
    public:
        Iterator(const BiDiList<T>& list);
        Iterator(const Iterator<T>& iter);
        Iterator(const BackIterator<T>& iter);
        Iterator& operator=(const BackIterator<T>& iter);
    };
    
    class BackIterator: public Iterator<T> {
    public:
        BackIterator(const BiDiList<T>& list);
        BackIterator(const BackIterator<T>& iter);
        BackIterator(const Iterator<T>& iter);
        BackIterator& operator=(const BackIterator<T>& iter);       
        BackIterator& operator=(const Iterator<T>& iter);       
    };
};


template <class K, class T>
class Key {
public:
    
    typedef K key_t;
    
    static const K& key(const T& value);
};

} } // elm::concept