1、对象引用概念
- 1.1 概念
- 1.2 所有权引用
- 1.3 指针引用
- 1.4 对象引用实现的例子
2 关于深克隆(Deep Clone)
- 2.1 深克隆基础
- 2.2 clone() 和deepClone()
- 2.3 关键概念
- - 2.3.1 克隆和存档
  - 2.3.2 克隆和所有权
  - 2.3.3 克隆和ID映射
  - 2.3.4 克隆和转换
- 2.4 典型的deepClone操作

1、对象引用概念

1.1 概念

一个对象的引用可以是“硬引用”或者“软引用”，也可以是“所有权关系引用”和“指针引用”。硬和软表示被引用的对象是否对引用对象的存在至关重要。一个硬引用表明，此对象的存在依赖于被引用的对象；一个软引用表明，一个对象对其引用的对象存在某种关系，但不是至关重要的。
所有权关系引用决定了对象如何存档。如果一个对象拥有另外一个，那么无论何时当首个对象要存档时，其他被拥有的对象亦会存档。因为一个对象只能有一个所有者，所以所有权引用用于从数据库中非冗余地写入。相反，指针引用用来描述AcDb对象之间的任意引用。指针引用用于完全（冗余）写入数据库。
比如，在下表中，双线表明是所有权引用。如果你沿着双线，每个对象只会碰到一次。如果你沿着单线（单线是指针引用），由于多个对象可以指向相同的对象，一个对象可能会碰到一次以上。要获得AcDbLine对象的完整“定义”，您需要遵循所有硬引用，包括所有权和指针（即单实线和双实线）引用。
Alt

1.2 所有权引用

当对象写入到DXF或者DWG文件中时，这个对象拥有的所有对象都会被同时写入。深克隆(Deep Clone)也会递归的复制每一个被拥有的对象。
硬所有权关系会阻止被拥有的对象被清理掉；而软所有权关系不会保护被拥有的对象被清理掉。
硬所有权关系的例子有：

数据库对象是其扩展字典的硬所有权者
块表是模型空间、图纸空间的硬所有权者（但不是其他块表记录的硬所有权者）
扩展字典是其元素的硬所有权者。

软所有权引用关系的例子有：

大多数情况下，符号表是其包含元素的软所有权拥有者（对*MODEL_SPACE, *PAPER_SPACE, *PAPER_SPACE0,以及图层0是例外；对这些元素，符号表维持了硬引用）。
字典是其元素的软所有权者（不过，你可以标识字典是其元素的硬所有权拥有者）

1.3 指针引用

你的自定义类可以包含对数据库其他对象的硬或者软指针引用。指针是一个单向链接（即，被引用对象中没有指示指针来源的信息）。一个对象可以指向或被任何数量的其他对象指向。
硬指针引用保护引用的对象免于被清理。比如，一个对象包含对某个图层硬指针引用，那么你将不能清理这个图层。当将一个已存在的数据库写到一个新数据库当中时（比如使用了WBLOCK），所有硬指针都被会复制到这个新的数据库。
硬指针引用的例子：

一个引线标注，包含对标注样式的硬指针引用。
一个文本实体，包含对一个文字样式的硬指针引用
一个标注实体，包含对一个标注样式的硬指针引用
一个多线对象，包含对一个多线样式的硬指针引用

一个软指针就是指向一个对象的指针。它不会阻止清除被引用的对象。软指针引用的例子：

Xdata引用是软指针
永久反应器是软指针。

如果你使用一个软指针去引用一个对象，在打开它之前你应该确保它存在。

1.4 对象引用实现的例子

以下在ObjectARX帮助文档中，路径为：ARX2010\samples\database\ownrshp_dg，在此摘抄出来供大家参阅。

// THE FOLLOWING CODE APPEARS IN THE SDK DOCUMENT.

// Class declarations
//
class AsdkOwnerDemo : public AcDbObject

