RxVariant.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2024 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
 
 
 
#if !defined(_ODVARIANT_H_INCLUDED_)
#define _ODVARIANT_H_INCLUDED_
 
#include "TD_PackPush.h"
#include "OdPlatformSettings.h"
#include "RxObject.h"
 
#include "StringArray.h"
#include "BoolArray.h"
#include "Int8Array.h"
#include "Int16Array.h"
#include "Int32Array.h"
#include "Int64Array.h"
#include "UInt8Array.h"
#include "UInt16Array.h"
#include "UInt32Array.h"
#include "UInt64Array.h"
#include "DoubleArray.h"
#include "OdString.h"
#include "OdAnsiString.h"

class FIRSTDLL_EXPORT OdError_InvalidVariantType : public OdError
{
public:
  OdError_InvalidVariantType();
};
 
const int nOdVariantDataSize = 8;

class FIRSTDLL_EXPORT OdVariant
{
protected:
  int m_type;
  union   // Union is required to have proper data alignment which is important
  {       // for some platforms
    OdUInt8 uint8[nOdVariantDataSize];
    double  dbl;
    void* ptr;
  } m_uData;
  void* data() const {return (void*)m_uData.uint8;}
 
  virtual void setVarType(int newType, int& type, void* data);
public:
  struct TypeFactory
  {
    virtual void construct(void* pData) const = 0;
    virtual void destroy(void* pData) const = 0;
    virtual ~TypeFactory() {}
  };
  static const TypeFactory* typeFactory(int type);
public:
  typedef enum
  {
    kVoid         = 0x0000,
    kString       = 0x0001,
    kBool         = 0x0002,
    kInt8         = 0x0003,
    kUInt8        = 0x0003,
    kInt16        = 0x0004,
    kUInt16       = 0x0004,
    kInt32        = 0x0005,
    kUInt32       = 0x0005,
    kInt64        = 0x0006,
    kUInt64       = 0x0006,
    kDouble       = 0x0007,
    kWString      = 0x0008,
    kAnsiString   = 0x0008,
    kRxObjectPtr  = 0x0009,
    kNextType     = 0x000A,
    kByRef        = 0x0040,
    kArray        = 0x0080
  } Type;
 
  OdVariant();
  OdVariant(const OdVariant& val);
  OdVariant& operator =(const OdVariant& val);
  virtual ~OdVariant();

  int  varType() const { return m_type; }
  Type type()    const { return Type(m_type & (0x3F)); }
  bool isArray() const { return (m_type & kArray)!=0; }
  bool isByRef() const { return (m_type & kByRef)!=0; }
 
  OdVariant(const OdString& val);
  OdVariant(const OdAnsiString& val);
  OdVariant(const OdRxObjectPtr& val);
  OdVariant(bool val);
  OdVariant(OdInt8 val);
  OdVariant(OdUInt8 val);
  OdVariant(OdInt16 val);
  OdVariant(OdUInt16 val);
  OdVariant(OdInt32 val);
  OdVariant(OdUInt32 val);
  OdVariant(OdInt64 val);
  OdVariant(OdUInt64 val);
  OdVariant(double val);
#ifdef OD_INTPTR_UNIQUE
  OdVariant(OdIntPtr val);
#endif

  const OdString& getString() const;

  const OdAnsiString& getAnsiString() const;

  const OdRxObjectPtr& getRxObjectPtr() const;

  bool getBool()   const;

  OdInt8 getInt8()   const;

  OdUInt8 getUInt8()  const;

  OdInt16 getInt16()  const;

  OdUInt16 getUInt16() const;

  OdInt32 getInt32()  const;

  OdUInt32 getUInt32() const;

  OdInt64 getInt64()  const;

  OdUInt64 getUInt64() const;

  OdIntPtr getIntPtr() const;

  double getDouble() const;
 

  OdString* getStringPtr() const;

  OdAnsiString* getAnsiStringPtr() const;

  OdRxObjectPtr* getRxObjectPtrPtr() const;

  bool* getBoolPtr()   const;

  OdInt8* getInt8Ptr()   const;

  OdUInt8* getUInt8Ptr()  const;

  OdInt16* getInt16Ptr()  const;

  OdUInt16* getUInt16Ptr() const;

  OdInt32* getInt32Ptr()  const;

  OdUInt32* getUInt32Ptr() const;

  OdInt64* getInt64Ptr()  const;

  OdUInt64* getUInt64Ptr() const;

  double* getDoublePtr() const;
 

  const OdStringArray& getStringArray() const;

  const OdAnsiStringArray& getAnsiStringArray() const;

  const OdRxObjectPtrArray& getRxObjectPtrArray() const;

  const OdBoolArray& getBoolArray  () const;

  const OdInt8Array& getInt8Array  () const;

  const OdUInt8Array& getUInt8Array () const;

  const OdInt16Array& getInt16Array () const;

  const OdUInt16Array& getUInt16Array() const;

  const OdInt32Array& getInt32Array () const;

  const OdUInt32Array& getUInt32Array() const;

  const OdInt64Array& getInt64Array () const;

  const OdUInt64Array& getUInt64Array() const;

  const OdDoubleArray& getDoubleArray() const;

  OdStringArray& asStringArray();

