DataEntry.h

Go to the documentation of this file.

#ifndef _RDA_DATA_ENTRY_H_
#define _RDA_DATA_ENTRY_H_
//
// 22 Mar 2001, N.Trofimov
// 18 Sep 2001 NNT
//    - added support for long long
// 13 May 2002 NNT
//    - fully rewritten to use union instead of Any as the data store
//    - added put/get methods for arrays
// 09 Jul 2002 NNT
//    - added print methods and os<<, asciiDump deprecated
//    - added getTypeName
//    - added message to rdaTypeMismatch
// 18 Mar 2004 NNT
//    - added documentation for put/get methods
//

#include <stdio.h>
#include <stddef.h>

#ifdef CMW_WIN
// For Windows/VC++
typedef __int64 longlong;
#else
// For Unix/GCC
typedef long long longlong;
#endif

class rdaDataEntry
{
   //
   // Allow Data access private constructor and destructor
   //
   friend class rdaData;

   const char* tag_;
   
   //
   // PRIVATE constructors and desctructor.
   //
   // The C++ implementation, unlike the Java implementation, does not
   // support "independent" data entries. The life cycle of a data entry
   // is fully managed by the rdaData object in which it is contained.
   //
   rdaDataEntry(const char* tag);
   rdaDataEntry(const rdaDataEntry& de);
   ~rdaDataEntry();

   public:
       
      rdaDataEntry& operator=(const rdaDataEntry& de);

      const char* tag() const;


      void print(FILE* fp, unsigned long maxElements) const;

      void print(unsigned long maxElements) const;

      void print() const;

      void asciiDump(unsigned long maxElements=5) const;
         
      //
      // COMPARISON
      // ==========
      //

     
      bool operator==(const rdaDataEntry&) const;
      bool operator!=(const rdaDataEntry&) const;
      
      //
      // VALUE TYPE
      // ==========
      //  
      enum ValueType
      {
         TYPE_NULL,
         TYPE_BOOLEAN,
         TYPE_BOOLEAN_ARRAY,
         TYPE_BYTE, 
         TYPE_BYTE_ARRAY,
         TYPE_SHORT, 
         TYPE_SHORT_ARRAY,
         TYPE_INT, 
         TYPE_INT_ARRAY,
         TYPE_LONG, 
         TYPE_LONG_ARRAY,
         TYPE_FLOAT, 
         TYPE_FLOAT_ARRAY,
         TYPE_DOUBLE, 
         TYPE_DOUBLE_ARRAY,
         TYPE_STRING, 
         TYPE_STRING_ARRAY
      };
      ValueType getValueType() const;

      static const char* getTypeName(ValueType typeCode);

      //
      // EXTRACTION
      // ==========
      //


      bool   extractBoolean() const;
      bool*  extractBooleanArray(unsigned long& size) const;
      const bool*  getBooleanArray(unsigned long& size) const;
      signed char extractByte() const;
      signed char*  extractByteArray(unsigned long& size) const;
      const signed char*  getByteArray(unsigned long& size) const;
      short  extractShort() const;
      short* extractShortArray(unsigned long& size) const;
      const short* getShortArray(unsigned long& size) const;
      long   extractInt() const;
      long*  extractIntArray(unsigned long& size) const;
      const long*  getIntArray(unsigned long& size) const;

      longlong extractLong() const;
      longlong*  extractLongArray(unsigned long& size) const;
      const longlong*  getLongArray(unsigned long& size) const;
      float  extractFloat() const;
      float* extractFloatArray(unsigned long& size) const;
      const float* getFloatArray(unsigned long& size) const;
      double  extractDouble() const;
      double* extractDoubleArray(unsigned long& size) const;
      const double* getDoubleArray(unsigned long& size) const;
      char*  extractString() const;
      const char* getString() const;
      char** extractStringArray(unsigned long& size) const;
      const char** getStringArray(unsigned long& size) const;

      
      //
      // INSERTION
      // =========
      //

      void insert(bool value);
      void insert(const bool* value, unsigned long size);
      void put(const bool* value, unsigned long size);
      void insert(signed char value);
      void insert(const signed char* value, unsigned long size);
      void put(const signed char* value, unsigned long size);
      void insert(short value);
      void insert(const short* value, unsigned long size);
      void put(const short* value, unsigned long size);
      void insert(long value);
      void insert(const long* value, unsigned long size);
      void put(const long* value, unsigned long size);

      void insert(longlong value);
      void insert(const longlong* value, unsigned long size);
      void put(const longlong* value, unsigned long size);

      void insert(float value);
      void insert(const float* value, unsigned long size);
      void put(const float* value, unsigned long size);
      void insert(double value);
      void insert(const double* value, unsigned long size);
      void put(const double* value, unsigned long size);
      void insert(const char* value);
      void put(const char* value);
      void insert(const char** value, unsigned long size);
      void put(const char** value, unsigned long size);


   //
   // Private attributes and methods with ValueType args
   //
   private:

      //
      // Value store
      //
      union
      {
         // scalar values
         bool boolValue;
         signed char byteValue;
         short shortValue;
         long intValue;
         longlong longValue;
         float floatValue;
         double doubleValue;
         // strings
         char* stringValue;
         // arrays of primitive types
         void* arrayValue;
         // string arrays
         char** stringArrayValue;
      };

      //
      // Identifies the type of a contained value
      //
      ValueType type;

      //
      // The number of elements for array values.
      // size = 0 for scalar values
      //
      unsigned long size;

      //
      // If true, indicates that the memory pointed to by
      // stringValue, arrayValue, or stringArrayValue needs
      // to be released before inserting a new value or
      // deleting the data entry.
      //
      bool rel;

   void release();
   size_t elementSize(ValueType type) const;
   void* extractArray(ValueType type, unsigned long& size, bool copy) const;
   void replace(ValueType type, const void* v, unsigned long size, bool copy);
   void throwTypeMismatch(rdaDataEntry::ValueType expected) const;
};

#ifndef RDA_HAS_NO_IOSTREAM
   #ifndef RDA_HAS_NO_STD_IOSTREAM
      #include <iostream>
      using std::ostream;
      using std::endl;
   #else
      #include <iostream.h>
   #endif

ostream& operator<<(ostream& os, const rdaDataEntry& dataEntry);
#endif

#endif

---