// This is a custom object class to demonstrate what is
// necessary to create ownership trees.
//
// To keep it simple, this class has two data members: a
// simple integer to represent normal data, and a hard
// ownership ID data member to hold the object ID of an owned
// object.
//
// Get and set functions are provided for both data members.
//
{
public:
    ACRX_DECLARE_MEMBERS(AsdkOwnerDemo);
    AsdkOwnerDemo(): mIntval(0) {};
    AsdkOwnerDemo(const Adesk::Int16& val): mIntval(val) {};

    Adesk::Int16 intData();
    Acad::ErrorStatus setIntData(const Adesk::Int16&);

    AcDbHardOwnershipId idData();
    Acad::ErrorStatus setIdData(const AcDbHardOwnershipId&);

    Acad::ErrorStatus dwgInFields (AcDbDwgFiler*);
    Acad::ErrorStatus dwgOutFields(AcDbDwgFiler*) const;
    Acad::ErrorStatus dxfInFields (AcDbDxfFiler*);
    Acad::ErrorStatus dxfOutFields(AcDbDxfFiler*) const;
private:
    Adesk::Int16 mIntval;
    AcDbHardOwnershipId mObjId;
};

ACRX_DXF_DEFINE_MEMBERS(AsdkOwnerDemo, AcDbObject,
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 0,
    ASDKOWNERDEMO, OWNERSHIP);

// Gets the value of the integer data member.
//
Adesk::Int16 AsdkOwnerDemo::intData()
{
    assertReadEnabled();
    return mIntval;
}

// Sets the value of the integer data member.
//
Acad::ErrorStatus AsdkOwnerDemo::setIntData(const Adesk::Int16& val)
{
    assertWriteEnabled();
    mIntval = val;
    return Acad::eOk;
}

// Returns a copy of the ownership ID data member.
//
AcDbHardOwnershipId AsdkOwnerDemo::idData()
{
    assertReadEnabled();
    return mObjId;
}

// Sets the value of the ownership ID data member.
//
Acad::ErrorStatus AsdkOwnerDemo::setIdData(const AcDbHardOwnershipId& ownedId)
{
    if (ownedId.asOldId() == 0L) {
        return Acad::eInvalidInput;
    }
    assertWriteEnabled();

    mObjId = ownedId;

    // Now set the backpointer.  A transaction is used for
    // opening the object, so if the object is already
    // open it won't prevent this setting from taking place.
    //
    AcDbObject *pObj;
    AcTransaction *pTrans
        = actrTransactionManager->startTransaction();
    pTrans->getObject(pObj, ownedId, AcDb::kForWrite);
    pObj->setOwnerId(objectId());
    actrTransactionManager->endTransaction();

    return Acad::eOk;
}

// Files data in from a DWG file.
//
Acad::ErrorStatus AsdkOwnerDemo::dwgInFields(AcDbDwgFiler* filer)
{
    assertWriteEnabled();
    AcDbObject::dwgInFields(filer);
    // For wblock filing we wrote out our owner as a hard
    // pointer Id so now we need to read it in to keep things
    // in sync.
    //
    if (filer->filerType() == AcDb::kWblockCloneFiler) {
        AcDbHardPointerId id;
        filer->readItem(&id);
    }
    filer->readItem(&mIntval);
    filer->readItem(&mObjId);
    return filer->filerStatus();
}

// Files data out to a DWG file.
//
Acad::ErrorStatus AsdkOwnerDemo::dwgOutFields(AcDbDwgFiler* filer) const
{
    assertReadEnabled();
    AcDbObject::dwgOutFields(filer);
    // Since objects of this class will be in the Named
    // Objects Dictionary tree and may be hard referenced
    // by some other object, to support wblock we need to
    // file out our owner as a hard pointer Id so that it
    // will be added to the list of objects to be wblocked
    //
    if (filer->filerType() == AcDb::kWblockCloneFiler)
        filer->writeHardPointerId((AcDbHardPointerId)ownerId());
    filer->writeItem(mIntval);
    filer->writeItem(mObjId);
    return filer->filerStatus();
}

// Files data in from a DXF file.
//
Acad::ErrorStatus AsdkOwnerDemo::dxfInFields(AcDbDxfFiler* filer)
{
    assertWriteEnabled();

    Acad::ErrorStatus es;
    if ((es = AcDbObject::dxfInFields(filer))
        != Acad::eOk)
    {
        return es;
    }

    // Check if we're at the right subclass data marker.
    //
    if (!filer->atSubclassData(_T("AsdkOwnerDemo"))) {
        return Acad::eBadDxfSequence;
    }

    struct resbuf inbuf;
    while (es == Acad::eOk) {
        if ((es = filer->readItem(&inbuf)) == Acad::eOk) {
            if (inbuf.restype == AcDb::kDxfInt16) {
                mIntval = inbuf.resval.rint;
            } else if (inbuf.restype
                == AcDb::kDxfHardOwnershipId)
            {
                acdbGetObjectId(mObjId,
                    inbuf.resval.rlname);
            }
        }
    }
    return filer->filerStatus();
}