  OdAnsiStringArray& asAnsiStringArray();

  OdRxObjectPtrArray& asRxObjectPtrArray();
  
  OdBoolArray&   asBoolArray  ();
  
  OdInt8Array&   asInt8Array  ();
  
  OdUInt8Array&  asUInt8Array ();
  
  OdInt16Array&  asInt16Array ();
  
  OdUInt16Array& asUInt16Array();
  
  OdInt32Array&  asInt32Array ();
  
  OdUInt32Array& asUInt32Array();
  
  OdInt64Array&  asInt64Array ();
  
  OdUInt64Array& asUInt64Array();
  
  OdDoubleArray& asDoubleArray();

  OdStringArray* getStringArrayPtr() const;

  OdAnsiStringArray* getAnsiStringArrayPtr() const;

  OdRxObjectPtrArray* getRxObjectPtrArrayPtr() const;

  OdBoolArray* getBoolArrayPtr  () const;

  OdInt8Array* getInt8ArrayPtr  () const;

  OdUInt8Array* getUInt8ArrayPtr () const;

  OdInt16Array* getInt16ArrayPtr () const;

  OdUInt16Array* getUInt16ArrayPtr() const;

  OdInt32Array* getInt32ArrayPtr () const;

  OdUInt32Array* getUInt32ArrayPtr() const;

  OdInt64Array* getInt64ArrayPtr () const;

  OdUInt64Array* getUInt64ArrayPtr() const;

  OdDoubleArray* getDoubleArrayPtr() const;

  OdVariant& setString(const OdString& val);

  OdVariant& setAnsiString(const OdAnsiString& val);

  OdVariant& setRxObjectPtr( const OdRxObjectPtr& val );

  OdVariant& setBool  (bool val);

  OdVariant& setInt8  (OdInt8 val);

  OdVariant& setUInt8 (OdUInt8 val);

  OdVariant& setInt16 (OdInt16 val);

  OdVariant& setUInt16(OdUInt16 val);

  OdVariant& setInt32 (OdInt32 val);

  OdVariant& setUInt32(OdUInt32 val);

  OdVariant& setInt64 (OdInt64 val);

  OdVariant& setUInt64(OdUInt64 val);

  OdVariant& setIntPtr (OdIntPtr val);

  OdVariant& setDouble(double val);

  OdVariant& setStringPtr(OdString* val);

  OdVariant& setAnsiStringPtr(OdAnsiString* val);

  OdVariant& setRxObjectPtrPtr(OdRxObjectPtr* val);

  OdVariant& setBoolPtr  (bool* val);

  OdVariant& setInt8Ptr  (OdInt8* val);

  OdVariant& setUInt8Ptr (OdUInt8* val);

  OdVariant& setInt16Ptr (OdInt16* val);

  OdVariant& setUInt16Ptr(OdUInt16* val);

  OdVariant& setInt32Ptr (OdInt32* val);

  OdVariant& setUInt32Ptr(OdUInt32* val);

  OdVariant& setInt64Ptr (OdInt64* val);

  OdVariant& setUInt64Ptr(OdUInt64* val);

  OdVariant& setDoublePtr(double* val);

  OdVariant& setStringArray(const OdStringArray& val);

  OdVariant& setAnsiStringArray(const OdAnsiStringArray& val);

  OdVariant& setRxObjectPtrArray(const OdRxObjectPtrArray& val);

  OdVariant& setBoolArray  (const OdBoolArray&   val);

  OdVariant& setInt8Array  (const OdInt8Array&   val);

  OdVariant& setUInt8Array (const OdUInt8Array&  val);

  OdVariant& setInt16Array (const OdInt16Array&  val);

  OdVariant& setUInt16Array(const OdUInt16Array& val);

  OdVariant& setInt32Array (const OdInt32Array&  val);

  OdVariant& setUInt32Array(const OdUInt32Array& val);

  OdVariant& setInt64Array (const OdInt64Array&  val);

  OdVariant& setUInt64Array(const OdUInt64Array& val);

  OdVariant& setDoubleArray(const OdDoubleArray& val);
 

  OdVariant& setStringArrayPtr(OdStringArray* val);

  OdVariant& setAnsiStringArrayPtr(OdAnsiStringArray* val);

  OdVariant& setRxObjectPtrArrayPtr(OdRxObjectPtrArray* val);

  OdVariant& setBoolArrayPtr  (OdBoolArray*   val);

  OdVariant& setInt8ArrayPtr  (OdInt8Array*   val);

  OdVariant& setUInt8ArrayPtr (OdUInt8Array*  val);

  OdVariant& setInt16ArrayPtr (OdInt16Array*  val);

  OdVariant& setUInt16ArrayPtr(OdUInt16Array* val);

  OdVariant& setInt32ArrayPtr (OdInt32Array*  val);

  OdVariant& setUInt32ArrayPtr(OdUInt32Array* val);

  OdVariant& setInt64ArrayPtr (OdInt64Array*  val);

  OdVariant& setUInt64ArrayPtr(OdUInt64Array* val);

  OdVariant& setDoubleArrayPtr(OdDoubleArray* val);
};
 
 
 
#include "TD_PackPop.h"
 
#endif //_ODVARIANT_H_INCLUDED_