OdValue.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, 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-2017 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 _ODVALUE_INCLUDED_
#define _ODVALUE_INCLUDED_
 
#include "TD_PackPush.h"
#include "StaticRxObject.h"
 
class OdValueImpl;
class OdValue;
typedef OdSmartPtr<OdValue> OdValuePtr;
 
class TOOLKIT_EXPORT OdValue : public OdStaticRxObject<OdRxObject>
{
public:
  ODRX_HEAP_OPERATORS();
 
  enum DataType
  {
    kUnknown            = 0x00,
    kLong               = 0x01,
    kDouble             = 0x02,
    kString             = 0x04,
    kDate               = 0x08,
    kPoint              = 0x10,
    k3dPoint            = 0x20,
    kObjectId           = 0x40,
    kBuffer             = 0x80,
    kResbuf             = 0x100,
    kGeneral            = 0x200,
    kColor              = 0x400
  };
 
  enum UnitType
  {
    kUnitless           = 0x00,
    kDistance           = 0x01,
    kAngle              = 0x02,
    kArea               = 0x04,
    kVolume             = 0x08,
    kCurrency           = 0x10,
    kPercentage         = 0x20
  };
 
  enum ParseOption
  {
    kParseOptionNone        = 0x00,
    kSetDefaultFormat       = 0x01,
    kPreserveMtextFormat    = 0x02,
    kConvertTextToValue     = 0x04,
    kChangeDataType         = 0x08,
    kParseTextForFieldCode  = 0x10
  };
 
  enum FormatOption
  {
    kFormatOptionNone       = 0x00,
    kForEditing             = 0x01,
    kForExpression          = 0x02,
    kUseMaximumPrecision    = 0x04,
    kIgnoreMtextFormat      = 0x08
  };
 
 
public:
  ODRX_DECLARE_MEMBERS(OdValue);
 
  OdValue(void);
  ~OdValue(void);
 
  OdValue(const OdValue& value);
  OdValue(const OdString& value);
  OdValue(OdInt32 value);
  OdValue(double value);
  OdValue(const OdInt64& date);
  OdValue(double x, double y);
  OdValue(double x, double y, double z);
  OdValue(const OdDbObjectId& objectId);
  OdValue(const OdResBufPtr& resBuf);
  OdValue(const OdTimeStamp& time); //FELIX_CHANGE Backport from 22.4
  // OdValue(const OdRxVariantValue& var);
 
  OdValue(const void* buffer, OdInt32 bufferSize);
 
  bool reset();
  OdValue::DataType dataType () const;
  bool isValid () const;
 
  operator OdString() const;
  operator OdInt32() const;
  operator double() const;
  operator OdInt64() const;
  operator OdDbObjectId() const;  
 
  OdValue& operator=(const OdValue& value);
  OdValue& operator=(const OdString& value);
  OdValue& operator=(OdInt32 value);
  OdValue& operator=(double value);
  OdValue& operator=(OdInt64 date);
  OdValue& operator=(const OdDbObjectId& objectId);
  OdValue& operator=(const OdResBufPtr& resBuf);
 
  // OdValue& operator=    (const OdRxVariantValue& var);
 
  // bool  get                    (const OdChar*& pszValue) const;
 
  bool get(OdString& value) const;
  bool get(OdInt32& value) const;
  bool get(double& value) const;
  bool get(OdInt64& date) const;
  bool get(double& x, double& y) const;
  bool get(double& x, double& y, double& z) const;
  bool get(OdDbObjectId& objectId) const;
  bool get(OdResBufPtr& resBuf) const;
 
  // bool get(OdRxVariantValue& var) const;
 
  bool get(void*& pBuf, OdInt32& bufferSize) const;
  bool get(OdTimeStamp& time) const; //FELIX_CHANGE Backport from 22.4
  bool set(const OdValue& value);
  bool set(const OdString& value);
  bool set(OdInt32 value);
  bool set(double value);
  bool set(const OdInt64& date);
  bool set(double x, double y);
  bool set(double x, double y, double z);
  bool set(const OdDbObjectId& objectId);
  bool set(const OdResBufPtr& resBuf);
 
  // bool  set                    (const OdRxVariantValue& var);
 
  bool set(const void* buffer, OdInt32 bufferSize);
 
  bool set(const OdTimeStamp& time); //FELIX_CHANGE Backport from 22.4
//     bool  reset                   (void);
  bool  reset  (OdValue::DataType nDataType);
//     bool  resetValue              (void);
 
  OdValue::UnitType unitType (void) const;
  void  setUnitType (OdValue::UnitType nUnitType);
  OdString   getFormat (void) const;
  void  setFormat (const OdString& pszFormat);
 
//     bool  parse                   (const OdString& pszText, 
//                                             OdValue::DataType nDataType, 
//                                             OdValue::UnitType nUnitType, 
//                                             const ACHAR* pszFormat, 
//                                             OdValue::ParseOption nOption, 
//                                             const AcDbObjectId* pTextStyleId);
// 
 
  OdString  format(OdDbDatabase* pDb = 0) const;
  OdString format(OdValue::FormatOption nOption, OdDbDatabase* pDb = 0);
  OdString format(const OdString& pszFormat, OdValue::FormatOption nOption, OdDbDatabase* pDb = 0);
  bool format(const OdString& pszFormat, OdString& pszValue, OdDbDatabase* pDb = 0) const;
 
  bool  convertTo               (OdValue::DataType nDataType, 
                                          OdValue::UnitType nUnitType);
  bool  convertTo               (OdValue::DataType nDataType, 
                                          OdValue::UnitType nUnitType, 
                                          bool bResetIfIncompatible);
 
  virtual OdResult dwgInFields (
    OdDbDwgFiler* pFiler);
  virtual void dwgOutFields(
    OdDbDwgFiler* pFiler) const;
 
  virtual OdResult dxfInFields (
    OdDbDxfFiler* pFiler);
  virtual void dxfOutFields(
    OdDbDxfFiler* pFiler) const;
 
protected:
  OdValue(OdValueImpl* pValImpl);
 
  friend class OdDbSystemInternals;
  OdValueImpl* m_pImpl;
};
 
#include "TD_PackPop.h"
 
#endif // _ODVALUE_INCLUDED_