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

cde/programs/dtinfo/DtMmdb/object/pstring.C

@@ -0,0 +1,417 @@
+/*
+ * $XConsortium: pstring.C /main/6 1996/09/16 14:26:44 mgreess $
+ *
+ * Copyright (c) 1992 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 "object/pstring.h"
+
+#ifdef C_API
+buffer* pstring::v_io_buf_ptr;
+#define v_io_buf (*v_io_buf_ptr)
+#else
+buffer pstring::v_io_buf(LBUFSIZ);
+#endif
+   
+void pstring::init_persistent_info(persistent_info* x)
+{
+   root::init_persistent_info(x);
+   if ( get_mode(OLD_OBJECT) == false ) {
+     char* y = 0;
+     if ( storage_ptr )
+       storage_ptr -> insertString(v_str_ptr.loc, y, 0);
+   }
+}
+
+pstring::pstring(c_code_t c_id) : primitive(c_id),
+   v_sz(0)
+{
+   //
+   // CDExc21900
+   // Make sure the entire union is initialized for 64bit architectures.
+   //
+   memset((char*) &v_str_ptr, 0, sizeof(v_str_ptr));
+}
+
+pstring::pstring(const char* x, int leng, c_code_t c_id) : 
+primitive(c_id)
+{
+   _init(x, leng);
+}
+
+pstring::pstring(pstring& x) : primitive(x)
+{
+   _init((const char*)x.get(), x.v_sz);
+}
+
+void pstring::_init(const char* x, int leng) 
+{
+   v_sz = leng;
+
+   if ( v_sz == 0 ) {
+     v_str_ptr.loc = 0;
+     return;
+   }
+
+   v_str_ptr.p = new char[leng+1]; 
+   memcpy(v_str_ptr.p, x, leng);
+   v_str_ptr.p[leng] = 0;
+}
+
+pstring::~pstring()
+{
+   if ( get_mode(PERSISTENT) == false && NULL != v_str_ptr.p ) 
+      delete v_str_ptr.p;
+}
+
+
+// /////////////////////////////////////
+// should not delete what get() returns!
+// /////////////////////////////////////
+char* pstring::get(buffer& string_buffer)
+{
+//MESSAGE(cerr, "get()");
+   if ( get_mode(PERSISTENT) == true ) {
+
+/*
+MESSAGE(cerr, "persistent");
+debug(cerr, v_sz);
+debug(cerr, v_str_ptr.loc);
+debug(cerr, f_oid);
+*/
+
+      string_buffer.reset();
+      string_buffer.expand_chunk(v_sz+1);
+
+      char* this_v_str_ptr = string_buffer.get_base();
+
+      storage_ptr -> 
+           readString(v_str_ptr.loc, this_v_str_ptr, v_sz);
+
+
+/*
+for (int i=0; i<v_sz; i++)
+{
+  cerr << int(this_v_str_ptr[i]) << " " ;
+}
+  cerr << "\n";
+*/
+
+
+      this_v_str_ptr[v_sz] = 0;
+
+      string_buffer.set_content_sz(v_sz);
+
+      return this_v_str_ptr;
+
+   } else {
+
+      return v_str_ptr.p;
+
+   }
+}
+
+
+/*
+Boolean pstring::value_LS(root& x, Boolean safe) const
+{
+   if ( safe == true &&
+        ( f_oid.ccode() != STRING_CODE ||
+          x.my_oid().ccode() != STRING_CODE
+        ) 
+      ) 
+     return false;
+
+   Boolean ok;
+   char* this_v_str_ptr;
+   char* x_v_str_ptr;
+
+   if ( get_mode(PERSISTENT) == true ) {
+      this_v_str_ptr = new char[v_sz+1];
+      storage_ptr -> readString(v_str_ptr.loc, this_v_str_ptr, v_sz);
+   } else
+      this_v_str_ptr = v_str_ptr.p;
+      
+   pstring &casted_x = *(pstring*)&x;
+
+   if ( casted_x.get_mode(PERSISTENT) == true ) {
+      x_v_str_ptr = new char[v_sz+1];
+      storage_ptr -> 
+          readString(casted_x.v_str_ptr.loc, x_v_str_ptr, casted_x.v_sz);
+   } else
+      x_v_str_ptr = casted_x.v_str_ptr.p;
+
+   int min_len = MIN(v_sz, casted_x.v_sz);
+
+   for ( int i=0; i<min_len; i++ ) {
+         if ( this_v_str_ptr[i] < x_v_str_ptr[i] ) {
+            ok = true;
+            break;
+          }
+
+         if ( this_v_str_ptr[i] > x_v_str_ptr[i] ) {
+            ok = false;
+            break;
+          }
+    }
+
+    if ( i == min_len && v_sz < casted_x.v_sz )
+       ok = true;
+    else
+       ok = false;
+
+    if ( get_mode(PERSISTENT) == true )
+       delete this_v_str_ptr;
+
+    if ( casted_x.get_mode(PERSISTENT) == true )
+       delete x_v_str_ptr;
+
+    return ok;
+}
+
+Boolean pstring::value_EQ(root& x, Boolean safe) const
+{
+   if ( safe == true &&
+        ( f_oid.ccode() != STRING_CODE ||
+           x.my_oid().ccode() != STRING_CODE
+        ) 
+      )
+     return false;
+
+   pstring &casted_x = *(pstring*)&x;
+
+   if ( v_sz != casted_x.v_sz )
+     return false;
+
+   Boolean ok;
+   char* this_v_str_ptr;
+   char* x_v_str_ptr;
+
+   if ( get_mode(PERSISTENT) == true ) {
+      this_v_str_ptr = new char[v_sz+1];
+      storage_ptr -> readString(v_str_ptr.loc, this_v_str_ptr, v_sz);
+   } else
+      this_v_str_ptr = v_str_ptr.p;
+      
+   if ( casted_x.get_mode(PERSISTENT) == true ) {
+      x_v_str_ptr = new char[v_sz+1];
+      storage_ptr -> 
+          readString(casted_x.v_str_ptr.loc, x_v_str_ptr, casted_x.v_sz);
+   } else
+      x_v_str_ptr = casted_x.v_str_ptr.p;
+
+   //ok = ( bcmp(this_v_str_ptr, x_v_str_ptr, v_sz) == 0 ) ? true : false;
+   ok = ( memcmp(this_v_str_ptr, x_v_str_ptr, v_sz) == 0 ) ? true : false;
+
+   if ( get_mode(PERSISTENT) == true )
+      delete this_v_str_ptr;
+
+   if ( casted_x.get_mode(PERSISTENT) == true )
+      delete x_v_str_ptr;
+
+    return ok;
+}
+*/
+
+io_status pstring::asciiOut(ostream& out) 
+{
+/*
+MESSAGE(cerr, "pstring::asciiOut():");
+debug(cerr, v_sz);
+debug(cerr, (void*)this);
+my_oid().asciiOut(cerr);
+cerr << "\n";
+*/
+
+   const char* x = get();
+
+   out << v_sz << '\t';
+
+   for ( int i=0; i<v_sz; i++ )
+      out << x[i];
+
+    return done;
+}
+
+io_status pstring::asciiIn(istream& in) 
+{
+/*
+MESSAGE(cerr, "pstring::asciiIn():");
+debug(cerr, (void*)this);
+my_oid().asciiOut(cerr);
+cerr << "\n";
+*/
+
+   _asciiIn(in);
+   pstring::update(v_io_buf.get_base(), v_io_buf.content_sz());
+   return done;
+}
+
+io_status pstring::asciiIn(const char* buf, int size) 
+{
+   v_io_buf.reset();
+   v_io_buf.expand_chunk(size);
+   memcpy(v_io_buf.get_base(), buf, size);
+   v_io_buf.set_content_sz(size);
+   return done;
+}
+
+void pstring::_asciiIn(istream& in) 
+{
+   if ( ! cc_is_digit(in) )
+      throw (stringException("a digit expected"));
+
+   int len;
+   in >> len;
+
+   int tab = in.get(); // expect a '\t'
+
+   if ( tab != '\t' ) {
+      debug(cerr, len);
+      debug(cerr, tab);
+      throw(stringException("'\\t' expected"));
+   }
+
+   v_io_buf.reset();
+   v_io_buf.expand_chunk(len);
+
+   if (  len > 0 && 
+         ( !in.read(v_io_buf.get_base(), len) || in.gcount() != len ) 
+      ) {
+      debug(cerr, len);
+      debug(cerr, v_io_buf.get_base());
+      throw(stringException("pstring::asciiIn(): read failed"));
+   }
+
+   int ret = in.get(); // expect a '\n'
+
+   if ( ret != '\n' ) {
+      debug(cerr, ret);
+      throw(stringException(form("'\\n' expected. %c seen. (count=%d)", ret, len)));
+   }
+
+   v_io_buf.set_content_sz(len);
+}
+
+Boolean pstring::update(pstring& new_value)
+{
+   return update((const char*)new_value.get(), new_value.v_sz);
+}
+
+Boolean pstring::update(const char* new_value, int new_value_sz)
+{
+
+/*
+MESSAGE(cerr, "pstring:: update value:");
+debug(cerr, v_str_ptr.loc);
+debug(cerr, f_oid);
+debug(cerr, v_sz);
+
+debug(cerr, new_value_sz);
+for (int i=0; i<new_value_sz; i++)
+{
+  cerr << int(new_value[i]) << " " ;
+}
+  cerr << "\n";
+*/
+
+
+
+   int old_sz = v_sz;
+   v_sz = new_value_sz;
+
+   if ( get_mode(PERSISTENT) == true ) {
+//MESSAGE(cerr, "persist case");
+
+      if ( v_str_ptr.loc == 0 ) {
+         storage_ptr -> insertString(v_str_ptr.loc, new_value, v_sz);
+      } else {
+         storage_ptr -> updateString(v_str_ptr.loc, new_value, v_sz); 
+      }
+
+   } else  {
+
+      if ( old_sz < new_value_sz ) {
+         delete v_str_ptr.p;
+         v_str_ptr.p = new char[v_sz+1];
+      } 
+      memcpy(v_str_ptr.p, new_value, v_sz);
+
+   }
+
+   set_mode(UPDATE, true);
+
+//debug(cerr, this -> get());
+
+   return true;
+}
+
+
+int pstring::cdr_sizeof()
+{
+   return primitive::cdr_sizeof() + 
+          sizeof(v_str_ptr.loc) + 
+          sizeof(v_sz);
+}
+
+io_status pstring::cdrOut(buffer& buf)
+{
+   primitive::cdrOut(buf);
+   buf.put(v_str_ptr.loc);
+   buf.put(v_sz);
+   return done;
+}
+
+io_status pstring::cdrIn(buffer& buf)
+{
+   primitive::cdrIn(buf);
+   buf.get(v_str_ptr.loc);
+   buf.get(v_sz);
+   return done;
+}
+
+MMDB_BODIES(pstring)
+
+pstring_handler::pstring_handler(const oid_t& v_oid, storagePtr _store) :
+handler(v_oid, _store)
+{
+}
+
+pstring_handler::pstring_handler(const char* str, int sz, storagePtr _store) :
+handler(STRING_CODE, _store)
+{
+   (this -> operator->()) -> update(str, sz);
+}
+
+pstring_handler::~pstring_handler()
+{
+}
+
+pstring* pstring_handler::operator ->()
+{
+   return (pstring*)handler::operator->();
+}
+
+