Initial import of the CDE 2.1.30 sources from the Open Group.

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

@@ -0,0 +1,332 @@
+/*
+ * $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(MAXSHORT, 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];
+        strcpy(key.str_key, d.key.str_key);
+        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 )
+      strcpy(key.str_key, str);
+
+   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==()"));
+   }
+}
+
+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:
+        {
+        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];
+        }
+        strcpy(key.str_key, d.key.str_key);
+        key.str_key[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(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];
+      strcpy(d.key.str_key, key_ptr);
+      d.key.str_key[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;
+   }
+
+   o << "	" << (long)(d.dt);
+   return o;
+}
+
+Boolean data_t::binaryIn(buffer& buf)
+{
+   char c; buf.get(c);
+   flag = (data_t::flag_type)c;
+
+   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;
+   }
+   buf.get(*(long*)&dt);
+   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);
+}
+