kolibrios/contrib/media/updf/include/lisphash.h
right-hearted 4f7ee97ec9 uPDF with buttons
git-svn-id: svn://kolibrios.org@4680 a494cfbc-eb01-0410-851d-a64ba20cac60
2014-03-22 21:00:40 +00:00

102 lines
3.2 KiB
C++

/** \file lisphash.h
* hashing of strings. Each string will exist only once in the
* hash table, and have an unique id.
*/
#ifndef __lisphash_h__
#define __lisphash_h__
#include "yacasbase.h"
#include "grower.h"
#include "lispstring.h"
const LispInt KSymTableSize = 211;
LispInt LispHash( const char *s );
LispInt LispHashCounted( const char *s, LispInt length );
LispInt LispHashStringify( const char *s );
LispInt LispHashUnStringify( const char *s );
LispInt LispHashPtr(const LispString * aString); // hash the *address*!
/**
* This is the symbol table, implemented as a hash table for fast
* lookup. It is meant to store any string just once, have fast
* searching for strings and return a reference to the string.
* This also allows fast comparison of two strings (two strings
* are equal iff the pointers to the strings are equal).
*/
class LispHashTable : public YacasBase
{
public:
LispHashTable() {}
~LispHashTable();
// If string not yet in table, insert. Afterwards return the string.
LispString * LookUp(const LispChar * aString, LispBoolean aStringOwnedExternally=LispFalse);
/// LookUp that takes ownership of the string
LispString * LookUp(LispString * aString);
LispString * LookUpCounted(LispChar * aString,LispInt aLength);
LispString * LookUpStringify(LispChar * aString, LispBoolean aStringOwnedExternally=LispFalse);
LispString * LookUpUnStringify(LispChar * aString, LispBoolean aStringOwnedExternally=LispFalse);
void GarbageCollect();
private:
void AppendString(LispInt bin,LispString * result);
private:
CArrayGrower<LispStringSmartPtr, ArrOpsCustomObj<LispStringSmartPtr> > iHashTable[KSymTableSize];
};
/** VoidGrow is a helper class for LispAssociatedHash
*/
class VoidGrow : public CArrayGrower<void*, ArrOpsCustomPtr<void> >
{
};
/** LispAssociatedHash allows you to associate arbitrary
* information with a string in the above hash table. You can
* specify what type of information to link to the string, and
* this class then stores that information for a string. It is
* in a sense a way to extend the string object without modifying
* the string class itself. This class does not own the strings it
* points to, but instead relies on the fact that the strings
* are maintained in a hash table (like LispHashTable above).
*/
template<class T>
class LispAssociatedHash : public YacasBase
{
public:
/// Find the data associated to \a aString.
/// If \a aString is not stored in the hash table, this function
/// returns #NULL.
inline T* LookUp(LispString * aString);
/// Add an association to the hash table.
/// If \a aString is already stored in the hash table, its
/// association is changed to \a aData. Otherwise, a new
/// association is added.
inline void SetAssociation(const T& aData, LispString * aString);
/// Delete an association from the hash table.
inline void Release(LispString * aString);
protected:
/** The destructor is made protected because we do not want the outside world to directly
* call this destructor. The alternative would be to make the destructor virtual.
*/
inline ~LispAssociatedHash();
private:
// The next array is in fact an array of arrays of type LAssoc<T>
VoidGrow iHashTable[KSymTableSize];
};
#include "lisphash.inl"
#endif