// Files data out to a DXF file.
//
Acad::ErrorStatus AsdkOwnerDemo::dxfOutFields(AcDbDxfFiler* filer) const
{
    assertReadEnabled();

    AcDbObject::dxfOutFields(filer);
    filer->writeItem(AcDb::kDxfSubclass, _T("AsdkOwnerDemo"));
    filer->writeItem(AcDb::kDxfInt16, mIntval);

    // Null object IDs are invalid: don't write them out.
    //
    if (mObjId.asOldId() != 0L) {
        filer->writeItem(AcDb::kDxfHardOwnershipId, mObjId);
    }
    return filer->filerStatus();
}

// Creates an AsdkOwnerDemo object (pObjC) and adds data to
// it.  Then, AsdkOwnerDemo pObjB is created and set to be
// the owner of pObjC.  Next, AsdkOwnerDemo pObjA is created
// and added to a dictionary in the named object dictionary.
// Finally, pObjA is set to own pObjB. Technically, we could
// just add pObjA to the named object dictionary itself, but
// that's not appropriate because it would clutter up the
// named object dictionary.
//

void createObjs()
{
    AcDbObjectId objIdA, objIdB, objIdC;
    AcDbDictionary *pNamedobj;
    AcDbDictionary *pDict = NULL;
    AcDbDatabase *pCurDwg = acdbHostApplicationServices()->workingDatabase();

    // Create object C with a dummy integer data value of 3.
    //
    AsdkOwnerDemo *pObjC = new AsdkOwnerDemo(3);

    // Append object C to database without setting an owner.
    //
    pCurDwg->addAcDbObject(objIdC, pObjC);

    pObjC->close();

    // Create object B with a dummy integer data value of 2.
    //
    AsdkOwnerDemo *pObjB = new AsdkOwnerDemo(2);

    // Append object B to the database without setting an owner.
    //
    pCurDwg->addAcDbObject(objIdB, pObjB);

    // Now set up ownership for object C.  The
    // AsdkOwnerDemo::setIdData() function takes the
    // objectId parameter and copies it into the
    // AcDbHardOwnershipId data member.  This places the
    // object ID in a position to be filed out/in via the
    // dwgInFields/dwgOutFields/dxfInFields/dxfOutFields
    // member functions.  This constitutes primary
    // "ownership."  The AsdkOwnerDemo::setIdData() function
    // also calls each owned object's setOwnerId() member
    // function to set the backpointer and establish the
    // full two-way ownership link.
    //
    pObjB->setIdData(objIdC);

    pObjB->close();

    // Create object A with a dummy integer data value of 1.
    //
    AsdkOwnerDemo *pObjA = new AsdkOwnerDemo(1);

    // Next, add objA to a dictionary in the named object
    // dictionary.  This will establish ownership for objA,
    // set the ownership backlink, and add it to the
    // database.
    //
    pCurDwg->getNamedObjectsDictionary(pNamedobj,
        AcDb::kForWrite);

    // Get a pointer to the ASDK_DICT dictionary.  If it
    // doesn't exist, then create it and add it to the
    // named object dictionary.
    //
    if (pNamedobj->getAt(_T("ASDK_DICT"), (AcDbObject*&) pDict,
        AcDb::kForWrite) == Acad::eKeyNotFound)
    {
        pDict = new AcDbDictionary;
        AcDbObjectId DictId;
        pNamedobj->setAt(_T("ASDK_DICT"), pDict, DictId);
    }
    pNamedobj->close();

    // add object A to the ASDK_DICT dictionary
    //
    pDict->setAt(_T("OBJA"), pObjA, objIdA);
    pDict->close();

    // Now set up ownership for object B.
    //
    pObjA->setIdData(objIdB);

    pObjA->close();
}

这个例子创建了一个自定义对象AsdkOwnerDemo，演示了如何创建一个所有权关系树。
首先，我们看下dwgOutFields函数，当我们在执行写块命令（Wblock）时，为了支持写块操作，我们需要把该对象的硬所有者ID同时写出。

