//Public interfaces for Finding a Node by its value from the HashTable //On SUCCESS returns the Node; NULL otherwise Node* HashTable::Find(const string& aValue) const { Node* pNode = NULL; size_t hashIndex = 0; hashIndex = HashIndex(aValue); pNode = iTable[hashIndex].Find(aValue); return pNode; }
static int InsertHash(Socket sd) { int i; IPAddress temp_addr; if(!HashIndex(sd, &i, &temp_addr)) { FAIL("InsertHash: can't insert addr (failed getpeername)\n"); } Addrs[i] = temp_addr; Pkt_to[i].timeout = PKTTIMEOUT; return(1); }
/* ======================== idLZWCompressor::AddToDict ======================== */ int idLZWCompressor::AddToDict( int w, int k ) { assert( w < 0xFFFF - 1 ); assert( k < 256 ); assert( lzwData->nextCode < lzwCompressionData_t::LZW_DICT_SIZE ); lzwData->dictionaryK[lzwData->nextCode] = (uint8)k; lzwData->dictionaryW[lzwData->nextCode] = (uint16)w; int i = HashIndex( w, k ); nextHash[lzwData->nextCode] = hash[i]; hash[i] = (uint16)lzwData->nextCode; return lzwData->nextCode++; }
Node* HashTable::Find(const char* pValue) const { Node* pNode = NULL; size_t hashIndex = 0; string val(pValue); if (pValue) { hashIndex = HashIndex(val); pNode = iTable[hashIndex].Find(val); } return pNode; }
//Public interfaces for Removing a Node by its value from the HashTable //On SUCCESS returns true; false otherwise bool HashTable::Remove(const string& aValue) { bool bSuccess = false; size_t hashIndex = 0; hashIndex = HashIndex(aValue); bSuccess = iTable[hashIndex].Remove(aValue); if (bSuccess) { iLength--; } return bSuccess; }
bool HashTable::Insert(const string& aValue) { bool bSuccess = false; size_t hashIndex = 0; hashIndex = HashIndex(aValue); bSuccess = iTable[hashIndex].Insert(aValue); if (bSuccess) { iLength++; } return bSuccess; }
//Public interfaces for Inserting a Node to the HashTable //On SUCCESS returns true; false otherwise bool HashTable::Insert(Node* pNode, bool bOwnIt) { bool bSuccess = false; size_t hashIndex = 0; if (pNode) { hashIndex = HashIndex(pNode->Value()); bSuccess = iTable[hashIndex].Insert(pNode, bOwnIt); if (bSuccess) { iLength++; } } return bSuccess; }
double PktTimeOut(Socket sd) { int hashindex; IPAddress temp_addr; double time_out; /* XXX check to see if this peer is indexed already */ time_out = HashIndex(sd, &hashindex, &temp_addr) ? Pkt_to[hashindex].timeout : PKTTIMEOUT; if(time_out == 0) time_out = PKTTIMEOUT; return(time_out); }
/* ======================== idLZWCompressor::Lookup ======================== */ int idLZWCompressor::Lookup( int w, int k ) { if ( w == -1 ) { return k; } else { int i = HashIndex( w, k ); for ( int j = hash[i]; j != 0xFFFF; j = nextHash[j] ) { assert( j < lzwCompressionData_t::LZW_DICT_SIZE ); if ( lzwData->dictionaryK[j] == k && lzwData->dictionaryW[j] == w ) { return j; } } } return -1; }
void SetPktTimeOut(Socket sd, double duration, int timedOut) { IPAddress addr; double dev; double err; double est; int hashindex; double timeout; if(HashIndex(sd,&hashindex, &addr) == 0) { WARN("SetPktTimeOut: HashIndex failed (getpeername)\n"); return; } est = Pkt_to[hashindex].est; dev = Pkt_to[hashindex].dev; err = est - duration; if(err < 0.0) err = err * -1.0; est = est + PGAIN * (duration - est); if(timedOut) est++; dev = dev + PGAIN * (err - dev); if(dev < 0.0) dev = -1.0 * dev; timeout = est + 2 * dev; Pkt_to[hashindex].est = est; Pkt_to[hashindex].dev = dev; if(timeout < MINPKTTIMEOUT) timeout = MINPKTTIMEOUT; if(timeout > MAXPKTTIMEOUT) timeout = MAXPKTTIMEOUT; Pkt_to[hashindex].timeout = timeout; }
bool HashTable::Remove(const char* pValue) { bool bSuccess = false; size_t hashIndex = 0; string val(pValue); if (pValue) { hashIndex = HashIndex(val); bSuccess = iTable[hashIndex].Remove(val); if (bSuccess) { iLength--; } } return bSuccess; }