DbGeomRef.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 DbGeomRef_INCLUDED_
#define DbGeomRef_INCLUDED_ 
#include "DbSubentId.h"
#include "DbCompoundObjectId.h"
#include "Ge/GeCurve3d.h"
#include "RxObjectImpl.h"
 
#include "TD_PackPush.h"
 
class OdDbEntity;
typedef OdSmartPtr<OdDbEntity> OdDbEntityPtr;
 
 
class DBENT_EXPORT OdDbGeomRef : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdDbGeomRef);
 
  virtual ~OdDbGeomRef();
 
  virtual void reset();
 
  virtual bool isValid() const;
 
  virtual bool isEmpty() const;
 
  virtual OdDbEntityPtr createEntity() const;
 
  virtual OdResult  evaluateAndCacheGeometry();
};
 
typedef OdSmartPtr<OdDbGeomRef> OdDbGeomRefPtr;
 
 
class DBENT_EXPORT OdDbSubentRef : public OdDbGeomRef
{
public:
  ODRX_DECLARE_MEMBERS(OdDbSubentRef);
 
  OdDbSubentRef();
 
  OdDbSubentRef(const OdDbCompoundObjectId& compId, 
                const OdDbSubentId& subent = OdDbSubentId()); 
 
  static OdSmartPtr<OdDbSubentRef> createObject( const OdDbCompoundObjectId& compId,
                const OdDbSubentId& subent = OdDbSubentId() );
 
  static OdSmartPtr<OdDbSubentRef> createObject( const OdDbCompoundObjectId* pid,
                const OdDbSubentId& subentid = OdDbSubentId() )
  {
    return createObject( *pid, subentid );
  }
 
  OdDbSubentRef& operator =(const OdDbSubentRef& src);
 
  virtual void copyFrom(const OdRxObject* src);
 
  virtual void reset();
 
  virtual bool isValid() const;
 
  virtual bool isEmpty() const;
 
  virtual const OdDbCompoundObjectId& entity() const;
 
  virtual OdDbSubentId subentId() const;
 
  virtual OdDbEntityPtr createEntity() const;
 
  virtual OdResult evaluateAndCacheGeometry(); 
 
protected:
  void setEntity(const OdDbCompoundObjectId& entityId);
 
  void setSubent(const OdDbSubentId& subentId);
 
  void setFromSubentPath(const OdDbFullSubentPath& pathSubEnt);
 
private:
  OdDbCompoundObjectId m_entityId;
  OdDbSubentId m_SubentId;
};
 
typedef OdSmartPtr<OdDbSubentRef> OdDbSubentRefPtr;
 
 
class DBENT_EXPORT OdDbFaceRef : public OdRxObjectImpl<OdDbSubentRef>
{
public:
  ODRX_DECLARE_MEMBERS(OdDbFaceRef);
 
  OdDbFaceRef();
 
  OdDbFaceRef(const OdDbCompoundObjectId& compId, 
              const OdDbSubentId& = OdDbSubentId(), 
              class BODY*pBody = NULL); 
 
  OdDbFaceRef(const OdDbFaceRef& faceRef);
 
  virtual ~OdDbFaceRef();
 
  OdDbFaceRef& operator =(const OdDbFaceRef& src);
 
  virtual void copyFrom(const OdRxObject* src);
 
  virtual void reset();
 
  virtual bool isValid() const;
 
  virtual bool isEmpty() const;
 
  class BODY* asmBody() const;
 
  virtual OdDbEntityPtr createEntity() const;
 
  virtual OdResult evaluateAndCacheGeometry();
 
private:
  class BODY* m_pAsmBody;
};
 
typedef OdSmartPtr<OdDbFaceRef> OdDbFaceRefPtr;
 
 
class DBENT_EXPORT OdDbEdgeRef : public OdRxObjectImpl<OdDbSubentRef>
{
public:
  ODRX_DECLARE_MEMBERS(OdDbEdgeRef);
 
  OdDbEdgeRef();
  
  OdDbEdgeRef(const OdDbFullSubentPath& path);
  
  OdDbEdgeRef(const OdDbCompoundObjectId& comId,
              const OdDbSubentId& edgeSubentId = OdDbSubentId(),
              const OdDbSubentId& faceSubentId = OdDbSubentId(),
              const OdGeCurve3d* pCurve = NULL);
  OdDbEdgeRef(const OdGeCurve3d* pGeCurve);
 
