hashmap.hpp File Reference

#include "list.hpp"
#include "hashmap.ipp"
#include "hashmap_extra.ipp"

Include dependency graph for hashmap.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	hashentry< T, U >
	Hash entry template for key-value pairs. More...
class	hashmap_rep< T, U >
class	hashmap< T, U >
	A simple hashmap class implementation. More...

Macros
#define	TMPL   template <class T, class U>

Functions
template<class T , class U >
int	N (hashmap< T, U > h)
	Returns the size of the given hashmap.
template<class T , class U >
tm_ostream &	operator<< (tm_ostream &out, hashmap< T, U > h)
template<class T , class U >
hashmap< T, U >	copy (hashmap< T, U > h)
template<class T , class U >
hashmap< T, U >	changes (hashmap< T, U > patch, hashmap< T, U > base)
	Creates a new hashmap containing entries that have changed in the 'patch' compared to 'base'.
template<class T , class U >
hashmap< T, U >	invert (hashmap< T, U > patch, hashmap< T, U > base)
	Creates a new hashmap containing entries that are different in the 'patch' compared to 'base', but with values taken from 'base'.
template<class T , class U >
bool	operator== (hashmap< T, U > h1, hashmap< T, U > h2)
template<class T , class U >
bool	operator!= (hashmap< T, U > h1, hashmap< T, U > h2)
	CONCRETE_TEMPLATE_2_CODE (hashmap, class, T, class, U)

Macro Definition Documentation

TMPL

#define TMPL   template <class T, class U>

Definition at line 216 of file hashmap.hpp.

Function Documentation

N()

template<class T , class U >

int N ( hashmap< T, U > h )

inline

Returns the size of the given hashmap.

Template Parameters

T	The type of the key in the hashmap.
U	The type of the value in the hashmap.

Parameters

h	The hashmap whose size is to be determined.

Returns

The size of the hashmap.

Definition at line 227 of file hashmap.hpp.

                    {
  return h->size;
}

operator<<()

template<class T , class U >

tm_ostream & operator<<	(	tm_ostream &	out,
		hashmap< T, U >	h )

Definition at line 134 of file hashmap.ipp.

                                              {
  int i= 0, j= 0, n= h->n, size= h->size;
  out << "{ ";
  for (; i < n; i++) {
    list<hashentry<T, U>> l= h->a[i];
    for (; !is_nil (l); l= l->next, j++) {
      out << l->item;
      if (j != size - 1) out << ", ";
    }
  }
  out << " }";
  return out;
}

copy()

template<class T , class U >

hashmap< T, U > copy

(

hashmap< T, U >

h

)

Definition at line 81 of file hashmap_extra.ipp.

                            {
  int           i, n= h->n;
  hashmap<T, U> h2 (h->init, n, h->max);
  h2->size= h->size;
  for (i= 0; i < n; i++)
    h2->a[i]= copy_list (h->a[i]);
  return h2;
}

changes()

template<class T , class U >

hashmap< T, U > changes	(	hashmap< T, U >	patch,
		hashmap< T, U >	base )

Creates a new hashmap containing entries that have changed in the 'patch' compared to 'base'.

Template Parameters

T	The type of the key in the hashmap.
U	The type of the value in the hashmap.

Parameters

patch	The hashmap containing updated key-value pairs.
base	The original hashmap that serves as the reference.

Returns

A new hashmap containing only the entries that have changed from 'base' to 'patch'.

Definition at line 91 of file hashmap_extra.ipp.

                                                       {
  int           i;
  hashmap<T, U> h (base->init);
  for (i= 0; i < patch->n; i++) {
    list<hashentry<T, U>> l (patch->a[i]);
    while (!is_nil (l)) {
      if (l->item.im != base[l->item.key]) h (l->item.key)= l->item.im;
      l= l->next;
    }
  }
  return h;
}

invert()

template<class T , class U >

hashmap< T, U > invert	(	hashmap< T, U >	patch,
		hashmap< T, U >	base )

Creates a new hashmap containing entries that are different in the 'patch' compared to 'base', but with values taken from 'base'.

Template Parameters

T	The type of the key in the hashmap.
U	The type of the value in the hashmap.

Parameters

patch	The hashmap containing potentially updated key-value pairs.
base	The original hashmap that serves as the reference.

Returns

A new hashmap containing only the entries that are different in 'patch' but using the values from 'base'.

Definition at line 105 of file hashmap_extra.ipp.

                                                      {
  int           i;
  hashmap<T, U> h (base->init);
  for (i= 0; i < patch->n; i++) {
    list<hashentry<T, U>> l (patch->a[i]);
    while (!is_nil (l)) {
      if (l->item.im != base[l->item.key]) h (l->item.key)= base[l->item.key];
      l= l->next;
    }
  }
  return h;
}

operator==()

template<class T , class U >

bool operator==	(	hashmap< T, U >	h1,
		hashmap< T, U >	h2 )

Definition at line 160 of file hashmap.ipp.

                                                {
  if (h1->size != h2->size) return false;
  int i= 0, n= h1->n;
  for (; i < n; i++) {
    list<hashentry<T, U>> l= h1->a[i];
    for (; !is_nil (l); l= l->next)
      if (h2[l->item.key] != l->item.im) return false;
  }
  return true;
}

operator!=()

template<class T , class U >

bool operator!=	(	hashmap< T, U >	h1,
		hashmap< T, U >	h2 )

Definition at line 172 of file hashmap.ipp.

                                                {
  return !(h1 == h2);
}

CONCRETE_TEMPLATE_2_CODE()

CONCRETE_TEMPLATE_2_CODE	(	hashmap	,
		class	,
		T	,
		class	,
		U	)