IfcEntity.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, 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-2024 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_INSTANCE_H_
#define _IFC_INSTANCE_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 OdIfcInstance : public OdDAI::ApplicationInstance
  {
  public:
 
    //DOM-IGNORE-BEGIN
    ODRX_DECLARE_MEMBERS(OdIfcInstance);
    //DOM-IGNORE-END

    OdIfcInstance();
    
    ~OdIfcInstance();

    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 OdIfcInstance *inst) {
      if (inst->m_resolved == kResPoint3d || inst->m_resolved == kResPoint2d)
        return reinterpret_cast<OdGePoint3d*>(inst->m_resPtr);
      ODA_ASSERT(0);
      return nullptr;
    };

    static const OdGePoint2d* asPoint2d(const OdIfcInstance *inst) {
      if (inst->m_resolved == kResPoint2d || inst->m_resolved == kResPoint3d)
        return reinterpret_cast<OdGePoint2d*>(inst->m_resPtr);
      ODA_ASSERT(0);
      return nullptr;
    };

    static const OdGeVector3d* asVector3d(const OdIfcInstance *inst) {
      if (inst->m_resolved == kResVector3d || inst->m_resolved == kResVector2d)
        return reinterpret_cast<OdGeVector3d*>(inst->m_resPtr);
      ODA_ASSERT(0);
      return nullptr;
    };

    static const OdGeVector2d* asVector2d(const OdIfcInstance *inst) {
      if (inst->m_resolved == kResVector2d || inst->m_resolved == kResVector3d)
        return reinterpret_cast<OdGeVector2d*>(inst->m_resPtr);
      ODA_ASSERT(0);
      return nullptr;
    };

    static const OdGeMatrix2d* asMatrix2d(const OdIfcInstance *inst) {
      if (inst->m_resolved == kResMatrix2d)
        return reinterpret_cast<OdGeMatrix2d*>(inst->m_resPtr);
      ODA_ASSERT(0);
      return nullptr;
    };

    static const OdGeMatrix3d* asMatrix3d(const OdIfcInstance *inst) {
      if (inst->m_resolved == kResMatrix3d)
        return reinterpret_cast<OdGeMatrix3d*>(inst->m_resPtr);
      ODA_ASSERT_ONCE(0);
      return nullptr;
    };

    static OdIfcCompoundPtr asCompound(OdSmartPtr<OdIfcInstance> inst);

    static const OdCmEntityColor* asRgbColor(const OdIfcInstance *inst) {
      if (inst->m_resolved == kRgbColor)
        return reinterpret_cast<OdCmEntityColor*>(inst->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;

    virtual OdDbStub* ownerId() 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(OdIfcInstance);
 
} //namespace OdIfc
 
#endif // _IFC_INSTANCE_H_