  OdDbEdgeRef(const OdDbEdgeRef& src);
 
  static OdSmartPtr<OdDbEdgeRef> createObject( const OdDbCompoundObjectIdPtr & pid, const OdGeCurve3d* pCurve ) {
    return createObject( *pid, pCurve );
  }
 
  static OdSmartPtr<OdDbEdgeRef> createObject( const OdDbCompoundObjectId& compId, const OdGeCurve3d* pCurve );
 
  static OdSmartPtr<OdDbEdgeRef> createObject( const OdDbEntity* pEnt );
 
  static OdSmartPtr<OdDbEdgeRef> createObject( const OdGeCurve3d* pCurve );
 
  virtual ~OdDbEdgeRef();
 
  OdDbEdgeRef& operator =(const OdDbEdgeRef& src);
 
  virtual void copyFrom(const OdRxObject* src);
 
  virtual void reset();
 
  virtual bool isValid() const;
 
  virtual bool isEmpty() const;
 
  void setFaceSubentity(const OdDbSubentId& faceSubentId);
 
  OdDbSubentId faceSubentId() const;
 
  const OdGeCurve3d* curve() const;
 
  virtual OdResult evaluateCurve(OdGeCurve3d*& src) const;
 
  virtual OdDbEntityPtr createEntity() const;
 
  virtual OdResult evaluateAndCacheGeometry(); 
 
  
  void setCurve(const OdGeCurve3d* pCurve);
 
private:
  //  Sets the constant three-dimensional curve to be hold by this edge reference.
  //*/
  //void setCurve(const OdGeCurve3d* pCurve);
  OdDbSubentId m_FaceSubentId;
  OdGeCurve3dPtr m_pCurve;
};
 
typedef OdSmartPtr<OdDbEdgeRef> OdDbEdgeRefPtr;
 
 
class DBENT_EXPORT OdDbVertexRef : public OdRxObjectImpl<OdDbSubentRef>
{
public:
  ODRX_DECLARE_MEMBERS(OdDbVertexRef);
 
  enum ImpliedType
  {
    kExplicitVertex,
    kUnknownType,
    kEdgeStart,
    kEdgeEnd,
    kEdgeMid,
    kEdgeCenter,
    kEdgeSplineControlPoint,
    kEdgeSplineFitPoint,
  };
 
  OdDbVertexRef();
  
  OdDbVertexRef(const OdDbCompoundObjectId& comId,
                const OdDbSubentId& subentId = OdDbSubentId(),
                const OdGePoint3d& point3d = OdGePoint3d::kOrigin);
 
  OdDbVertexRef(const OdDbFullSubentPath& fullPath);
 
  OdDbVertexRef(const OdDbEntity* pEnt);
  
  OdDbVertexRef(const OdGePoint3d& point3d);
 
  OdDbVertexRef(ImpliedType implType, 
                const OdDbEdgeRef& edgeRef,
                int controlOrFitPointIndex = 0,
                const OdGePoint3d& point3d = OdGePoint3d::kOrigin);
 
  OdDbVertexRef(const OdDbVertexRef& src);
 
  static OdSmartPtr<OdDbVertexRef> createObject( const OdGePoint3d& );
 
  static OdSmartPtr<OdDbVertexRef> createObject( const OdDbObjectId entId, const OdDbSubentId subId, const OdGePoint3d& point );
 
  virtual ~OdDbVertexRef();
 
  OdDbVertexRef& operator =(const OdDbVertexRef& other);
 
  virtual void copyFrom(const OdRxObject* src);
 
  virtual void reset();
 
  virtual bool isValid() const;
 
  virtual const OdDbCompoundObjectId& entity() const;
 
  virtual OdDbSubentId subentId() const;
 
  ImpliedType impliedType() const;
 
  const OdDbGeomRef* referencedRef() const;
 
  int index() const;
 
  OdGePoint3d point() const;
 
  virtual OdResult evaluatePoint(OdGePoint3d& point) const;
 
  OdDbEntityPtr createEntity()const;
 
  virtual OdResult evaluateAndCacheGeometry(); 
 
private:
  void setReferencedRef(OdDbGeomRefPtr pReferencedRef);
 
  ImpliedType m_ImpliedType;
  OdDbGeomRefPtr m_pReferencedRef;
  int m_Index;
  OdGePoint3d m_Point; 
};
 
