361 lines
7.8 KiB
C
361 lines
7.8 KiB
C
/*
|
|
* CDE - Common Desktop Environment
|
|
*
|
|
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
|
*
|
|
* These libraries and programs are free software; you can
|
|
* redistribute them and/or modify them under the terms of the GNU
|
|
* Lesser General Public License as published by the Free Software
|
|
* Foundation; either version 2 of the License, or (at your option)
|
|
* any later version.
|
|
*
|
|
* These libraries and programs are distributed in the hope that
|
|
* they will be useful, but WITHOUT ANY WARRANTY; without even the
|
|
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU Lesser General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with these libraries and programs; if not, write
|
|
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
|
* Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
/*
|
|
* $XConsortium: data_t.cc /main/4 1996/07/18 14:31:45 drk $
|
|
*
|
|
* Copyright (c) 1993 HAL Computer Systems International, Ltd.
|
|
* All rights reserved. Unpublished -- rights reserved under
|
|
* the Copyright Laws of the United States. USE OF A COPYRIGHT
|
|
* NOTICE IS PRECAUTIONARY ONLY AND DOES NOT IMPLY PUBLICATION
|
|
* OR DISCLOSURE.
|
|
*
|
|
* THIS SOFTWARE CONTAINS CONFIDENTIAL INFORMATION AND TRADE
|
|
* SECRETS OF HAL COMPUTER SYSTEMS INTERNATIONAL, LTD. USE,
|
|
* DISCLOSURE, OR REPRODUCTION IS PROHIBITED WITHOUT THE
|
|
* PRIOR EXPRESS WRITTEN PERMISSION OF HAL COMPUTER SYSTEMS
|
|
* INTERNATIONAL, LTD.
|
|
*
|
|
* RESTRICTED RIGHTS LEGEND
|
|
* Use, duplication, or disclosure by the Government is subject
|
|
* to the restrictions as set forth in subparagraph (c)(l)(ii)
|
|
* of the Rights in Technical Data and Computer Software clause
|
|
* at DFARS 252.227-7013.
|
|
*
|
|
* HAL COMPUTER SYSTEMS INTERNATIONAL, LTD.
|
|
* 1315 Dell Avenue
|
|
* Campbell, CA 95008
|
|
*
|
|
*/
|
|
|
|
|
|
#include "dynhash/data_t.h"
|
|
|
|
//memory_pool data_t::data_t_space_pool;
|
|
|
|
extern memory_pool g_memory_pool;
|
|
|
|
#ifdef C_API
|
|
atoi_larson* data_t::larson_convertor_ptr;
|
|
atoi_pearson* data_t::pearson_convertor_ptr;
|
|
#else
|
|
atoi_larson data_t::larson_convertor;
|
|
atoi_pearson data_t::pearson_convertor(SHRT_MAX, 256);
|
|
#endif
|
|
|
|
data_t::data_t(data_t& d)
|
|
{
|
|
flag = d.flag;
|
|
dt = d.dt;
|
|
|
|
switch ( flag ) {
|
|
case INT:
|
|
{
|
|
key.int_key = d.key.int_key ;
|
|
flag = INT;
|
|
break;
|
|
}
|
|
case STRING:
|
|
{
|
|
int sz = strlen(d.key.str_key);
|
|
key.str_key = new char[sz+1];
|
|
*((char *) memcpy(key.str_key, d.key.str_key, sz) + sz) = '\0';
|
|
key.str_key[sz] = 0;
|
|
|
|
flag = STRING;
|
|
break;
|
|
}
|
|
case VOID:
|
|
flag = VOID;
|
|
}
|
|
}
|
|
|
|
|
|
/* // inline
|
|
data_t::data_t(int t, voidPtr d) : dt(d)
|
|
{
|
|
flag = data_t::INT;
|
|
key.int_key = t;
|
|
}
|
|
*/
|
|
|
|
data_t::data_t(const char* str, int sz, voidPtr d) : dt(d)
|
|
{
|
|
flag = data_t::STRING;
|
|
|
|
key.str_key = new char[sz+1];
|
|
|
|
if ( sz > 0 ) {
|
|
int len = MIN(strlen(str), (unsigned int) sz);
|
|
*((char *) memcpy(key.str_key, str, len) + len) = '\0';
|
|
}
|
|
|
|
key.str_key[sz] = 0;
|
|
}
|
|
|
|
/*
|
|
int data_t::size()
|
|
{
|
|
switch ( flag ) {
|
|
case INT:
|
|
case VOID:
|
|
return 2 + strlen(form("%d", key.int_key)) + sizeof(dt);
|
|
|
|
case STRING:
|
|
return 2 + strlen(key.str_key) + sizeof(dt);
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
int data_t::operator==(data_t& d)
|
|
{
|
|
if ( flag != d.flag ) {
|
|
|
|
debug(cerr, flag);
|
|
debug(cerr, d.flag);
|
|
|
|
debug(cerr, *this);
|
|
debug(cerr, d);
|
|
|
|
throw(stringException("data_t type mismatches in operator==()"));
|
|
}
|
|
|
|
switch (flag) {
|
|
case INT:
|
|
return key.int_key == d.key.int_key ;
|
|
case STRING:
|
|
return strcmp(key.str_key, d.key.str_key) == 0 ;
|
|
case VOID:
|
|
throw(stringException("VOID type in operator==()"));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
data_t& data_t::operator =(data_t& d)
|
|
{
|
|
flag = d.flag;
|
|
dt = d.dt;
|
|
|
|
switch ( flag ) {
|
|
case INT:
|
|
key.int_key = d.key.int_key ;
|
|
flag = INT;
|
|
break;
|
|
|
|
case STRING:
|
|
{
|
|
unsigned int d_sz = strlen(d.key.str_key);
|
|
if ( strlen(key.str_key) < d_sz ) {
|
|
delete key.str_key;
|
|
key.str_key = new char[d_sz+1];
|
|
}
|
|
*((char *) memcpy(key.str_key, d.key.str_key, d_sz) + d_sz) = '\0';
|
|
flag = STRING;
|
|
break;
|
|
}
|
|
case VOID:
|
|
flag = VOID;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
data_t::~data_t()
|
|
{
|
|
switch ( flag ) {
|
|
case INT:
|
|
break;
|
|
case STRING:
|
|
delete key.str_key;
|
|
break;
|
|
case VOID:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static char buf[BUFSIZ];
|
|
|
|
istream& operator >>(istream& i, data_t& d)
|
|
{
|
|
if ( !i.getline(buf, BUFSIZ) || buf[0] == '\n' )
|
|
return i;
|
|
|
|
char* key_ptr = strchr(buf, '\t');
|
|
char* voidPtr_ptr = strrchr(buf, '\t');
|
|
|
|
*key_ptr = 0;
|
|
*voidPtr_ptr = 0;
|
|
|
|
key_ptr++;
|
|
voidPtr_ptr++;
|
|
|
|
//////////////////////////
|
|
// delete the string
|
|
//////////////////////////
|
|
if ( d.flag == data_t::STRING )
|
|
delete d.key.str_key;
|
|
|
|
d.flag = (data_t::flag_type)atoi(buf);
|
|
d.dt = (voidPtr)(size_t)atoi(voidPtr_ptr);
|
|
|
|
if ( d.flag == data_t::INT )
|
|
d.key.int_key = atoi(key_ptr);
|
|
else
|
|
if ( d.flag == data_t::STRING ) {
|
|
int sz = strlen(key_ptr);
|
|
d.key.str_key = new char[sz+1];
|
|
*((char *) memcpy(d.key.str_key, key_ptr, sz) + sz) = '\0';
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
ostream& operator <<(ostream& o, data_t& d)
|
|
{
|
|
if ( d.flag == data_t::VOID )
|
|
return o;
|
|
|
|
o << d.flag << " ";
|
|
|
|
switch ( d.flag ) {
|
|
case data_t::INT:
|
|
o << d.key.int_key;
|
|
break;
|
|
case data_t::STRING:
|
|
o << d.key.str_key;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
o << " " << (long)(d.dt);
|
|
return o;
|
|
}
|
|
|
|
Boolean data_t::binaryIn(buffer& buf)
|
|
{
|
|
char c; buf.get(c);
|
|
flag = (data_t::flag_type)c;
|
|
char* cp;
|
|
|
|
unsigned int sz;
|
|
|
|
switch ( flag ) {
|
|
case data_t::VOID:
|
|
break;
|
|
|
|
case data_t::INT:
|
|
buf.get(*(unsigned int*)&key.int_key);
|
|
break;
|
|
|
|
case data_t::STRING:
|
|
|
|
buf.get(sz);
|
|
key.str_key = new char[sz+1];
|
|
buf.get(key.str_key, sz);
|
|
key.str_key[sz] = 0;
|
|
|
|
break;
|
|
}
|
|
cp = (char*)&dt;
|
|
buf.get(*(long*)cp);
|
|
return true;
|
|
}
|
|
|
|
Boolean data_t::binaryOut(buffer& buf)
|
|
{
|
|
buf.put((char)flag);
|
|
unsigned int sz;
|
|
|
|
switch ( flag ) {
|
|
case data_t::VOID:
|
|
break;
|
|
|
|
case data_t::INT:
|
|
buf.put((unsigned int)key.int_key);
|
|
break;
|
|
|
|
case data_t::STRING:
|
|
sz = strlen(key.str_key);
|
|
|
|
buf.put(sz);
|
|
buf.put(key.str_key, sz);
|
|
|
|
|
|
break;
|
|
}
|
|
buf.put((long)dt);
|
|
return true;
|
|
}
|
|
|
|
ostream& data_t::asciiOut(ostream& o, print_func_ptr_t print_f)
|
|
{
|
|
print_f(o, this);
|
|
return o;
|
|
}
|
|
|
|
int data_t::bucket_num(int k, int p, int M)
|
|
{
|
|
switch ( flag ) {
|
|
case INT:
|
|
return abs( key.int_key * k ) % p % M ;
|
|
case STRING:
|
|
//return abs( larson_convertor.atoi(key.str_key) * k ) % p % M ;
|
|
//return abs( pearson_convertor.atoi(key.str_key, strlen(key.str_key), k
|
|
return abs( pearson_convertor.atoi(key.str_key, strlen(key.str_key), k
|
|
, p) ) % M ;
|
|
default:
|
|
throw(stringException("VOID type in bucket_num()"));
|
|
}
|
|
}
|
|
|
|
int data_t::slot_num(int k, int rotate, int prime, int M )
|
|
{
|
|
int x;
|
|
switch ( flag ) {
|
|
case INT:
|
|
x = ( abs( k * key.int_key ) % prime + rotate ) % M ;
|
|
break;
|
|
case STRING:
|
|
x = ( abs( pearson_convertor.atoi(key.str_key, strlen(key.str_key), k, prime)) + rotate ) % M ;
|
|
break;
|
|
default:
|
|
throw(stringException("VOID type in slot_num()"));
|
|
}
|
|
return x;
|
|
}
|
|
|
|
void* data_t::operator new( size_t x )
|
|
{
|
|
//return (void*)data_t_space_pool.alloc(x);
|
|
return (void*)(g_memory_pool).alloc(x);
|
|
}
|
|
|
|
void data_t::operator delete( void* ptr )
|
|
{
|
|
//data_t_space_pool.free((char*)ptr);
|
|
(g_memory_pool).free((char*)ptr);
|
|
}
|
|
|