Acad::ErrorStatus AsdkOwnerDemo::dwgOutFields(AcDbDwgFiler* filer) const
{
    assertReadEnabled();
    AcDbObject::dwgOutFields(filer);
    // Since objects of this class will be in the Named
    // Objects Dictionary tree and may be hard referenced
    // by some other object, to support wblock we need to
    // file out our owner as a hard pointer Id so that it
    // will be added to the list of objects to be wblocked
    //
    if (filer->filerType() == AcDb::kWblockCloneFiler)
        filer->writeHardPointerId((AcDbHardPointerId)ownerId());
    filer->writeItem(mIntval);
    filer->writeItem(mObjId);
    return filer->filerStatus();
}

类通过如下成员函数创建拥有者和被拥有者的关系。首先，设置被拥有者的ID,也就是本对象拥有的对象ID；然后，设置被拥有对象的拥有者是this指针指向对象的ID。这样，就在拥有者和被拥有者之间建立起了双向联系。

Acad::ErrorStatus AsdkOwnerDemo::setIdData(const AcDbHardOwnershipId& ownedId)
{
    if (ownedId.asOldId() == 0L) {
        return Acad::eInvalidInput;
    }
    assertWriteEnabled();
    mObjId = ownedId;	//设置拥有对象的ID，硬拥有

    // Now set the backpointer.  A transaction is used for
    // opening the object, so if the object is already
    // open it won't prevent this setting from taking place.
    //现在，设置被拥有对象的拥有者是this指针指向对象的ID
    AcDbObject *pObj;
    AcTransaction *pTrans = actrTransactionManager->startTransaction();
    pTrans->getObject(pObj, ownedId, AcDb::kForWrite);
    pObj->setOwnerId(objectId());
    actrTransactionManager->endTransaction();

    return Acad::eOk;
}

2 关于深克隆(Deep Clone)

2.1 深克隆基础

深克隆（deepClone）函数复制对象和它的的所有权引用，所有的指针引用会被忽略。而wBlock函数复制硬所有权引用以及硬指针引用，忽略软所有权引用和软指针引用。为了复制引用层次关系，所有的深克隆函数和wBlock函数同时处理对象和引用（包括所有权引用和指针引用），必要时将引用指向新的对象。
深克隆操作需要用到以后函数之一：

AcDbDatabase::deepCloneObjects()
AcDbDatabase::wblock()
AcDbDatabase::insert()

AcDbDatabase::deepCloneObjects()仅支持在一个数据库内克隆。如果你需要在数据库之间克隆对象，使用wblock()或insert()（比如，使用wblock()将对象复制到一个临时数据库，然后用insert() 将这个新数据库插入到目标数据库当中）。
通常情况下，你应当使用AcDbDatabase::deepCloneObjects()，AcDbDatabase::wblock()，AcDbDatabase::insert() ，你不需要知道如何生成ID映射，或者深复制的每个阶段详情。如果你创建了一个新类，并且你想要重载AcDbObject::deepClone() 或者AcDbObject::wblockClone()，你需要熟悉这些函数的细节。
在应用程序代码中，不应当直接调用对象的AcDbObject::deepClone() 和AcDbObject::wblockClone() 。他们仅仅作为更高层次克隆操作链中的一环。

2.2 clone() 和deepClone()

AcRxObject::clone() 函数仅仅克隆单一实体。AcDbObject::deepClone() 函数克隆该对象以及该对象拥有的其他对象。AcDbObject::deepClone()还会转换被克隆对象的引用关系。通常，deepClone函数更加安全。

2.3 关键概念

2.3.1 克隆和存档

深度克隆和wblock克隆操作都使用对象存档来复制（克隆）对象。创建一个新对象（即克隆对象）后，使用dwgOut（）将原始对象存档到内存中。最后，使用dwgIn（）将数据存到到到新的克隆对象中。

2.3.2 克隆和所有权

对象关系作为一个AcDbObjectId成员变量存在对象当中。在对象中存在四种不同关系类型——硬拥有者、软拥有者、硬指针、软指针。比如，如果你创建了一个需要文本样式的实体，这个实体对象应当会有一个AcDbObjectId类型的数据成员，指向某个AcDbTextStyleTableRecord对象；它应当会被作为硬指针被存档。这个AcDbObjectId成员被存档的方式决定了deepClone和wblock使用它的方式。
深克隆处理所有硬所有权和软所有权连接；wblock写块操作处理所有硬所有权和硬指针连接。
在这里插入图片描述

2.3.3 克隆和ID映射

