ResBuf.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, 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-2022 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(_ODRESBUF_H___INCLUDED_)
#define _ODRESBUF_H___INCLUDED_
 
#include "TD_PackPush.h"
 
#include "DbExport.h"
#include "RxObject.h"
#include "OdString.h"
#include "DbHandle.h"
#include "OdError.h"
 
class OdBinaryData;
class OdGePoint2d;
class OdGePoint3d;
class OdGeVector2d;
class OdGeVector3d;
class OdDbObjectId;
class OdDbDatabase;
class OdCmColor;
class OdResBuf;
class OdDbSelectionSet;
 
typedef OdSmartPtr<OdDbSelectionSet> OdDbSelectionSetPtr;
 
 
class TOOLKIT_EXPORT OdError_InvalidResBuf : public OdError
{
public:
  OdError_InvalidResBuf() : OdError(eInvalidResBuf){}
};
 
typedef OdSmartPtr<OdResBuf> OdResBufPtr;
 
class TOOLKIT_EXPORT OdResBuf : public OdRxObject
{
public:
 
  ODRX_DECLARE_MEMBERS(OdResBuf);
 
  ~OdResBuf();
 
  void copyFrom( const OdRxObject* pRb );
 
 
  bool operator==( const OdResBuf& Rb ) const;
 
 
  bool operator!=( const OdResBuf& Rb ) const;
 
 
  enum ValueType
  {
    //FELIX_CHANGE_BEGIN
    kRtNorm                     = 5100,       // Normal termination
    kRtMemErr                   = -5000,      // Global memory error
    kRtError                    = -5001,      // Some other error
    kRtCan                      = -5002,      // User cancelled request -- Ctl-C
    kRtRej                      = -5003,      // Rejected request -- invalid
    kRtFail                     = -5004,      // Link failure -- Lisp probably died 
    kRtKword                    = -5005,      // Keyword returned from getxxx() routine
    kRtInputTruncated           = -5008,      // Input didn't all fit in the buffer
    //FELIX_CHANGE_END
 
    kRtNone                     = 5000,
    kRtDouble                   = 5001,
    kRtPoint2d                  = 5002,
    kRtInt16                    = 5003,
    kRtAngle                    = 5004,
    kRtString                   = 5005,
 
    kRtEntName                  = 5006, // setObjectId()/getEntName()/getObjectId(0)
    kRtPickSet                  = 5007,
 
    kRtOrient                   = 5008,
 
    kRtPoint3d                  = 5009,
    kRtInt32                    = 5010,
    kRtColor                    = 5011,
 
    kRtVoid                     = 5014,
    kRtListBeg                  = 5016, // list begin
    kRtListEnd                  = 5017, // list end
    kRtDote                     = 5018, // dot
    kRtNil                      = 5019, // nil
 
 
 
    kRtDXF0                     = 5020,
    kRtT                        = 5021,
    kRtResBuf                   = 5023,
//  kRtModeless                 = 5027,
 
    kRtBool                     =  290,
    kRtInt8                     =  280,
    kRtVector2d                 = kRtPoint2d,
    kRtVector3d                 = kRtPoint3d,
    kRtBinaryChunk              =  310,
    kRtHandle                   =  320,
    kRtObjectId                 =  330,
    kRtSoftPointerId            =  330,
    kRtHardPointerId            =  340,
    kRtSoftOwnershipId          =  350,
    kRtHardOwnershipId          =  360,
 
    kDxfInvalid                 = -9999,
 
