Gluco2::Map< K, D, H, E > Class Template Reference

#include <Map.h>

Classes
struct	Pair

Public Member Functions
	Map ()
	Map (const H &h, const E &e)
	~Map ()
const D &	operator[] (const K &k) const
D &	operator[] (const K &k)
void	insert (const K &k, const D &d)
bool	peek (const K &k, D &d) const
bool	has (const K &k) const
void	remove (const K &k)
void	clear ()
int	elems () const
int	bucket_count () const
void	moveTo (Map &other)
const vec< Pair > &	bucket (int i) const

Detailed Description

template<class K, class D, class H = Hash<K>, class E = Equal<K>>
class Gluco2::Map< K, D, H, E >

Definition at line 58 of file Map.h.

Constructor & Destructor Documentation

Map() [1/2]

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

Gluco2::Map< K, D, H, E >::Map ( )

inline

Definition at line 104 of file Map.h.

: table(NULL), cap(0), size(0) {}

Map() [2/2]

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

Gluco2::Map< K, D, H, E >::Map ( const H & h, const E & e )

inline

Definition at line 105 of file Map.h.

: hash(h), equals(e), table(NULL), cap(0), size(0){}

~Map()

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

Gluco2::Map< K, D, H, E >::~Map ( )

inline

Definition at line 106 of file Map.h.

{ delete [] table; }

Member Function Documentation

bucket()

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

const vec< Pair > & Gluco2::Map< K, D, H, E >::bucket ( int i ) const

inline

Definition at line 189 of file Map.h.

{ return table[i]; }

bucket_count()

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

int Gluco2::Map< K, D, H, E >::bucket_count ( ) const

inline

Definition at line 174 of file Map.h.

{ return cap; }

clear()

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

void Gluco2::Map< K, D, H, E >::clear ( )

inline

Definition at line 167 of file Map.h.

                   {
        cap = size = 0;
        delete [] table;
        table = NULL;
    }

elems()

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

int Gluco2::Map< K, D, H, E >::elems ( ) const

inline

Definition at line 173 of file Map.h.

{ return size; }

has()

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

bool Gluco2::Map< K, D, H, E >::has ( const K & k ) const

inline

Definition at line 146 of file Map.h.

                                  {
        if (size == 0) return false;
        const vec<Pair>& ps = table[index(k)];
        for (int i = 0; i < ps.size(); i++)
            if (equals(ps[i].key, k))
                return true;
        return false;
    }

insert()

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

void Gluco2::Map< K, D, H, E >::insert ( const K & k, const D & d )

inline

Definition at line 135 of file Map.h.

{ if (checkCap(size+1)) rehash(); _insert(k, d); size++; }

moveTo()

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

void Gluco2::Map< K, D, H, E >::moveTo ( Map< K, D, H, E > & other )

inline

Definition at line 177 of file Map.h.

                           {
        delete [] other.table;
 
        other.table = table;
        other.cap   = cap;
        other.size  = size;
 
        table = NULL;
        size = cap = 0;
    }

operator[]() [1/2]

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

D & Gluco2::Map< K, D, H, E >::operator[] ( const K & k )

inline

Definition at line 122 of file Map.h.

    {
        assert(size != 0);
        D*         res = NULL;
        vec<Pair>& ps  = table[index(k)];
        for (int i = 0; i < ps.size(); i++)
            if (equals(ps[i].key, k))
                res = &ps[i].data;
        assert(res != NULL);
        return *res;
    }

operator[]() [2/2]

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

const D & Gluco2::Map< K, D, H, E >::operator[] ( const K & k ) const

inline

Definition at line 109 of file Map.h.

    {
        assert(size != 0);
        const D*         res = NULL;
        const vec<Pair>& ps  = table[index(k)];
        for (int i = 0; i < ps.size(); i++)
            if (equals(ps[i].key, k))
                res = &ps[i].data;
        assert(res != NULL);
        return *res;
    }

peek()

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

bool Gluco2::Map< K, D, H, E >::peek ( const K & k, D & d ) const

inline

Definition at line 136 of file Map.h.

                                         {
        if (size == 0) return false;
        const vec<Pair>& ps = table[index(k)];
        for (int i = 0; i < ps.size(); i++)
            if (equals(ps[i].key, k)){
                d = ps[i].data;
                return true; } 
        return false;
    }

remove()

template<class K, class D, class H = Hash<K>, class E = Equal<K>>

void Gluco2::Map< K, D, H, E >::remove ( const K & k )

inline

Definition at line 156 of file Map.h.

                            {
        assert(table != NULL);
        vec<Pair>& ps = table[index(k)];
        int j = 0;
        for (; j < ps.size() && !equals(ps[j].key, k); j++);
        assert(j < ps.size());
        ps[j] = ps.last();
        ps.pop();
        size--;
    }

---

The documentation for this class was generated from the following file:

• src/sat/glucose2/Map.h