hashmap_extra.ipp File Reference

#include "hashmap.hpp"

Include dependency graph for hashmap_extra.ipp:

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

Go to the source code of this file.

Macros
#define	HASHMAP_EXTRA_CC
#define	TMPL   template <class T, class U>
#define	H   hashentry<T, U>

Functions
template<class T , class U >
list< hashentry< T, U > >	copy_list (list< hashentry< T, U > > l)
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'.

Macro Definition Documentation

HASHMAP_EXTRA_CC

#define HASHMAP_EXTRA_CC

Definition at line 13 of file hashmap_extra.ipp.

TMPL

#define TMPL   template <class T, class U>

Definition at line 16 of file hashmap_extra.ipp.

H

#define H   hashentry<T, U>

Definition at line 17 of file hashmap_extra.ipp.

Function Documentation

copy_list()

template<class T , class U >

list< hashentry< T, U > > copy_list

(

list< hashentry< T, U > >

l

)

Definition at line 72 of file hashmap_extra.ipp.

                                         {
  if (is_nil (l)) return l;
  else
    return list<hashentry<T, U>> (
        hashentry<T, U> (l->item.code, l->item.key, l->item.im),
        copy_list (l->next));
}

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;
}