DbIdMapping.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 __ODDBIDMAPPING_INCLUDED__
#define __ODDBIDMAPPING_INCLUDED__
 
#include "TD_PackPush.h"
 
#include "OdaDefs.h"
#include "DbObjectId.h"
#include "DbObject.h"
#include "RxObject.h"
 
class OdDbDatabase;
class OdDbIdMapping;
 
typedef OdSmartPtr<OdDbIdMapping> OdDbIdMappingPtr;
 
class OdDbIdPair
{
public:
  OdDbIdPair()
    : m_bCloned(false), m_bOwnerXlated(false), m_bPrimary(false) { }
    
  OdDbIdPair(
    const OdDbIdPair& source)
    : m_Key(source.key())
    , m_Value(source.value())
    , m_bCloned(source.isCloned())
    , m_bOwnerXlated(source.isOwnerXlated())
    , m_bPrimary(source.isPrimary()){ }
 
  OdDbIdPair(
    const OdDbObjectId& key)
    : m_Key(key)
    , m_bCloned(false)
    , m_bOwnerXlated(false)
    , m_bPrimary(false){ }
    
  OdDbIdPair(
    const OdDbObjectId& key, 
    const OdDbObjectId& value, 
    bool cloned = false,
    bool ownerXlated = true,
    bool primary = false)
    : m_Key(key)
    , m_Value(value)
    , m_bCloned(cloned)
    , m_bOwnerXlated(ownerXlated)
    , m_bPrimary(primary) { }
 
  
  OdDbObjectId key() const { return m_Key; } 
 
  OdDbObjectId value() const { return m_Value; }
 
  inline bool isCloned() const { return m_bCloned; }
  
  inline bool isPrimary() const { return m_bPrimary; }
  
  inline bool isOwnerXlated() const { return m_bOwnerXlated; }
  
  OdDbIdPair& set(
    const OdDbObjectId& key, 
    const OdDbObjectId& value,
    bool cloned = false,
    bool ownerXlated = true,
    bool primary = false)
  {
    setKey(key);
    setValue(value);
    setCloned(cloned);
    setOwnerXlated(ownerXlated);
    return *this;
  }
 
    
  void setKey(
    const OdDbObjectId& key) { m_Key = key; }
    
  void setValue(
    const OdDbObjectId& value) { m_Value = value; }
    
  void setCloned(
    bool cloned) { m_bCloned = cloned; }
 
    void setPrimary(bool primary) { m_bPrimary = primary; }
 
  void setOwnerXlated(
    bool ownerXlated) { m_bOwnerXlated = ownerXlated; }
  
private:
  OdDbObjectId m_Key;
  OdDbObjectId m_Value;
  bool m_bCloned;
  bool m_bOwnerXlated;
  bool m_bPrimary;
};
 
class OdDbIdMappingIter;
 
typedef OdSmartPtr<OdDbIdMappingIter> OdDbIdMappingIterPtr;
 
namespace OdDb
{
  enum DeepCloneType
  {
    kDcCopy           = 0,    // Copy, Array, Mirror
    kDcExplode        = 1,    // Explode
    kDcBlock          = 2,    // Block definition
    kDcXrefBind       = 3,    // Xref Bind
    kDcSymTableMerge  = 4,    // Xref Attach, DxfIn, IgesIn
    kDcInsert         = 6,    // Insert of a .dwg file
    kDcWblock         = 7,    // Wblock
    kDcObjects        = 8,    // OdDbDatabase::deepCloneObjects()
    kDcXrefInsert     = 9,    // Xref Insert, Xref BInd
    kDcInsertCopy     = 10,   // Insert() 
    kDcWblkObjects    = 11    // Wblock objects
  };
}
 
class TOOLKIT_EXPORT OdDbIdMapping : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdDbIdMapping);
 
  OdDbIdMapping() {}
  
  static OdDbIdMappingPtr createObject(OdDb::DeepCloneType);
  
  virtual void assign(
    const OdDbIdPair& idPair) = 0;
 
  virtual bool compute(
    OdDbIdPair& idPair) const = 0;
  virtual bool del(
    const OdDbObjectId& key) = 0;
 
   virtual OdDbIdMappingIterPtr newIterator() = 0;
  
  virtual OdDbDatabase* destDb() const = 0;
  
  virtual void setDestDb(
    OdDbDatabase* pDb) = 0;
 
  virtual OdDbDatabase* origDb() const = 0;
  
  virtual OdDbObjectId insertingXrefBlockId() const = 0;
  
  virtual OdDb::DeepCloneType deepCloneContext() const = 0;
  
  virtual OdDb::DuplicateRecordCloning duplicateRecordCloning() const = 0;
};
 
class TOOLKIT_EXPORT OdDbIdMappingIter : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdDbIdMappingIter);
 
  OdDbIdMappingIter() {}
  
    virtual void start() = 0;
  
   virtual void getMap(
    OdDbIdPair& idPair) = 0;
 
  virtual void next() = 0;
  
    virtual bool done() = 0;
};
 
 
#include "TD_PackPop.h"
 
#endif // __ODDBIDMAPPING_INCLUDED__