// @ZBS {
//		*MODULE_OWNER_NAME zhashtable
// }

#ifndef ZHASHTABLE_H
#define ZHASHTABLE_H

// The HashTable class is a generic associative array
// that associate keys which are nul-terminate strings with
// generic buffers of arbitrary length.
//
// HashTables will automatically rebuild themselves when
// they get to dense which can be an expensive operation
// therefore it is best if you create them with an
// initial size roughly double what you expect will be used.

class ZHashTable {
  protected:
	int collisions;
		// Incremented each time the set() function collides.
		// Useful for profiling the hash function
	int initialSize;
		// How big the initial array is
	int hasAnyChanged;
		// Has anything in here changed since the last time this was cleared
	int hashTableSize;
		// Number of pointers in the hash table
	int numRecords;
		// Actual active records in the table
	char **hashTable;
		// Array of key pointers, which are of the form:
		// 1 byte flags:
		#define aaDELETED (0x01)
		#define aaCHANGED (0x02)
		// followed by 4 bytes val length
		// followed by nul-terminated key string
		// followed by data of arbitrary length

	unsigned int hash( char *key );
		// Hashing function. currently using the one from http://burtleburtle.net/bob/hash/doobs.html

	int internalSet( char **_hashTable, int _hashTableSize, char *key, char *_recPtr );
		// Internal method to functionalize rebuilds of tables
		// Returns 1 if the key is new, 0 if it is replacing an existing

  public:
	ZHashTable( int _initialSize=64 );
		// For optimal performance make _initialSize twice as big as expected size

	~ZHashTable();

	void clear();
		// kill everything, start fresh

	int size() { return hashTableSize; }
		// The size of the hashtable including empty records

	int activeCount() { return numRecords; }
		// The actual number of active records

	void copyFrom( ZHashTable &table );
		// Copies all the items from table.
		// Does *NOT* clear first, if you want to
		// start off fresh, call clear() first

	int lookup( char *key );
		// Returns the index of key, or -1 if it wasn't found

	// These the the i_th key.val pair in the table.
	// They are useful when traversing the entire contents
	// For example:
	// for( int i=0; i<table.size(); i++ ) {
	//     char *k = getKey( i );
	//     char *v = getValS( i );
	char  *getKey( int i );
	void  *getValP( int i, int &valLen );
	char  *getValS( int i );
	int    getValI( int i );
	float  getValF( int i );
	double getValD( int i );

	void  *getP( char *key, int &length );
		// This gets the raw value pointer and the associated length.
		// It does not use nul-termination like getS does.

	// Each of the following will get a key and return it as
	// a specified type by appropriate string to type routines
	// If the value is empty, it returns the specified default
	char  *getS( char *key, char *onEmpty=(char *)0 );

	// The following really call getS and use atof or strtol
	int    getI( char *key, int onEmpty=0 );
	float  getF( char *key, float onEmpty=0.f );
	double getD( char *key, double onEmpty=0.0 );

	// The following set hash record key with value, overwriting
	// any existing value is there is one.
	//
	// "len" is the length of the value, or -1 if it is 
	// a null terminated string whose len should
	// be calculated.
	//
	// The buffer pointed to by value is always copied into 
	// this buffer of len.  And will be deleted upon clear()
	//
	// Setting a key to NULL means you want to kill
	// the key.  Internally, it is marked as deleted.
	// Note that this only applies to putS()
	void putS( char *key, char *val, int len=-1 );

	// The following convert the number to a string and call putS()
	void putI( char *key, int val );
	void putF( char *key, float val );
	void putD( char *key, double val );

	void put( char *string );
		// This sets a series of key elements based on a standard
		// encoded string like: "key1=val1 key2='val 2' 'key 3'=val3"
		// Backslash is an escape char for quotes. Eg: set( "key='This string won\\'t fail'" )
		// Also, set( "key='This\\\\string\\\\has\\\\backslashes\\\\for\\\\spaces!'" )

	void del( char *key ) { putS( key, (char*)0 ); }

	// The hash table  keeps track of what has changed with a 
	// flag for each object.  This can be useful for loading and saving
	// differences, for example in the config system.
	int hasChanged();
	int hasChanged( int i );
	int hasChanged( char *key );
	void setChanged( int i );
	void setChanged( char *key );
	void clearChanged( int i );
	void clearChanged( char *key );
	void clearChangedAll();

	void dump();
		// Dumps the contents to OutputDebugString in Win32 or stdout in UNIX

};

ZHashTable *zHashTable( char *fmt, ... );
	// Given an encoded string (see parseString above) this
	// allocates a hashtable and fills it in with the key/vals 
	// in the sprintf formatted argument string and returns it.
	// Note that the buffer for this fmt is 512 bytes

#endif