    kDxfXDictionary             = -6,
    kDxfPReactors               = -5,
    kDxfOperator                = -4,
    kDxfXDataStart              = -3,
    kDxfHeaderId                = -2,
    kDxfFirstEntId              = -2,
    kDxfEnd                     = -1,
    kDxfStart                   = 0,
    kDxfText                    = 1,
    kDxfXRefPath                = 1,
    kDxfShapeName               = 2,
    kDxfBlockName               = 2,
    kDxfAttributeTag            = 2,
    kDxfSymbolTableName         = 2,
    kDxfMstyleName              = 2,
    kDxfSymTableRecName         = 2,
    kDxfAttributePrompt         = 3,
    kDxfDimStyleName            = 3,
    kDxfLinetypeProse           = 3,
    kDxfTextFontFile            = 3,
    kDxfDescription             = 3,
    kDxfDimPostStr              = 3,
    kDxfTextBigFontFile         = 4,
    kDxfDimAPostStr             = 4,
    kDxfCLShapeName             = 4,
    kDxfSymTableRecComments     = 4,
    kDxfHandle                  = 5,
    kDxfDimBlk                  = 5,
    kDxfDimBlk1                 = 6,
    kDxfLinetypeName            = 6,
    kDxfDimBlk2                 = 7,
    kDxfTextStyleName           = 7,
    kDxfLayerName               = 8,
    kDxfCLShapeText             = 9,
    kDxfXCoord                 = 10,
    kDxfYCoord                 = 20,
    kDxfZCoord                 = 30,
    kDxfElevation              = 38,
    kDxfThickness              = 39,
    kDxfReal                   = 40,
    kDxfViewportHeight         = 40,
    kDxfTxtSize                = 40,
    kDxfTxtStyleXScale         = 41,
    kDxfViewWidth              = 41,
    kDxfViewportAspect         = 41,
    kDxfTxtStylePSize          = 42,
    kDxfViewLensLength         = 42,
    kDxfViewFrontClip          = 43,
    kDxfViewBackClip           = 44,
    kDxfShapeXOffset           = 44,
    kDxfShapeYOffset           = 45,
    kDxfViewHeight             = 45,
    kDxfShapeScale             = 46,
    kDxfPixelScale             = 47,
    kDxfLinetypeScale          = 48,
    kDxfDashLength             = 49,
    kDxfMlineOffset            = 49,
    kDxfLinetypeElement        = 49,
    kDxfAngle                  = 50,
    kDxfViewportSnapAngle      = 50,
    kDxfViewportTwist          = 51,
    kDxfVisibility             = 60,
    kDxfLayerLinetype          = 61,
    kDxfColor                  = 62,
    kDxfHasSubentities         = 66,
    kDxfViewportVisibility     = 67,
    kDxfViewportActive         = 68,
    kDxfViewportNumber         = 69,
    kDxfInt16                  = 70,
    kDxfViewMode               = 71,
    kDxfCircleSides            = 72,
    kDxfViewportZoom           = 73,
    kDxfViewportIcon           = 74,
    kDxfViewportSnap           = 75,
    kDxfViewportGrid           = 76,
    kDxfViewportSnapStyle      = 77,
    kDxfViewportSnapPair       = 78,
    kDxfRegAppFlags            = 71,
    kDxfTxtStyleFlags          = 71,
    kDxfLinetypeAlign          = 72,
    kDxfLinetypePDC            = 73,
    kDxfInt32                  = 90,
    kDxfSubclass               = 100,
    kDxfEmbeddedObjectStart    = 101,
    kDxfControlString          = 102,
    kDxfDimVarHandle           = 105,
    kDxfUCSOrg                 = 110,
    kDxfUCSOriX                = 111,
    kDxfUCSOriY                = 112,
    kDxfXReal                  = 140,
    // 64-bit integers can only be used with version R24 and higher
    kDxfInt64                  = 160,
 
    kDxfXInt16                 = 170,
    kDxfNormalX                = 210,
    kDxfNormalY                = 220,
    kDxfNormalZ                = 230,
    kDxfXXInt16                = 270,
    kDxfInt8                   = 280,
    kDxfRenderMode             = 281,
    kDxfBool                   = 290,
    kDxfXTextString            = 300,
    kDxfBinaryChunk            = 310,
    kDxfArbHandle              = 320,
    kDxfSoftPointerId          = 330,
    kDxfHardPointerId          = 340,
    kDxfSoftOwnershipId        = 350,
    kDxfHardOwnershipId        = 360,  
    kDxfLineWeight             = 370,
    kDxfPlotStyleNameType      = 380,
    kDxfPlotStyleNameId        = 390,
    kDxfXXXInt16               = 400,
    kDxfLayoutName             = 410,
    kDxfComment                = 999,
    kDxfXdAsciiString          = 1000,
    kDxfRegAppName             = 1001,
    kDxfXdControlString        = 1002,
    kDxfXdLayerName            = 1003,
    kDxfXdBinaryChunk          = 1004,
    kDxfXdHandle               = 1005,
    kDxfXdXCoord               = 1010,
    kDxfXdYCoord               = 1020,
    kDxfXdZCoord               = 1030,
    kDxfXdWorldXCoord          = 1011,
    kDxfXdWorldYCoord          = 1021,
    kDxfXdWorldZCoord          = 1031,
    kDxfXdWorldXDisp           = 1012,
    kDxfXdWorldYDisp           = 1022,
    kDxfXdWorldZDisp           = 1032,
    kDxfXdWorldXDir            = 1013,
    kDxfXdWorldYDir            = 1023,
    kDxfXdWorldZDir            = 1033,
    kDxfXdReal                 = 1040,
    kDxfXdDist                 = 1041,
    kDxfXdScale                = 1042,
    kDxfXdInteger16            = 1070,
    kDxfXdInteger32            = 1071
  };
 
 
  int restype() const;
 
  
  void setRestype( int resType );
 
 
  OdResBufPtr next() const;
 
 
  OdResBufPtr last() const;
 
 
  OdResBufPtr insert( OdResBuf* pRb );
 
 
  OdResBufPtr setNext( OdResBuf* pRb );
 
 
  OdString getString() const;
 
 
  void setString( const OdString& sValue );
 
 
  bool getBool() const;
 
 
  void setBool( bool bValue );
 
 
  OdInt8 getInt8() const;
 
 
  void setInt8( OdInt8 iValue );
 
 
  OdInt16 getInt16() const;
 
 
  void setInt16( OdInt16 iValue );
 
 
 