typedef OdSmartPtr<OdDbVertexRef> OdDbVertexRefPtr;
 
 
class DBENT_EXPORT OdDbPathRef : public OdRxObjectImpl<OdDbGeomRef>
{
public:
  ODRX_DECLARE_MEMBERS(OdDbPathRef);
 
  OdDbPathRef();
  OdDbPathRef(const OdArray<OdDbEdgeRef>& edges);
 
  OdDbPathRef(const OdDbFullSubentPathArray& edgeSubentPathArr,
              const OdDbFullSubentPathArray& faceSubentPathArr);
 
  OdDbPathRef(const OdDbPathRef& src);
 
  virtual ~OdDbPathRef();
 
  OdDbPathRef& operator =(const OdDbPathRef&);
 
  virtual void copyFrom(const OdRxObject* src);
 
  virtual void reset();
 
  virtual bool isValid() const;
 
  virtual bool isEmpty() const;
 
  void setEdgeRefs(const OdArray<OdDbEdgeRef>& edges);
 
  OdResult getEntityArray(OdArray<OdDbEntity*>& entities, bool concatenate) const;
 
  const OdArray<OdDbEdgeRef>& edgeRefs() const;
 
  bool isEqualTo(const OdGeCurve3d* pOther);
 
  bool isReferencePath();
 
  virtual OdDbEntityPtr createEntity() const;
 
  virtual OdResult evaluateAndCacheGeometry();
 
private:
  OdArray<OdDbEdgeRef> m_EdgeRefs;
};
 
typedef OdSmartPtr<OdDbPathRef> OdDbPathRefPtr;
 
 
class DBENT_EXPORT OdDbVectorRef : public OdRxObjectImpl<OdDbGeomRef>
{
public:
  ODRX_DECLARE_MEMBERS(OdDbVectorRef);
 
  OdDbVectorRef();
 
  OdDbVectorRef(const OdGeVector3d& vector);
 
  OdDbVectorRef(const OdDbVectorRef& src);
 
  virtual ~OdDbVectorRef();
 
  OdDbVectorRef& operator =(const OdDbVectorRef& src);
 
  virtual void copyFrom(const OdRxObject* src);
 
  virtual void reset();
 
  virtual bool isValid() const;
 
  virtual bool isEmpty() const;
 
  const OdGeVector3d vector() const;
 
  void set(const OdGeVector3d& vector);
 
  virtual OdDbEntityPtr createEntity() const;
 
  virtual OdResult evaluateAndCacheGeometry();
 
private:
  OdGeVector3d m_Vector;
};
 
typedef OdSmartPtr<OdDbVectorRef> OdDbVectorRefPtr;
 
 
class DBENT_EXPORT OdDbCoordSystemRef : public OdRxObjectImpl<OdDbGeomRef>
{
public:
  ODRX_DECLARE_MEMBERS(OdDbCoordSystemRef);
 
  OdDbCoordSystemRef();
 
  OdDbCoordSystemRef(const OdGeMatrix3d& matrix);
  
  OdDbCoordSystemRef(const OdDbCompoundObjectId& compId, const OdGeMatrix3d& matrix);
 
  OdDbCoordSystemRef(const OdArray<OdDbSubentRef*>& aSubentRef);
 
  OdDbCoordSystemRef(const OdDbCoordSystemRef& src);
 
  virtual ~OdDbCoordSystemRef();
 
  OdDbCoordSystemRef& operator = (const OdDbCoordSystemRef&);
 
  virtual void copyFrom(const OdRxObject*);
 
  virtual void reset();
 
  virtual bool isValid() const;
 
  virtual bool isEmpty() const;
 
  const OdGeMatrix3d& coordSystem() const;
 
  const OdDbCompoundObjectId& entityId() const;
 
  const OdArray<OdDbSubentRef*>& subentRefs() const;
 
  void set(const OdGeMatrix3d& matrix);
  
  void set(const OdDbCompoundObjectId& entId);
  
  void set(const OdArray<OdDbSubentRef*>& subentReferences);
 
  virtual OdDbEntityPtr createEntity() const;
 
  virtual OdResult evaluateAndCacheGeometry();
 
private:
  OdGeMatrix3d m_CoordSystem;
  OdDbCompoundObjectId m_entityId;
  OdArray<OdDbSubentRef*> m_SubentRefs;
};
 
typedef OdSmartPtr<OdDbCoordSystemRef> OdDbCoordSystemRefPtr;
 
#include "TD_PackPop.h"
 
#endif // DbGeomRef_INCLUDED_