cde/programs/dtinfo/DtMmdb/dynhash/data_t.C

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /*
  24  * $XConsortium: data_t.cc /main/4 1996/07/18 14:31:45 drk $
  25  *
  26  * Copyright (c) 1993 HAL Computer Systems International, Ltd.
  27  * All rights reserved.  Unpublished -- rights reserved under
  28  * the Copyright Laws of the United States.  USE OF A COPYRIGHT
  29  * NOTICE IS PRECAUTIONARY ONLY AND DOES NOT IMPLY PUBLICATION
  30  * OR DISCLOSURE.
  31  *
  32  * THIS SOFTWARE CONTAINS CONFIDENTIAL INFORMATION AND TRADE
  33  * SECRETS OF HAL COMPUTER SYSTEMS INTERNATIONAL, LTD.  USE,
  34  * DISCLOSURE, OR REPRODUCTION IS PROHIBITED WITHOUT THE
  35  * PRIOR EXPRESS WRITTEN PERMISSION OF HAL COMPUTER SYSTEMS
  36  * INTERNATIONAL, LTD.
  37  *
  38  *                         RESTRICTED RIGHTS LEGEND
  39  * Use, duplication, or disclosure by the Government is subject
  40  * to the restrictions as set forth in subparagraph (c)(l)(ii)
  41  * of the Rights in Technical Data and Computer Software clause
  42  * at DFARS 252.227-7013.
  43  *
  44  *          HAL COMPUTER SYSTEMS INTERNATIONAL, LTD.
  45  *                  1315 Dell Avenue
  46  *                  Campbell, CA  95008
  47  *
  48  */
  49
  50
  51 #include "dynhash/data_t.h"
  52
  53 //memory_pool data_t::data_t_space_pool;
  54
  55 extern memory_pool g_memory_pool;
  56
  57 #ifdef C_API
  58 atoi_larson* data_t::larson_convertor_ptr;
  59 atoi_pearson* data_t::pearson_convertor_ptr;
  60 #else
  61 atoi_larson data_t::larson_convertor;
  62 atoi_pearson data_t::pearson_convertor(SHRT_MAX, 256);
  63 #endif
  64
  65 data_t::data_t(data_t& d)
  66 {
  67    flag = d.flag;
  68    dt = d.dt;
  69
  70    switch ( flag ) {
  71       case INT:
  72       {
  73         key.int_key = d.key.int_key ;
  74         flag = INT;
  75         break;
  76       }
  77       case STRING:
  78       {
  79         int sz = strlen(d.key.str_key);
  80         key.str_key = new char[sz+1];
  81         *((char *) memcpy(key.str_key, d.key.str_key, sz) + sz) = '\0';
  82         key.str_key[sz] = 0;
  83
  84         flag = STRING;
  85         break;
  86       }
  87       case VOID:
  88         flag = VOID;
  89    }
  90 }
  91
  92
  93 /* // inline
  94 data_t::data_t(int t, voidPtr d) : dt(d)
  95 {
  96    flag = data_t::INT;
  97    key.int_key = t;
  98 }
  99 */
 100
 101 data_t::data_t(const char* str, int sz, voidPtr d) : dt(d)
 102 {
 103    flag = data_t::STRING;
 104
 105    key.str_key = new char[sz+1];
 106
 107    if ( sz > 0 ) {
 108       int len = MIN(strlen(str), (unsigned int) sz);
 109       *((char *) memcpy(key.str_key, str, len) + len) = '\0';
 110    }
 111
 112    key.str_key[sz] = 0;
 113 }
 114
 115 /*
 116 int data_t::size()
 117 {
 118    switch ( flag ) {
 119       case INT:
 120       case VOID:
 121         return 2 + strlen(form("%d", key.int_key)) + sizeof(dt);
 122
 123       case STRING:
 124         return 2 + strlen(key.str_key) + sizeof(dt);
 125    }
 126 }
 127 */
 128
 129
 130 int data_t::operator==(data_t& d)
 131 {
 132    if ( flag != d.flag ) {
 133
 134       debug(cerr, flag);
 135       debug(cerr, d.flag);
 136
 137       debug(cerr, *this);
 138       debug(cerr, d);
 139
 140       throw(stringException("data_t type mismatches in operator==()"));
 141    }
 142
 143    switch (flag) {
 144       case INT:
 145         return key.int_key == d.key.int_key ;
 146       case STRING:
 147         return strcmp(key.str_key, d.key.str_key) == 0 ;
 148       case VOID:
 149         throw(stringException("VOID type in operator==()"));
 150    }
 151
 152    return 0;
 153 }
 154
 155 data_t& data_t::operator =(data_t& d)
 156 {
 157    flag = d.flag;
 158    dt = d.dt;
 159
 160    switch ( flag ) {
 161       case INT:
 162         key.int_key = d.key.int_key ;
 163         flag = INT;
 164         break;
 165
 166       case STRING:
 167         {
 168         unsigned int d_sz = strlen(d.key.str_key);
 169         if ( strlen(key.str_key) < d_sz ) {
 170            delete key.str_key;
 171            key.str_key = new char[d_sz+1];
 172         }
 173         *((char *) memcpy(key.str_key, d.key.str_key, d_sz) + d_sz) = '\0';
 174         flag = STRING;
 175         break;
 176         }
 177       case VOID:
 178         flag = VOID;
 179    }
 180    return *this;
 181 }
 182
 183 data_t::~data_t()
 184 {
 185    switch ( flag ) {
 186       case INT:
 187         break;
 188       case STRING:
 189         delete key.str_key;
 190         break;
 191       case VOID:
 192         break;
 193    }
 194 }
 195
 196
 197 static char buf[BUFSIZ];
 198
 199 istream& operator >>(istream& i, data_t& d)
 200 {
 201    if ( !i.getline(buf, BUFSIZ) || buf[0] == '\n' )
 202       return i;
 203
 204    char* key_ptr = strchr(buf, '\t');
 205    char* voidPtr_ptr = strrchr(buf, '\t');
 206
 207    *key_ptr = 0;
 208    *voidPtr_ptr = 0;
 209
 210    key_ptr++;
 211    voidPtr_ptr++;
 212
 213 //////////////////////////
 214 // delete the string
 215 //////////////////////////
 216    if ( d.flag == data_t::STRING )
 217       delete d.key.str_key;
 218
 219    d.flag = (data_t::flag_type)atoi(buf);
 220    d.dt = (voidPtr)(size_t)atoi(voidPtr_ptr);
 221
 222    if ( d.flag == data_t::INT )
 223       d.key.int_key = atoi(key_ptr);
 224    else
 225    if ( d.flag == data_t::STRING ) {
 226       int sz = strlen(key_ptr);
 227       d.key.str_key = new char[sz+1];
 228       *((char *) memcpy(d.key.str_key, key_ptr, sz) + sz) = '\0';
 229    }
 230
 231    return i;
 232 }
 233
 234 ostream& operator <<(ostream& o, data_t& d)
 235 {
 236    if ( d.flag == data_t::VOID )
 237       return o;
 238
 239    o << d.flag << "     ";
 240
 241    switch ( d.flag ) {
 242       case data_t::INT:
 243         o << d.key.int_key;
 244         break;
 245       case data_t::STRING:
 246         o << d.key.str_key;
 247         break;
 248       default:
 249         break;
 250    }
 251
 252    o << "       " << (long)(d.dt);
 253    return o;
 254 }
 255
 256 Boolean data_t::binaryIn(buffer& buf)
 257 {
 258    char c; buf.get(c);
 259    flag = (data_t::flag_type)c;
 260    char* cp;
 261
 262    unsigned int sz;
 263
 264    switch ( flag ) {
 265       case data_t::VOID:
 266         break;
 267
 268       case data_t::INT:
 269         buf.get(*(unsigned int*)&key.int_key);
 270         break;
 271
 272       case data_t::STRING:
 273
 274         buf.get(sz);
 275         key.str_key = new char[sz+1];
 276         buf.get(key.str_key, sz);
 277         key.str_key[sz] = 0;
 278
 279         break;
 280    }
 281    cp = (char*)&dt;
 282    buf.get(*(long*)cp);
 283    return true;
 284 }
 285
 286 Boolean data_t::binaryOut(buffer& buf)
 287 {
 288    buf.put((char)flag);
 289    unsigned int sz;
 290
 291    switch ( flag ) {
 292       case data_t::VOID:
 293         break;
 294
 295       case data_t::INT:
 296         buf.put((unsigned int)key.int_key);
 297         break;
 298
 299       case data_t::STRING:
 300         sz = strlen(key.str_key);
 301
 302         buf.put(sz);
 303         buf.put(key.str_key, sz);
 304
 305
 306         break;
 307    }
 308    buf.put((long)dt);
 309    return true;
 310 }
 311
 312 ostream& data_t::asciiOut(ostream& o, print_func_ptr_t print_f)
 313 {
 314    print_f(o, this);
 315    return o;
 316 }
 317
 318 int data_t::bucket_num(int k, int p, int M)
 319 {
 320    switch ( flag ) {
 321       case INT:
 322         return abs( key.int_key * k ) % p % M ;
 323       case STRING:
 324         //return abs( larson_convertor.atoi(key.str_key) * k ) % p % M ;
 325         //return abs( pearson_convertor.atoi(key.str_key, strlen(key.str_key), k
 326         return abs( pearson_convertor.atoi(key.str_key, strlen(key.str_key), k
 327 , p) )  % M ;
 328       default:
 329         throw(stringException("VOID type in bucket_num()"));
 330    }
 331 }
 332
 333 int data_t::slot_num(int k, int rotate, int prime, int M )
 334 {
 335    int x;
 336    switch ( flag ) {
 337       case INT:
 338         x = ( abs( k * key.int_key ) % prime + rotate ) % M ;
 339         break;
 340       case STRING:
 341         x = ( abs( pearson_convertor.atoi(key.str_key, strlen(key.str_key), k, prime)) + rotate  ) % M ;
 342         break;
 343       default:
 344         throw(stringException("VOID type in slot_num()"));
 345    }
 346    return x;
 347 }
 348
 349 void* data_t::operator new( size_t x )
 350 {
 351    //return (void*)data_t_space_pool.alloc(x);
 352    return (void*)g_memory_pool.alloc(x);
 353 }
 354
 355 void data_t::operator delete( void* ptr )
 356 {
 357    //data_t_space_pool.free((char*)ptr);
 358    g_memory_pool.free((char*)ptr);
 359 }
 360