IfcEntity.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.
 
#ifndef _IFC_ENTITY_H_
#define _IFC_ENTITY_H_
 
#include "IfcCommon.h"
#include "IfcBuildOptions.h"
#include "IfcEntityTypes.h"
#include "IfcAttributesEnum.h"
#include "daiApplicationInstance.h"
#include "daiEntity.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"
 
namespace OdIfc {
 
  enum IfcOpResult
  {
    kUnresolved = 0, 
    kResVisited = 1, 
    kResPoint2d, 
    kResPoint3d, 
    kResVector2d, 
    kResVector3d, 
    kResMatrix2d, 
    kResMatrix3d, 
    kRgbColor, 
    kResCompound, 
    kResError 
  };
 
  class OdIfcCompound;
 
  typedef OdSmartPtr<OdIfcCompound> OdIfcCompoundPtr;
 
  class IFCCORE_EXPORT OdIfcEntity : public OdDAI::ApplicationInstance
  {
  public:
 
    //DOM-IGNORE-BEGIN
    ODRX_DECLARE_MEMBERS(OdIfcEntity);
    //DOM-IGNORE-END
 
    OdIfcEntity();
    
    ~OdIfcEntity();
 
    virtual bool isKindOf(OdIfcEntityType entityType) const;
 
    bool isInstanceOf(OdIfcEntityType entityType) const;
 
    virtual OdIfcEntityType type() const;
    
    using OdDAI::ApplicationInstance::getAttr;
 
    virtual OdRxValue getAttr(const OdIfcAttribute attrDef) const;
 
    virtual bool testAttr(const char * explicitAttrName) const;
 
    virtual bool testAttr(const OdIfcAttribute explicitAttrDef) const;
 
    virtual void unsetAttr(const char * explicitAttrName);
 
    virtual void unsetAttr(const OdIfcAttribute explicitAttrDef);
 
    virtual bool putAttr(const char * 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;
    };
 
    void unresolve();
 
    static const OdGePoint3d* asPoint3d(const OdIfcEntity *pEnt) {
      if (pEnt->m_resolved == kResPoint3d || pEnt->m_resolved == kResPoint2d)
        return reinterpret_cast<OdGePoint3d*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return nullptr;
    };
 
    static const OdGePoint2d* asPoint2d(const OdIfcEntity *pEnt) {
      if (pEnt->m_resolved == kResPoint2d || pEnt->m_resolved == kResPoint3d)
        return reinterpret_cast<OdGePoint2d*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return nullptr;
    };
 
    static const OdGeVector3d* asVector3d(const OdIfcEntity *pEnt) {
      if (pEnt->m_resolved == kResVector3d || pEnt->m_resolved == kResVector2d)
        return reinterpret_cast<OdGeVector3d*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return nullptr;
    };
 
    static const OdGeVector2d* asVector2d(const OdIfcEntity *pEnt) {
      if (pEnt->m_resolved == kResVector2d || pEnt->m_resolved == kResVector3d)
        return reinterpret_cast<OdGeVector2d*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return nullptr;
    };
 
    static const OdGeMatrix2d* asMatrix2d(const OdIfcEntity *pEnt) {
      if (pEnt->m_resolved == kResMatrix2d)
        return reinterpret_cast<OdGeMatrix2d*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return nullptr;
    };
 
    static const OdGeMatrix3d* asMatrix3d(const OdIfcEntity *pEnt) {
      if (pEnt->m_resolved == kResMatrix3d)
        return reinterpret_cast<OdGeMatrix3d*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return nullptr;
    };
 
    static OdIfcCompoundPtr asCompound(OdSmartPtr<OdIfcEntity> pEnt);
 
    static const OdCmEntityColor* asRgbColor(const OdIfcEntity *pEnt) {
      if (pEnt->m_resolved == kRgbColor)
        return reinterpret_cast<OdCmEntityColor*>(pEnt->m_resPtr);
      ODA_ASSERT(0);
      return nullptr;
    }
 
    virtual void setGsNode(OdGsCache* pGsNode);
 
    virtual OdGsCache* gsNode() const;
 
    virtual OdUInt32 subSetAttributes(OdGiDrawableTraits * traits) const;
 
    virtual bool subWorldDraw(OdGiWorldDraw * wd) const;
 
    using OdDAI::ApplicationInstance::isKindOf;
 
//DOM-IGNORE-BEGIN
  protected:
 
    void          *m_resPtr;
    IfcOpResult   m_resolved;
 
  private:
 
    void* asCustom() const { return m_resPtr; }
 
    friend class OdIfcCompound;
//DOM-IGNORE-END
  };
 
  SMARTPTR(OdIfcEntity);
 
} //namespace OdIfc
 
#endif // _IFC_ENTITY_H_