RxValue.h

Go to the documentation of this file.

// Copyright (C) 2002-2018, 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 Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2018 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef _ODRXVALUE_INCLUDED_
#define _ODRXVALUE_INCLUDED_
 
#include "RxValueType.h"
#include "RxMember.h"
#include "StringArray.h"
#include "IntArray.h"
#include "Ge/GeDoubleArray.h"
#include "StaticRxObject.h"
#include "CmColorBase.h"
#include "DbHandle.h"
 
template<typename ValueType> ValueType* rxvalue_cast(OdRxValue* value) throw();
 
template<typename ValueType> ValueType * rxenum_cast(OdRxValue * value) throw();
 
template<typename ValueType> const ValueType * rxvalue_cast(const OdRxValue * value) throw();
 
template<typename ValueType> const ValueType * rxenum_cast(const OdRxValue * value) throw();
 
#include "TD_PackPush.h"
 
class FIRSTDLL_EXPORT OdRxValue
{
public:
  OdRxValue() throw() : m_type(OdRxValueType::Desc<void>::value())
  {
    memset(&m_value, 0, sizeof(m_value));
  }
 
  OdRxValue(const OdRxValue& rhs) throw() : m_type(rhs.m_type)
  {
    init(rhs, false);
  }
 
  OdRxValue(const OdRxValueType& type, const OdRxValue& value) throw() : m_type(type)
  {
    init(value, false);
  }
 
  const OdRxValue& operator=(const OdRxValue& rhs) throw()
  {
    if (this == &rhs)
      return *this;
    if (type() != rhs.type())
    {
      if (!type().isBlittable())
        type().nonBlittable()->destruct(valuePtr());
      if (!isInlined() && rhs.isInlined())
        deallocate(m_value.m_ptr);
#ifdef _MSC_VER
#pragma push_macro("new")
#undef new
#endif
      ::new ((OdRxValueStorage*)this) OdRxValue(rhs, !isInlined() && !rhs.isInlined());
#ifdef _MSC_VER
#pragma pop_macro("new")
#endif
      return *this;
    }
    bool blittable = rhs.type().isBlittable();
    bool inlined = rhs.isInlined();
    if (blittable && inlined)
    {
      memcpy(this, &rhs, sizeof(OdRxValue));
      return *this;
    }
    /*
    inlined,non-blittable
    non-inlined, non-blittable
    non-inlined, blittable
    */
    if (inlined)
      type().nonBlittable()->assign(inlineValuePtr(), rhs.inlineValuePtr());
    else
      setNonInlineValue(rhs.nonInlineValuePtr(), blittable, true, true);
    return *this;
  }
 
  ~OdRxValue() throw()
  {
    //if the type is non-blittable then we must call destructor
    if (!type().isBlittable())
      type().nonBlittable()->destruct(valuePtr());
    //finally free memory if necessary
    if (!isInlined())
      deallocate(m_value.m_ptr);
  }
 
  const OdRxValueType& type() const throw()
  {
    return m_type;
  }
 
  bool isEmpty() const throw() { return *this == empty(); }
 
  static const OdRxValue& empty() throw();
 
  bool isVaries() const throw() { return *this == varies(); }
 
  static const OdRxValue& varies() throw();
 
  OdString toString(OdRxValueType::StringFormat format = OdRxValueType::kStringFormatGlobal) const throw()
  {
    return m_type.toString(valuePtr(), format);
  }
 
  bool operator==(const OdRxValue& value) const throw()
  {
    if (type() != value.type())
      return false;
    return type().equalTo(valuePtr(), value.valuePtr());
  }
 
  bool operator!=(const OdRxValue& value) const throw()
  {
    return !(operator == (value));
  }
 
  const OdAnsiString typePath() const
  {
    return m_type.typePath(*this);
  }
 
  template <typename ValueType>
  OdRxValue(const ValueType& value) throw()
    :m_type(OdRxValueType::Desc<ValueType>::value())
  {
    //this should have been specialized otherwise
    ODA_ASSERT(m_type.isBlittable());
    initBlittable<sizeof(ValueType) <= 24>(&value, sizeof(ValueType));
  }
 
