DbBaseSubentId.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 ODDB_DBBASESUBENT_H
#define ODDB_DBBASESUBENT_H 
#include "TD_PackPush.h"
 
#include "DbRootExport.h"
#include "DbStubPtrArray.h"
 
namespace OdDb
{
  enum SubentType
  {
    kNullSubentType = 0, //Null
    kFaceSubentType,     //Face
    kEdgeSubentType,     //Edge
    kVertexSubentType,   //Vertex
    kMlineSubentCache,   //Multiline
    kClassSubentType     //Other
  };
}
 
class DBROOT_EXPORT OdDbSubentId
{
public:
 
  OdDbSubentId()
    : m_Type(OdDb::kNullSubentType)
    , m_Index(0) 
  {}
 
  OdDbSubentId(OdDb::SubentType type, OdGsMarker index)
    : m_Type(type)
    , m_Index(index) 
  {}
 
  bool operator ==(const OdDbSubentId& subentId) const
  {
    return ((m_Index == subentId.m_Index) && (m_Type == subentId.m_Type));
  }
      
  bool operator !=(const OdDbSubentId& subentId) const
  {
    return ((m_Index != subentId.m_Index) || (m_Type != subentId.m_Type));
  }
  
  OdDb::SubentType type () const 
  { 
    return m_Type; 
  }
  
  void setType(OdDb::SubentType type) 
  { 
    m_Type = type; 
  }
 
  OdGsMarker index() const 
  { 
    return m_Index; 
  }
 
  void setIndex(OdGsMarker index) 
  { 
    m_Index = index; 
  }
 
private:
  OdDb::SubentType m_Type;
  OdGsMarker       m_Index;
};
 
class DBROOT_EXPORT OdDbBaseFullSubentPath
{
public:
 
  OdDbBaseFullSubentPath() 
  {}
 
  OdDbBaseFullSubentPath(OdDb::SubentType type, OdGsMarker index)
    : m_SubentId(type, index) 
  {}
 
  OdDbBaseFullSubentPath(OdDbStub* entId, OdDbSubentId subId)
    : m_SubentId(subId) 
  {
    m_ObjectIds.clear();
    m_ObjectIds.append(entId) ;
  }
 
  OdDbBaseFullSubentPath(OdDbStub* entId, OdDb::SubentType type, OdGsMarker index)
    : m_SubentId(type, index)
  {
    m_ObjectIds.clear();
    m_ObjectIds.append(entId) ;
  }
 
  OdDbBaseFullSubentPath(OdDbStubPtrArray objectIds, OdDbSubentId subId)
    : m_ObjectIds(objectIds) 
    , m_SubentId(subId) 
  {
  }
 
  void objectIds(OdDbStubPtrArray& objectIdsArg) const
  {
    objectIdsArg = m_ObjectIds;
  }
 
  OdDbBaseFullSubentPath& operator =(const OdDbBaseFullSubentPath& fullSubentPath)
  {
    m_ObjectIds = fullSubentPath.objectIds();
    m_SubentId  = fullSubentPath.subentId();
    return *this;
  }
 
  bool operator==(const OdDbBaseFullSubentPath& fullSubentPath) const
  {
    return m_ObjectIds == fullSubentPath.objectIds() && m_SubentId == fullSubentPath.subentId();
  }
 
  const OdDbStubPtrArray& objectIds() const
  {
    return m_ObjectIds;
  }
  
  OdDbStubPtrArray& objectIds()
  {
    return m_ObjectIds;
  }
  
  const OdDbSubentId subentId() const
  {
    return m_SubentId;
  }
 
  OdDbSubentId& subentId()
  {
    return m_SubentId;
  }
  
protected:              
  OdDbStubPtrArray  m_ObjectIds;
  OdDbSubentId      m_SubentId;
};
 
typedef OdArray<OdDbBaseFullSubentPath> OdDbBaseFullSubentPathArray;
 
DBROOT_EXPORT OdRxObject* baseDatabaseBy(OdDbStub* id);
 
class OdBaseDatabaseByResolver : public OdRxObject
{
public:
  
  virtual OdRxObject* resolve(OdRxObject* pRxDb) = 0;
};
 
DBROOT_EXPORT void addBaseDatabaseByResolver(OdBaseDatabaseByResolver* pResolver);
 
DBROOT_EXPORT void removeBaseDatabaseByResolver(OdBaseDatabaseByResolver* pResolver);
#include "TD_PackPop.h"
 
#endif