DbBaseSubentId.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 ODDB_DBBASESUBENT_H
#define ODDB_DBBASESUBENT_H 
 
#include "TD_PackPush.h"
 
#include "DbRootExport.h"
#include "DbStubPtrArray.h"
#include "RxDictionary.h"
 
namespace OdDb
{
  enum SubentType
  {
    kNullSubentType = 0, //Null
    kFaceSubentType,     //Face
    kEdgeSubentType,     //Edge
    kVertexSubentType,   //Vertex
    kMlineSubentCache,   //Multiline
    kClassSubentType,    //Other
    kAxisSubentType      //Axis
  };
}

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) 
  {}

  OdDbSubentId(OdRxClass* clazz, OdGsMarker index)
    : m_Type(OdDb::kClassSubentType)
    , m_Index(index) 
    , m_Class(clazz->name())
  {}

  bool operator ==(const OdDbSubentId& subentId) const
  {
    return ((m_Index == subentId.m_Index) && (m_Type == subentId.m_Type) && (m_Class == subentId.m_Class));
  }
      
  bool operator !=(const OdDbSubentId& subentId) const
  {
    return ((m_Index != subentId.m_Index) || (m_Type != subentId.m_Type) || (m_Class != subentId.m_Class));
  }
  
  OdDb::SubentType type () const 
  { 
    return m_Type; 
  }
  
  void setType(OdDb::SubentType type) 
  { 
    m_Type = type; 
    if (m_Type != OdDb::kClassSubentType)
      m_Class = OdString::kEmpty;
  }

  OdGsMarker index() const 
  { 
    return m_Index; 
  }

  void setIndex(OdGsMarker index) 
  { 
    m_Index = index; 
  }

  OdRxClass* typeClass() const
  { 
    return ::odrxGetClassDesc(m_Class); 
  }

  void setTypeClass(OdRxClass* clazz)
  {
    m_Type = OdDb::kClassSubentType;
    m_Class = clazz->name();
  }
 
private:
  OdDb::SubentType m_Type;
  OdGsMarker       m_Index;
  OdString         m_Class;
};

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