  template<typename ValueType>
  friend ValueType* rxvalue_cast(OdRxValue* value) throw()
  {
    return value && OdRxValueType::Desc<ValueType>::value() == value->type() ? (ValueType*)(value->valuePtr__<sizeof(ValueType) <= 24>()) : 0;
  }
 
  template<typename ValueType>
  friend ValueType * rxenum_cast(OdRxValue * value) throw()
  {
    ODA_ASSERT(value == NULL || value->isVaries() || value->type().isEnum());
    return value &&
      value->type().isEnum() &&
      OdRxValueType::Desc<ValueType>::value() == value->type().enumeration()->getAt(0).type() ? (ValueType*)(value->valuePtr__<sizeof(ValueType) <= 24>()) : 0;
  }
 
  template<typename ValueType>
  OdRxValue& operator=(const ValueType & rhs) throw()
  {
    *this = OdRxValue(rhs);
    return *this;
  }
 
  template<typename ValueType>
  friend inline const ValueType * rxvalue_cast(const OdRxValue * value) throw()
  {
    return rxvalue_cast<ValueType>(const_cast<OdRxValue*>(value));
  }
 
  template<typename ValueType>
  friend inline const ValueType * rxenum_cast(const OdRxValue * value) throw()
  {
    return rxenum_cast<ValueType>(const_cast<OdRxValue*>(value));
  }
 
  static const OdRxValue* unbox(const OdRxObject* pO) throw();
 
  static OdRxValue* unbox(OdRxObject* pO) throw();
 
  const OdRxEnumTag* getEnumTag() const throw();
 
  size_t serializeOut(void* pBytes, size_t& maxBytesToWrite) const;
 
  size_t serializeIn(const void* pBytes, size_t maxBytesToRead);
 
  template<typename ValueType>
  void operator << (const ValueType &val)
  {
    *this = val;
  }
 
  template<typename ValueType>
  bool operator >> (ValueType &val) const
  {
    if (m_type == OdRxValueType::Desc<ValueType>::value())
    {
      const ValueType *pVal = rxvalue_cast<ValueType>(this);
      if (pVal)
      {
        val = *pVal;
        return true;
      }
    }
    else
    {
      OdRxValue subVal;
      if (m_type.toValueType(OdRxValueType::Desc<ValueType>::value(), *this, subVal) ||
        OdRxValueType::Desc<ValueType>::value().fromValueType(*this, subVal))
      {
        const ValueType *pVal = rxvalue_cast<ValueType>(&subVal);
        if (pVal)
        {
          val = *pVal;
          return true;
        }
      }
    }
    return false;
  }
 
  //DOM-IGNORE-BEGIN
#ifdef _MSC_VER
#pragma region private
#endif
private:
  bool isInlined() const
  {
    return type().size() <= sizeof(m_value);
  }
  const void* nonInlineValuePtr() const { return m_value.m_ptr; }
  void* nonInlineValuePtr() { return m_value.m_ptr; }
  const void* inlineValuePtr() const { return &m_value; }
  void* inlineValuePtr() { return &m_value; }
  const void* valuePtr() const
  {
    if (isInlined())
      return inlineValuePtr();
    else
      return nonInlineValuePtr();
  }
  template <bool Inlined>
  void* valuePtr__();
  template <bool Inlined>
  void initBlittable(const void* value, size_t size);
 
  template<typename T, bool inlined>
  class InitNonBlittable
  {
  public:
    static void init(OdRxValue& rxValue, const T& value);
  };
  template<typename T>
  class InitNonBlittable<T, true>
  {
  public:
    static void init(OdRxValue& rxValue, const T& value);
  };
  template<typename T>
  class InitNonBlittable<T, false>
  {
  public:
    static void init(OdRxValue& rxValue, const T& value);
  };
 
  template <typename T>
  void initNonBlittable(const T& value)
  {
    InitNonBlittable<T, sizeof(value) <= sizeof(m_value) >::init(*this, value);
  }
 
