目录
1、对象引用概念
1.1 概念
一个对象的引用可以是“硬引用”或者“软引用”，也可以是“所有权关系引用”和“指针引用”。硬和软表示被引用的对象是否对引用对象的存在至关重要。一个硬引用表明，此对象的存在依赖于被引用的对象；一个软引用表明，一个对象对其引用的对象存在某种关系，但不是至关重要的。
所有权关系引用决定了对象如何存档。如果一个对象拥有另外一个，那么无论何时当首个对象要存档时，其他被拥有的对象亦会存档。因为一个对象只能有一个所有者，所以所有权引用用于从数据库中非冗余地写入。相反，指针引用用来描述AcDb对象之间的任意引用。指针引用用于完全（冗余）写入数据库。
比如，在下表中，双线表明是所有权引用。如果你沿着双线，每个对象只会碰到一次。如果你沿着单线（单线是指针引用），由于多个对象可以指向相同的对象，一个对象可能会碰到一次以上。要获得AcDbLine对象的完整“定义”，您需要遵循所有硬引用，包括所有权和指针（即单实线和双实线）引用。
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());
}
}
深克隆很有用处，比如复制动态块参照：一般的clone只会复制动态块转换而成的静态块；而deepClone则会原原本本的复制动态块参照。wblock写块操作用于数据库之间的数据写入，也非常有用。
478
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