ID映射是追踪克隆操作的一种机制。映射包含对象的ID对——源对象的ID（被称作"Key ID"）和克隆对象或者目标对象ID（被称为"value ID"）。ID映射也包含额外的ID对，在ID转换时需要这些非克隆的额外的ID。
当对某些对象调用deepCloneObjects（）时，会克隆其他对象，因为这些对象与克隆对象的主集合具有所有权关系。您可以查看ID映射以查看克隆了哪些其他对象。

2.3.4 克隆和转换

深克隆和wblock克隆操作实际上包含两个步骤：克隆和转换。克隆步骤是调用dwgOut（）和dwgIn（）并复制对象的步骤。第二步是转换步骤，在这一步会使用ID映射来重新连接所有的对象，以反应新的对象引用关系。
在转换过程中，必须转换所有四种类型的对象ID。一些对象已克隆并位于ID映射中，而其他对象尚未克隆且不在映射中。在ID转换过程中，如果在ID映射中找不到与引用对应的ID对，则会发生以下两种情况之一。如果引用与引用它的对象位于同一数据库中，则不处理。否则，设置为NULL。

2.4 典型的deepClone操作

如何启动一个深克隆

获取所有需要克隆的对象集
将每个对象的ID放置于数组中（AcDbObjectIdArray）
创建一个新的ID映射（AcDbIdMapping），作为deepCloneObjects的输出参数
调用deepCloneObjects。

在下面这个例子中，对象的所有者是模型空间。deepCloneObjects函数填充了idMap参数。程序然后迭代了映射中的每个实体，并对其做了额外的操作

void cloneSameOwnerObjects()
{
    // Step 1:  Obtain the set of objects to be cloned
	// 步骤一：获取即将深克隆对象的集合
    ads_name sset;
    if (acedSSGet(NULL, NULL, NULL, NULL, sset) != RTNORM) {
        acutPrintf(_T("\nNothing selected"));
        return;
    }

    // Step 2: Add obtained objectIds to list of objects to be cloned
	// 步骤二：将对象ID放置于容器中
    AdInt32 length = 0;
    acedSSLength(sset, &length);

    AcDbObjectIdArray  objList;
    AcDbObjectId ownerId = AcDbObjectId::kNull;
    for (int i = 0; i < length; i++) {
        ads_name ent;
        acedSSName(sset, i, ent);
        AcDbObjectId objId;
        acdbGetObjectId(objId, ent);

        // check to be sure same owner as first object
        AcDbObject *pObj;
        acdbOpenObject(pObj, objId, AcDb::kForRead);

        if (pObj->ownerId() == ownerId)
            objList.append(objId);
        else if (i == 0) {
            ownerId = pObj->ownerId();
            objList.append(objId);
        }
        pObj->close();
    }
    acedSSFree(sset);

    // Step 3: Get the objectId of the desired owner for
    // the cloned objects.  We'll use Model Space for
    // this example.
	//步骤三：获取这些复制后对象的新的拥有者ID，实际上就是模型空间
    AcDbBlockTable *pBlockTable;
    acdbHostApplicationServices()->workingDatabase()->getSymbolTable(pBlockTable, AcDb::kForRead);
    AcDbObjectId  modelSpaceId;
    pBlockTable->getAt(ACDB_MODEL_SPACE, modelSpaceId);
    pBlockTable->close();

    // Step 4:  Create a new ID map
    // 步骤4：新建一个ID映射
    AcDbIdMapping idMap;

    // Step 5: Call deepCloneObjects()
    // 步骤4：调用deepCloneObjects
    acdbHostApplicationServices()->workingDatabase()->deepCloneObjects(objList, modelSpaceId, idMap);

    // Now we can go through the idMap and do whatever we'd
    // like to the original and/or clone objects.
    //
    // For this example we'll print out the objectId's of
    // the new objects resulting from the cloning process
    // 现在，通过idMap，我们可以找到克隆后的对象了（AcDbIdPair中的key获取源对象ID，value获取克隆后的对象ID），然后对它任意操作。
    AcDbIdMappingIter iter(idMap);
    for (iter.start(); !iter.done(); iter.next()) {
        AcDbIdPair idPair;
        iter.getMap(idPair);
        if (!idPair.isCloned())
            continue;
	
	// 这里面有个有用的接口AcDbIdPair::isPrimary，用来判断ID对是否是主要对象（换句话说，不是因为被其他对象拥有才被克隆）。	
        acutPrintf(_T("\nObjectId is: %Ld"),
            idPair.value().asOldId());
    }
}