IfcEntity.h

Go to the documentation of this file.

// Copyright (C) 2002-2019, 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-2019 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 _IFC_ENTITY_H_
#define _IFC_ENTITY_H_
 
#include "DbHandle.h"
#include "IfcCommon.h"
#include "IfcBuildOptions.h"
#include "IfcEntityTypes.h"
#include "IfcAttributesEnum.h"
#include "daiObjectId.h"
#include "daiAny.h"
#include "daiEntityInstance.h"
#include "daiEntity.h"
#include "daiModel.h"
 
#include "Ge/GePoint2d.h"
#include "Ge/GePoint3d.h"
#include "Ge/GeVector2d.h"
#include "Ge/GeVector3d.h"
#include "Ge/GeMatrix2d.h"
#include "Ge/GeMatrix3d.h"
#include "CmColorBase.h"
 
#define STL_USING_LIMITS
#include "OdaSTL.h"
 
namespace OdIfc {
 
  enum IfcOpResult
  {
    kUnresolved = 0, // Unresolved operation.
    kResVisited = 1, // No appropriate compound object exists for the entity instance.
    kResPoint2d,     // The entity is composed as an <exref target="https://docs.opendesign.com/tkernel/OdGePoint2d.html">OdGePoint2d</exref> object.
    kResPoint3d,     // The entity is composed as an <exref target="https://docs.opendesign.com/tkernel/OdGePoint3d.html">OdGePoint3d</exref> object.
    kResVector2d,    // The entity is composed as an <exref target="https://docs.opendesign.com/tkernel/OdGeVector2d.html">OdGeVector2d</exref> object.
    kResVector3d,    // The entity is composed as an <exref target="https://docs.opendesign.com/tkernel/OdGeVector3d.html">OdGeVector3d</exref> object.
    kResMatrix2d,    // The entity is composed as an <exref target="https://docs.opendesign.com/tkernel/OdGeMatrix2d.html">OdGeMatrix2d</exref> object.
    kResMatrix3d,    // The entity is composed as an <exref target="https://docs.opendesign.com/tkernel/OdGeMatrix3d.html">OdGeMatrix3d</exref> object.
    kRgbColor,       // The entity is composed as an RGB color value.
    kResCompound,    // The entity has attached a compound object.
    kResError        // An error occurred during the compose operation.
  };
 
  class OdIfcModelContents;
  class OdIfcCompound;
 
  typedef OdSmartPtr<OdIfcCompound> OdIfcCompoundPtr;
 
  class IFCCORE_EXPORT OdIfcEntity : public OdDAI::EntityInstance
  {
  public:
 
    //DOM-IGNORE-BEGIN
    ODRX_DECLARE_MEMBERS(OdIfcEntity);
    //DOM-IGNORE-END
 
    OdIfcEntity();
    
    ~OdIfcEntity();
 
    virtual bool isKindOf(OdIfcEntityType entityType) const;
 
    virtual bool isInstanceOf(OdIfcEntityType entityType) const;
 
    virtual OdIfcEntityType type() const = 0;
 
    virtual OdRxValue getAttr(const OdAnsiString &attrName) const;
 
    virtual OdRxValue getAttr(const OdIfcAttribute attrDef) const;
 
    virtual bool testAttr(const OdAnsiString &explicitAttrName) const;
 
    virtual bool testAttr(const OdIfcAttribute explicitAttrDef) const;
 
    virtual void unsetAttr(const OdAnsiString &explicitAttrName);
 
    virtual void unsetAttr(const OdIfcAttribute explicitAttrDef);
 
    virtual bool putAttr(const OdAnsiString &explicitAttrName, const OdRxValue &val);
 
    virtual bool putAttr(const OdIfcAttribute explicitAttrDef, const OdRxValue &val);
 
    IfcOpResult resolved() { return m_resolved; };
 
    void resolve(IfcOpResult resolved, void *resPtr)
    {
      ODA_ASSERT_ONCE(
        ((resolved == kUnresolved || resolved == kResVisited) && !resPtr)
          || resPtr);
      m_resolved = resolved;
      m_resPtr = resPtr;
    };
 
    static OdGePoint3d* asPoint3d(OdSmartPtr<OdIfcEntity> pEnt) {
      if (pEnt->m_resolved == kResPoint3d || pEnt->m_resolved == kResPoint2d)
        return reinterpret_cast<OdGePoint3d*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return NULL;
    };
 
    static OdGePoint2d* asPoint2d(OdSmartPtr<OdIfcEntity> pEnt) {
      if (pEnt->m_resolved == kResPoint3d || pEnt->m_resolved == kResPoint2d)
        return reinterpret_cast<OdGePoint2d*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return NULL;
    };
 
    static OdGeVector3d* asVector3d(OdSmartPtr<OdIfcEntity> pEnt) {
      if (pEnt->m_resolved == kResVector3d || pEnt->m_resolved == kResVector2d)
        return reinterpret_cast<OdGeVector3d*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return NULL;
    };
 
    static OdGeVector2d* asVector2d(OdSmartPtr<OdIfcEntity> pEnt) {
      if (pEnt->m_resolved == kResVector3d || pEnt->m_resolved == kResVector2d)
        return reinterpret_cast<OdGeVector2d*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return NULL;
    };
 
    static OdGeMatrix2d* asMatrix2d(OdSmartPtr<OdIfcEntity> pEnt) {
      if (pEnt->m_resolved == kResMatrix2d)
        return reinterpret_cast<OdGeMatrix2d*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return NULL;
    };
 
    static OdGeMatrix3d* asMatrix3d(OdSmartPtr<OdIfcEntity> pEnt) {
      if (pEnt->m_resolved == kResMatrix3d)
        return reinterpret_cast<OdGeMatrix3d*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return NULL;
    };
 
    /*OdGeCurve2d* asCurve2d() {
    if (m_resolved == kResCurve2d)
    return reinterpret_cast<OdGeCurve2d*>(m_resPtr);
    ODA_ASSERT(0);
    return NULL;
    }
 
    OdGeCurve3d* asCurve3d() {
    if (m_resolved == kResCurve3d)
    return reinterpret_cast<OdGeCurve3d*>(m_resPtr);
    ODA_ASSERT(0);
    return NULL;
    }*/
 
    static OdIfcCompoundPtr asCompound(OdSmartPtr<OdIfcEntity> pEnt);
 
    static OdCmEntityColor* asRgbColor(OdSmartPtr<OdIfcEntity> pEnt) {
      if (pEnt->m_resolved == kRgbColor)
        return reinterpret_cast<OdCmEntityColor*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return NULL;
    }
 
    virtual void setGsNode(OdGsCache* pGsNode);
 
    virtual OdGsCache* gsNode() const;
 
    virtual OdUInt32 subSetAttributes(OdGiDrawableTraits * traits) const;
 
    virtual bool subWorldDraw(OdGiWorldDraw * wd) const;
 
//DOM-IGNORE-BEGIN
  protected:
 
    void          *m_resPtr;
    IfcOpResult   m_resolved;
 
  private:
 
    void* asCustom() const { return m_resPtr; }
 
    friend class OdIfcCompound;
    friend class OdIfcModelContents;
//DOM-IGNORE-END
  };
 
  SMARTPTR(OdIfcEntity);
 
} //namespace OdIfc
 
#endif // _IFC_ENTITY_H_