  void init(const OdRxValue& rhs, bool realloc)
  {
    bool blittable = type().isBlittable();
    bool inlined = isInlined();
    if (blittable && inlined)
    {
      memcpy(&m_value, &rhs.m_value, sizeof(m_value));
      return;
    }
    /*
    inlined,non-blittable
    non-inlined, non-blittable
    non-inlined, blittable
    */
    if (inlined)
      type().nonBlittable()->construct(inlineValuePtr(), rhs.inlineValuePtr());
    else
      setNonInlineValue(rhs.nonInlineValuePtr(), blittable, false, realloc);
  }
  void setNonInlineValue(const void* value, bool blittable, bool assignment, bool realloc)
  {
    ODA_ASSERT(blittable == type().isBlittable());
    ODA_ASSERT(!isInlined());
    unsigned int newSize = type().size();
    realloc = realloc || assignment;
    if (realloc)
    {
      size_t oldsize = *(((size_t*)m_value.m_ptr) - 1);
      if (oldsize != newSize)
      {
        m_value.m_ptr = reallocate(newSize, m_value.m_ptr);
        assignment = false;
      }
    }
    else
      m_value.m_ptr = allocate(newSize);
 
    if (blittable)
      memcpy(nonInlineValuePtr(), value, newSize);
    else if (assignment)
      type().nonBlittable()->assign(nonInlineValuePtr(), value);
    else
      type().nonBlittable()->construct(nonInlineValuePtr(), value);
  }
  OdRxValue(const OdRxValue& rhs, bool realloc)
    :m_type(rhs.m_type)
  {
    init(rhs, realloc);
  }
  const OdRxValueType& m_type;
#if (OD_SIZEOF_PTR == 4)
  OdInt32 padding;
#endif
  union InlineStorage
  {
    double m_point[3];
    void* m_ptr;
    char  m_int8;
    short m_int16;
    int   m_int32;
    OdInt64 m_int64;
    float m_real32;
    double m_real64;
  } m_value;
  void* allocate(size_t size) const;
  void* reallocate(size_t size, void* p) const;
  void  deallocate(void* p) const;
};
#ifdef _MSC_VER
#pragma endregion private
#endif
//DOM-IGNORE-END
 
template <class T> OdRxValue createOdRxValue() { T val; return OdRxValue(val); }
 
ODA_ASSUME(sizeof(OdRxValue) == 32); //each OdRxValue instance is 32 bytes long (on both 32 and 64 bit)
 
//DOM-IGNORE-BEGIN
template<>
inline const void* rxvalue_cast<void>(const OdRxValue * value) throw()
{
  return value ? value->valuePtr() : 0;
}
 
template<>
inline void* OdRxValue::valuePtr__<true>()
{
  ODA_ASSERT(isInlined());
  return inlineValuePtr();
}
 
template <>
inline void* OdRxValue::valuePtr__<false>()
{
  ODA_ASSERT(!isInlined());
  return nonInlineValuePtr();
}
 
template <>
inline void OdRxValue::initBlittable<true>(const void* value, size_t size)
{
  ODA_ASSERT(type().isBlittable());
  ODA_ASSERT(isInlined());
  memcpy(inlineValuePtr(), value, size);
}
template <>
inline void OdRxValue::initBlittable<false>(const void* value, size_t size)
{
  ODA_ASSERT(type().isBlittable());
  ODA_ASSERT(!isInlined());
  m_value.m_ptr = allocate(size);
  memcpy(nonInlineValuePtr(), value, size);
}
 
template<typename T>
inline void OdRxValue::InitNonBlittable< T, true>::init(OdRxValue& rxValue, const T& value)
{
  //call global placement new defined above so that we can call copy constructor
  ::new ((OdRxValueStorage*)(rxValue.inlineValuePtr())) T(value);
}
 
template<typename T>
inline void OdRxValue::InitNonBlittable< T, false>::init(OdRxValue& rxValue, const T& value)
{
  rxValue.setNonInlineValue(&value, false, false, false);
}
//DOM-IGNORE-END
 
