Associative.h

Go to the documentation of this file.

/*
 * Copyright (C) 2015 Niek Linnenbank
 *
 * This program 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 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef __LIBSTD_ASSOCIATIVE_H
#define __LIBSTD_ASSOCIATIVE_H
 
#include "Container.h"
#include "Comparable.h"
#include "Types.h"
#include "Macros.h"
#include "List.h"
#include "ListIterator.h"
 
template <class K, class V> class Associative : public Container, public Comparable<Associative<K,V> >
{
  public:
 
    virtual bool insert(const K & key, const V & item)
    {
        return false;
    }
 
    virtual bool append(const K & key, const V & item)
    {
        return false;
    }
 
    virtual int remove(const K & key)
    {
        return 0;
    }
 
    virtual void clear()
    {
        List<K> k = keys();
 
        for (ListIterator<K> i(k); i.hasNext(); i++)
            remove(i.current());
    }
 
    virtual List<K> keys() const = 0;
 
    virtual List<K> keys(const V & value) const = 0;
 
    virtual bool contains(const K & key) const
    {
        return values(key).count() > 0;
    }
 
    virtual List<V> values() const = 0;
 
    virtual List<V> values(const K & key) const = 0;
 
    virtual const V * get(const K & key) const = 0;
 
    virtual const V & at(const K & key) const = 0;
 
    virtual const V value(const K & key, const V defaultValue = V()) const = 0;
 
    virtual int compareTo(const Associative<K,V> &a) const
    {
        Size sz = size();
        Size cnt = count();
        List<V> vals = a.values();
 
        // Size must be equal
        if (a.size() != sz)
            return a.size() - sz;
 
        // Count must be equal
        if (a.count() != cnt)
            return a.count() - cnt;
 
        // All elements must be equal
        for (ListIterator<V> i(values()); i.hasCurrent(); i++)
            if (!vals.contains(i.current()))
                return 1;
 
        return 0;
    }
 
    virtual bool equals(const Associative<K,V> &a) const
    {
        return compareTo(a) == 0;
    }
 
    const V & operator [] (K key) const
    {
        return at(key);
    }
};
 
#endif /* __LIBSTD_ASSOCIATIVE_H */