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

#include <Map.h>

Collaboration diagram for Minisat::Map< K, D, H, E >:

Data Structures
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

Private Member Functions
Map< K, D, H, E > &	operator= (Map< K, D, H, E > &other)
	Map (Map< K, D, H, E > &other)
bool	checkCap (int new_size) const
int32_t	index (const K &k) const
void	_insert (const K &k, const D &d)
void	rehash ()

Private Attributes
H	hash
E	equals
vec< Pair > *	table
int	cap
int	size

Detailed Description

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

Definition at line 56 of file Map.h.

Constructor & Destructor Documentation

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

Minisat::Map< K, D, H, E >::Map ( Map< K, D, H, E > &  other )

private

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

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

inline

Definition at line 102 of file Map.h.

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

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

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

inline

Definition at line 103 of file Map.h.

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

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

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

inline

Definition at line 104 of file Map.h.

{ delete [] table; }

Member Function Documentation

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

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

inlineprivate

Definition at line 75 of file Map.h.

                                            { 
        vec<Pair>& ps = table[index(k)];
        ps.push(); ps.last().key = k; ps.last().data = d; }

Here is the caller graph for this function:

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

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

inline

Definition at line 187 of file Map.h.

{ return table[i]; }

Here is the caller graph for this function:

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

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

inline

Definition at line 172 of file Map.h.

{ return cap; }

Here is the caller graph for this function:

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

bool Minisat::Map< K, D, H, E >::checkCap ( int  new_size ) const

inlineprivate

Definition at line 72 of file Map.h.

{ return new_size > cap; }

Here is the caller graph for this function:

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

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

inline

Definition at line 165 of file Map.h.

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

Here is the caller graph for this function:

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

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

inline

Definition at line 171 of file Map.h.

{ return size; }

Here is the caller graph for this function:

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

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

inline

Definition at line 144 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;
    }

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

int32_t Minisat::Map< K, D, H, E >::index ( const K &  k ) const

inlineprivate

Definition at line 74 of file Map.h.

{ return hash(k) % cap; }

Here is the caller graph for this function:

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

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

inline

Definition at line 133 of file Map.h.

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

Here is the caller graph for this function:

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

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

inline

Definition at line 175 of file Map.h.

                           {
        delete [] other.table;

        other.table = table;
        other.cap   = cap;
        other.size  = size;

        table = NULL;
        size = cap = 0;
    }

Here is the caller graph for this function:

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

Map<K,D,H,E>& Minisat::Map< K, D, H, E >::operator= ( Map< K, D, H, E > &  other )

private

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

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

inline

Definition at line 107 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;
    }

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

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

inline

Definition at line 120 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;
    }

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

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

inline

Definition at line 134 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;
    }

Here is the caller graph for this function:

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

void Minisat::Map< K, D, H, E >::rehash ( )

inlineprivate

Definition at line 79 of file Map.h.

                      {
        const vec<Pair>* old = table;

        int old_cap = cap;
        int newsize = primes[0];
        for (int i = 1; newsize <= cap && i < nprimes; i++)
           newsize = primes[i];

        table = new vec<Pair>[newsize];
        cap   = newsize;

        for (int i = 0; i < old_cap; i++){
            for (int j = 0; j < old[i].size(); j++){
                _insert(old[i][j].key, old[i][j].data); }}

        delete [] old;

        // printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize);
    }

Here is the caller graph for this function:

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

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

inline

Definition at line 154 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--;
    }

Here is the caller graph for this function:

Field Documentation

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

int Minisat::Map< K, D, H, E >::cap

private

Definition at line 65 of file Map.h.

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

E Minisat::Map< K, D, H, E >::equals

private

Definition at line 62 of file Map.h.

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

H Minisat::Map< K, D, H, E >::hash

private

Definition at line 61 of file Map.h.

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

int Minisat::Map< K, D, H, E >::size

private

Definition at line 66 of file Map.h.

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

vec<Pair>* Minisat::Map< K, D, H, E >::table

private

Definition at line 64 of file Map.h.

---

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

• Map.h