  OdInt32 getInt32() const;
 
 
  void setInt32( OdInt32 iValue );
 
 
  OdInt64 getInt64() const;
 
 
  void setInt64( OdInt64 iValue );
 
 
  double getDouble() const;
 
 
  void setDouble( double realValue );
 
 
  const OdGePoint2d& getPoint2d() const;
 
 
  void setPoint2d( const OdGePoint2d& gePoint );
 
 
  const OdGePoint3d& getPoint3d() const;
 
 
  void setPoint3d( const OdGePoint3d& gePoint );
 
 
  const OdGeVector2d& getVector2d() const;
 
 
  void setVector2d( const OdGeVector2d& geVector );
 
 
  const OdGeVector3d& getVector3d() const;
 
 
  void setVector3d(const OdGeVector3d& val);
 
 
  const OdBinaryData& getBinaryChunk() const;
 
 
  void setBinaryChunk( const OdBinaryData& bChunk );
 
 
  const OdCmColor& getColor() const;
 
 
  void setColor( const OdCmColor& cmColor );
 
 
  OdResBufPtr getResBuf() const;
 
 
  void setResBuf( const OdResBuf* pResBuf );
 
 
  OdDbHandle getHandle() const;
 
 
  void setHandle( const OdDbHandle& vHandle );
 
 
  const OdDbObjectId& getEntName() const;
 
 
  void setObjectId( const OdDbObjectId& idObject );
 
 
  OdDbObjectId getObjectId( const OdDbDatabase* pDb ) const;
 
 
  OdDbSelectionSetPtr getPickSet() const;
 
  void setPickSet(const OdDbSelectionSet* pSSet);
 
 
  static OdResBufPtr newRb(int resType = OdResBuf::kRtNone);
 
  static OdResBufPtr newRb(int resType, bool resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setBool(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, OdInt8 resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setInt8(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, OdUInt8 resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setInt8(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, OdInt16 resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setInt16(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, OdUInt16 resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setInt16(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, OdInt32 resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setInt32(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, OdUInt32 resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setInt32(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, OdInt64 resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setInt64(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, OdUInt64 resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setInt64(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, double resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setDouble(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, const OdGePoint2d& resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setPoint2d(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, const OdGePoint3d& resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setPoint3d(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, const OdGeVector2d& resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setVector2d(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, const OdGeVector3d& resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setVector3d(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, const OdString& resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setString(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, const OdChar* resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setString(resVal);
    return pRes;
  }
 
#if defined(OD_WINDOWS_DESKTOP) && defined(_MSC_VER)
  static OdResBufPtr newRb(int resType, const __wchar_t* resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setString(resVal);
    return pRes;
  }
#endif
 
  static OdResBufPtr newRb(int resType, const OdCmColor& resVal)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setColor(resVal);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, const OdDbObjectId& id)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setObjectId(id);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, const OdDbSelectionSet* pSSet)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setPickSet(pSSet);
    return pRes;
  }
 
  static OdResBufPtr newRb(int resType, const OdResBuf* pNestedRb)
  {
    OdResBufPtr pRes = newRb(resType);
    pRes->setResBuf(pNestedRb);
    return pRes;
  }
 // is used to get assertion with needed call stack only
  static void setAssertIndexByNewRb(int index);
 
  union Data
  {
    bool    Bool;                     // Boolean content
    OdInt16 Int16;                    // 8-bit or 16-bit Integer content
    OdInt32 Int32;                    // 32-bit Integer or Color content
    OdInt64 Int64;                    // 64-bit Integer or Handle content  
    double  Double;                   // double-precision floating-point content
    void*   Pointer;                  // pointer to an object
    OdUInt8 Bytes[sizeof(OdInt64)];   // Content as an array of bytes
  };
 
protected:
  OdResBuf();
 
  int m_nCode;           // Group code that defines the data type
  Data m_data;           // Value that defines the content
  OdResBufPtr m_pNext;   // Smart pointer to another instance for attaching in a sequence
};
 
inline bool
OdResBuf::operator!=( const OdResBuf& other ) const
{
  return !operator==( other );
}
 
TOOLKIT_EXPORT bool oddbCompareRbChains(const OdResBuf* pRb1, const OdResBuf* pRb2);
 
#include "TD_PackPop.h"
 
#endif //_ODRESBUF_H___INCLUDED_