class OdRxBoxedValue;
typedef OdSmartPtr<OdRxBoxedValue> OdRxBoxedValuePtr;
 
class ODRX_ABSTRACT FIRSTDLL_EXPORT OdRxBoxedValue : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdRxBoxedValue);
 
  virtual const OdRxValue* value() const = 0;
  
  virtual OdRxValue* value() = 0;
 
  static OdRxBoxedValuePtr newBoxedValueOnHeap(const OdRxValue& value);
 
  virtual OdRxObjectPtr clone() const ODRX_OVERRIDE;
 
  virtual void copyFrom(const OdRxObject* other) ODRX_OVERRIDE;
  
  virtual bool isEqualTo(const OdRxObject * other) const ODRX_OVERRIDE;
  
  virtual OdRx::Ordering comparedTo(const OdRxObject * other) const ODRX_OVERRIDE;
};
 
class FIRSTDLL_EXPORT OdRxBoxedValueOnStack : public OdStaticRxObject<OdRxBoxedValue>
{
  OdRxValue& m_value;
public:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdRxBoxedValueOnStack);
  //DOM-IGNORE-END
 
  OdRxBoxedValueOnStack(OdRxValue& value);
  
  virtual const OdRxValue* value() const ODRX_OVERRIDE { return &m_value; }
  
  virtual OdRxValue* value() ODRX_OVERRIDE { return &m_value; }
};
 
// Type declarations follow:
//
 
#define ODRX_DECLARE_VALUE_TYPE(type, attribute)\
template<> struct OdRxValueType::Desc<type>\
{\
  attribute static const OdRxValueType& value() throw();\
  attribute static void del();\
};\
template<> OdRxValue::OdRxValue(const type&) throw();
 
ODRX_DECLARE_VALUE_TYPE(OdArray<OdRxValue>, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(char, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(signed char, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(unsigned char, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(bool, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(double, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(short, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(unsigned short, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(int, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(unsigned int, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(long, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(unsigned long, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(long long, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(unsigned long long, FIRSTDLL_EXPORT)
 
 
ODRX_DECLARE_VALUE_TYPE(float, FIRSTDLL_EXPORT)
 
 
template<> struct OdRxValueType::Desc<const OdChar*>
{
  FIRSTDLL_EXPORT static const OdRxValueType& value() throw();
  FIRSTDLL_EXPORT static void del();
};
template<> OdRxValue::OdRxValue(const OdChar* const &) throw();
 
ODRX_DECLARE_VALUE_TYPE(OdArray<bool>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<double>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<float>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<signed char>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<char>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<short>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<int>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<long>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<unsigned char>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<unsigned short>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<unsigned int>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<unsigned long>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<long long>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<unsigned long long>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<OdArray<double> >, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<OdArray<int> >, FIRSTDLL_EXPORT)
 
class OdRxClass;
 
template<> struct OdRxValueType::Desc<OdRxClass*>
{
  FIRSTDLL_EXPORT static const OdRxValueType& value() throw(); 
  FIRSTDLL_EXPORT static void del(); 
};
 
class OdAnsiString;
ODRX_DECLARE_VALUE_TYPE(OdAnsiString, FIRSTDLL_EXPORT)
class OdString;
ODRX_DECLARE_VALUE_TYPE(OdString, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdCmTransparency, FIRSTDLL_EXPORT);
 
ODRX_DECLARE_VALUE_TYPE(OdRxObjectPtr, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdDbHandle, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<OdAnsiString>, FIRSTDLL_EXPORT)
 
ODRX_DECLARE_VALUE_TYPE(OdArray<OdString>, FIRSTDLL_EXPORT)
 
 
template<> struct OdRxValueType::Desc<const char*>
{
  FIRSTDLL_EXPORT static const OdRxValueType& value() throw();
  FIRSTDLL_EXPORT static void del();
};
template<> OdRxValue::OdRxValue(const char* const &) throw();
 
#include "TD_PackPop.h"
#endif // _ODRXVALUE_INCLUDED_