|
// MemoryMag.h
#ifndef __MEMORY_MAG_H__
#define __MEMORY_MAG_H__
#include <stdio.h>
#include <assert.h>
template <class T>
class CMemoryMag
{
public:
CMemoryMag(int size);
~CMemoryMag();
T *GetNew();
int Free(T *var);
private:
T *m_data;
int *m_freed;
int m_freedSize;
int m_maxSize;
int m_curSize;
};
template<class T>
CMemoryMag<T>::CMemoryMag(int size) :
m_maxSize(size),
m_curSize(0),
m_freedSize(0)
{
m_data = new T[size];
assert(m_data != NULL);
m_freed = new int[size];
assert(m_freed != NULL);
}
template<class T>
CMemoryMag<T>::~CMemoryMag()
{
delete [] m_data;
delete [] m_freed;
}
template<class T>
T *CMemoryMag<T>::GetNew()
{
if(!m_freedSize)
{
if(m_curSize < m_maxSize)
return &m_data[m_curSize++];
return NULL;
}
return &m_data[m_freed[--m_freedSize]];
}
template<class T>
int CMemoryMag<T>::Free(T *var)
{
int i,j;
int found = 0;
for(j=0; j<m_freedSize; j++)
if(&m_data[m_freed[j]] == var) found = 1;
if(found) return 0;
for(i=0; i<m_curSize; i++)
{
if(&m_data[i] == var)
{
found = i;
break;
}
}
if(!found) return 0;
if(found != (m_curSize - 1))
{
m_freed[m_freedSize++] = found;
return 1;
}
m_curSize --;
return 1;
}
#endif
==================================================
//然后你需要一个hash表
//hasher.h
#ifndef __HASHER_H__
#define __HASHER_H__
#include "MemoryMag.h"
class CHasher
{
public:
CHasher(int size);
~CHasher();
int Enter(const char *pStr, void *node);
int Remove(const char *pStr);
void *Find(const char *pStr);
private:
int GetHash(const char *pStr);
typedef struct hashNode
{
char *name;
void *ptr;
struct hashNode *next;
} HASHNODE;
CMemoryMag<HASHNODE> *m_hashArr;
HASHNODE **m_hashTable;
int m_h;
int m_objTable;
int m_size;
};
#endif
==================================================
//hasher.cpp
#include "Hasher.h"
#include <string>
static int T[] =
{
1, 87, 49, 12, 176, 178, 102, 166, 121, 193, 6, 84, 249, 230, 44, 163,
14, 197, 213, 181, 161, 85, 218, 80, 64, 239, 24, 226, 236, 142, 38, 200,
110, 177, 104, 103, 141, 253, 255, 50, 77, 101, 81, 18, 45, 96, 31, 222,
25, 107, 190, 70, 86, 237, 240, 34, 72, 242, 20, 214, 244, 227, 149, 235,
97, 234, 57, 22, 60, 250, 82, 175, 208, 5, 127, 199, 111, 62, 135, 248,
174, 169, 211, 58, 66, 154, 106, 195, 245, 171, 17, 187, 182, 179, 0, 243,
132, 56, 148, 75, 128, 133, 158, 100, 130, 126, 91, 13, 153, 246, 216, 219,
119, 68, 223, 78, 83, 88, 201, 99, 122, 11, 92, 32, 136, 114, 52, 10,
138, 30, 48, 183, 156, 35, 61, 26, 143, 74, 251, 94, 129, 162, 63, 152,
170, 7, 115, 167, 241, 206, 3, 150, 55, 59, 151, 220, 90, 53, 23, 131,
125, 173, 15, 238, 79, 95, 89, 16, 105, 137, 225, 224, 217, 160, 37, 123,
118, 73, 2, 157, 46, 116, 9, 145, 134, 228, 207, 212, 202, 215, 69, 229,
27, 188, 67, 124, 168, 252, 42, 4, 29, 108, 21, 247, 19, 205, 39, 203,
233, 40, 186, 147, 198, 192, 155, 33, 164, 191, 98, 204, 165, 180, 117, 76,
140, 36, 210, 172, 41, 54, 159, 8, 185, 232, 113, 196, 231, 47, 146, 120,
51, 65, 28, 144, 254, 221, 93, 189, 194, 139, 112, 43, 71, 109, 184, 209,
};
int hashstr(const char * s, int maxn)
{
register unsigned char oh, h;
register unsigned char *p;
register int i;
if (!*s) return 0;
p = (unsigned char *) s;
oh = T[*p];
h = (*(p++) + 1) & 0xff;
for (i = maxn - 1; *p && --i >= 0; ) {
oh = T[oh ^ *p];
h = T[h ^ *(p++)];
}
return (oh << 8) + h;
}
inline int CHasher::GetHash(const char *pStr)
{
return hashstr(pStr, 16) & m_objTable;
}
CHasher::CHasher(int size) :
m_hashArr(NULL),
m_size(size)
{
int realSize;
for (realSize = 1; realSize < size; realSize *= 2);
m_objTable = realSize - 1;
m_hashArr = new CMemoryMag<HASHNODE>(realSize);
m_hashTable = new HASHNODE*[size];
}
CHasher::~CHasher()
{
delete m_hashArr;
while(m_size --)
{
HASHNODE *next = m_hashTable[m_size];
while(next)
{
if(next->name != NULL)
{
delete [] next->name;
next->name = NULL;
}
next = next->next;
}
}
delete []m_hashTable;
}
char *GetNewStr(const char *pStr)
{
int len(strlen(pStr));
if(len >= 0)
{
char *p = new char[len];
assert(p != NULL);
memcpy(p, pStr, len);
return p;
}
return NULL;
}
int CHasher::Enter(const char *pStr, void *node)
{
HASHNODE *newNode = m_hashArr->GetNew();
int n = GetHash(pStr);
newNode->next = m_hashTable[n];
newNode->ptr = node;
newNode->name = GetNewStr(pStr);
newNode->next = m_hashTable[n];
m_hashTable[n] = newNode;
return 1;
}
void *CHasher::Find(const char *pStr)
{
int n = GetHash(pStr);
HASHNODE *node = m_hashTable[n];
while(node)
{
if(!strcmp(node->name, pStr)) return node->ptr;
node = node->next;
}
return NULL;
}
int CHasher::Remove(const char *pStr)
{
HASHNODE *prev, *curr;
m_h = GetHash(pStr);
curr = m_hashTable[m_h];
prev = 0;
while (curr) {
if (!strcmp(curr->name, pStr))
{
if (prev) prev->next = curr->next;
delete [] curr->name;
curr->name = NULL;
m_hashArr->Free(curr);
return 1;
}
prev = curr;
curr = curr->next;
}
return 0;
}
//然后看看FSM（Finite Status Machine）
//fsm.h
// Finite State Machine
#ifndef __MYFSM_H__
#define __MYFSM_H__
#define FSM_D (CFiniteStateMachine::GetInstance())
#define MAX_VARIABLE_NUM 512
#include "Hasher.h"
class CFiniteStateMachine
{
public:
CFiniteStateMachine();
~CFiniteStateMachine();
static CFiniteStateMachine *GetInstance();
int Set(const char *varName, void *varvalue);
void* Get(const char *varName);
private:
CHasher m_hasher;
static CFiniteStateMachine *m_myInstance;
};
#endif
================================================
//以及FSM的实现
#include "FSM.h"
CFiniteStateMachine *CFiniteStateMachine::m_myInstance = NULL;
CFiniteStateMachine *CFiniteStateMachine::GetInstance()
{
if(m_myInstance == NULL)
{
m_myInstance = new CFiniteStateMachine();
return m_myInstance;
}
return m_myInstance;
}
CFiniteStateMachine::CFiniteStateMachine() :
m_hasher(MAX_VARIABLE_NUM)
{
}
CFiniteStateMachine::~CFiniteStateMachine()
{
}
int CFiniteStateMachine::Set(const char *varName, void *varvalue)
{
if(m_hasher.Find(varName) != NULL)
{
m_hasher.Remove(varName);
return m_hasher.Enter(varName, varvalue);
}
return m_hasher.Enter(varName, varvalue);
}
void* CFiniteStateMachine::Get(const char *varName)
{
void *var;
if((var = m_hasher.Find(varName)) != NULL) return var;
return NULL;
}
|