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 "../include/elm/equiv.h"
 
namespace elm { namespace concept {
 
template <class T>
class Iter {
public:
 
    bool ended(void);
    
    void next(void);
    
    T item(void);
    
    operator bool(void);
    
    operator T (void);
    
    Iter& operator++(int);
    
    Iter& operator=(const Iter& iterator);
 
    bool equals(const Iter& iterator) const;
 
    bool operator==(const Iter& iterator) const;
 
    bool operator!=(const Iter& iterator) const;
};
 
 
template <class T>
class MutableIter {
public:
 
    bool ended(void);
 
    void next(void);
 
    T& item(void);
 
    operator bool(void);
 
    MutableIter& operator++(int);
 
    MutableIter& operator=(const MutableIter& iterator);
 
    bool equals(const MutableIter& iterator) const;
 
    bool operator==(const MutableIter& iterator) const;
 
    bool operator!=(const MutableIter& iterator) const;
};
 
 
template <class T>
class Collection {
public:
 
    typedef T t;
 
    typedef Collection<T> self_t;
 
    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 Iter: public concept::Iter<T> {
    public:
    
        Iter(const Collection<T>& collection);
    
    };
 
    Iter begin(void) const;
 
    Iter end(void) const;
 
    static const Collection null;
 
 
    bool equals(const Collection& coll);
 
    bool operator==(const Collection& coll);
 
    bool operator!=(const Collection& coll);
 
    static const Collection<T> null;
};
 
 
template <class T>
class MutableCollection: public  Collection<T> {
public:
 
    MutableIter<T> begin();
 
    MutableIter<T> end();
 
    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);
 
    MutableCollection<T>& operator+=(const T& item);
 
    MutableCollection<T>& operator-=(const T& item);
 
    void copy(const Collection<T>& items);
 
    MutableCollection& operator=(const Collection<T>& c);
 
};
 
 
template <class T>
class Set: public MutableCollection<T> {
public:
    
    void insert(const T& item);
 
    bool subsetOf(const Set& coll);
 
    bool operator>=(const Set& coll);
 
    bool operator<=(const Set& coll);
 
    bool operator>(const Set& coll);
 
    bool operator<(const Collection& coll);
 
    bool operator<=(const T& item);
 
 
    void join(const Set<T>& set);
 
    void meet(const Set<T>& set);
 
    void diff(const Set<T>& set);
 
    Set<T> operator+=(const Set<T> set);
 
    Set<T> operator|=(const Set<T> set);
 
    Set<T> operator-=(const Set<T> set);
 
    Set<T> operator&=(const Set<T> set);
 
    Set<T> operator*=(const Set<T> set);
 
    Set<T> operator+(const Set& set);
 
    Set<T> operator|(const Set& set);
 
    Set<T> operator*(const Set& set);
 
    Set<T> operator&(const Set& set);
 
    Set<T> operator-(const Set& set);
 
};
 
 
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);
    
};
 
 
template <class T>
class ExpandableArray: public  MutableArray<T>, public  MutableCollection<T> {
public:
 
    void shrink(int length);
 
    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& top();
 
    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 t::uint32 hash(const T& object);
    
    static bool equals(const T& object1, const T& object2);
 
    t::uint32 computeHash(const T& object);
 
    bool isEqual(const T& object1, const T& object2);
 
};
 
 
template <class T>
class Comparator {
public:
 
    static int compare(const T& object1, const T& object2);
 
    int doCompare(const T& object1, const T& object2);
 
};
 
 
template <class T>
class Equiv {
public:
    
    static bool equals(const T& val1, const T& val2);
 
    static bool isEqual(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<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 KeyIter: public Iter<K> {
    public:
    
        KeyIter(const Map<K, T>& map);
        
        KeyIter(const KeyIter& iter);
    };
    
    Iterable<KeyIter> keys() const;
 
    class PairIterator: public Iter<Pair<K, T> > {
    public:
    
        PairIterator(const Map<K, T>& map);
        
        PairIterator(const ValueIterator& iter);
    };
 
    Iterable<PairIter> pairs() const;
 
    const T& operator[](const K& k) const;
 
};
 
 
template <class K, class T>
class MutableMap: public Map<K, T> {
public:
    
    void clear();
 
    void put(const K& key, const T& value);
    
    void removeByKey(const K& key);
    
    void remove(const Collection<T>::Iter& iter);
 
    T& operator[](const K& k);
};
 
 
template <class T>
class List: public Collection<T> {
public:
    
    const T& first(void) const;
    
    const T& last(void) const;
    
    Iter<T> find(const T& item);
 
    Iter<T> find(const T& item, const Iterator& start);
 
    Iter<T> nth(int i);
 
    const T& operator[](int i) const;
 
};
 
 
template <class T>
class MutableList: public List<T>, public MutableCollection<T> {
public:
    
    T& first(void);
 
    T& last(void);
 
    void addFirst(const T& item);
    
    void addLast(const T& item);
    
    void removeFirst(void);
    
    void removeLast(void);
    
    void addAfter(const Iter<T>& pos, const T& item);
    
    void addBefore(const Iter<T>& pos, const T& item);
 
    void removeBefore(const Iter<T>& pos);
 
    void removeAfter(const Iter<T>& pos);
    
    void set(const Iterator<T>& pos, const T& item);
 
    T& operator[](int i);
 
};
 
 
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);
};
 
 
template <class T>
class Compare {
public:
        int compare(T v1, T v2);
};
 
 
template <class T>
class Predicate {
public:
 
    bool test(const T& item);
};
 
} } // elm::concept