ObjectARX的对象引用关系以及深克隆（deepClone）

1、对象引用概念

1.1 概念

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

1.2 所有权引用

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

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

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

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

1.3 指针引用

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

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

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

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

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

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();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269

这个例子创建了一个自定义对象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();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

类通过如下成员函数创建拥有者和被拥有者的关系。首先，设置被拥有者的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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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操作

如何启动一个深克隆

1. 获取所有需要克隆的对象集
2. 将每个对象的ID放置于数组中（AcDbObjectIdArray）
3. 创建一个新的ID映射（AcDbIdMapping），作为deepCloneObjects的输出参数
4. 调用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());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

深克隆很有用处，比如复制动态块参照：一般的clone只会复制动态块转换而成的静态块；而deepClone则会原原本本的复制动态块参照。wblock写块操作用于数据库之间的数据写入，也非常有用。