OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

#3214 AppFwk : Add function to get referencing objects of specified type

Browse Source
This commit is contained in:
Magne Sjaastad 2018-08-15 12:36:42 +02:00
parent 37962e040c
commit 97c3b9efea
2 changed files with 171 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

295
Fwk/AppFwk/cafProjectDataModel/cafPdmCore/cafPdmCore_UnitTests/cafPdmCoreBasicTest.cpp
View File

@ -14,13 +14,11 @@
#include <vector> #include <vector>
class DemoPdmObject : public caf::PdmObjectHandle
class DemoPdmObject: public caf::PdmObjectHandle
{ {
public: public:
DemoPdmObject()
DemoPdmObject() {
{
this->addField(&m_proxyDoubleField, "m_proxyDoubleField"); this->addField(&m_proxyDoubleField, "m_proxyDoubleField");
m_proxyDoubleField.registerSetMethod(this, &DemoPdmObject::setDoubleMember); m_proxyDoubleField.registerSetMethod(this, &DemoPdmObject::setDoubleMember);
m_proxyDoubleField.registerGetMethod(this, &DemoPdmObject::doubleMember); m_proxyDoubleField.registerGetMethod(this, &DemoPdmObject::doubleMember);
@ -34,105 +32,111 @@ public:
m_proxyStringField.registerGetMethod(this, &DemoPdmObject::stringMember); m_proxyStringField.registerGetMethod(this, &DemoPdmObject::stringMember);
this->addField(&m_memberDoubleField, "m_memberDoubleField"); this->addField(&m_memberDoubleField, "m_memberDoubleField");
this->addField(&m_memberIntField, "m_memberIntField"); this->addField(&m_memberIntField, "m_memberIntField");
this->addField(&m_memberStringField, "m_memberStringField"); this->addField(&m_memberStringField, "m_memberStringField");
// Default values
// Default values
m_doubleMember = 2.1; m_doubleMember = 2.1;
m_intMember = 7; m_intMember = 7;
m_stringMember = "abba"; m_stringMember = "abba";
m_memberDoubleField = 0.0; m_memberDoubleField = 0.0;
m_memberIntField = 0; m_memberIntField = 0;
m_memberStringField = ""; m_memberStringField = "";
} }
~DemoPdmObject() ~DemoPdmObject() {}
{
}
// Fields // Fields
caf::PdmProxyValueField<double> m_proxyDoubleField; caf::PdmProxyValueField<double> m_proxyDoubleField;
caf::PdmProxyValueField<int> m_proxyIntField; caf::PdmProxyValueField<int> m_proxyIntField;
caf::PdmProxyValueField<QString> m_proxyStringField; caf::PdmProxyValueField<QString> m_proxyStringField;
caf::PdmDataValueField<double> m_memberDoubleField; caf::PdmDataValueField<double> m_memberDoubleField;
caf::PdmDataValueField<int> m_memberIntField; caf::PdmDataValueField<int> m_memberIntField;
caf::PdmDataValueField<QString> m_memberStringField; caf::PdmDataValueField<QString> m_memberStringField;
// Internal class members accessed by proxy fields // Internal class members accessed by proxy fields
double doubleMember() const { std::cout << "doubleMember" << std::endl; return m_doubleMember; } double doubleMember() const
void setDoubleMember(const double& d) { m_doubleMember = d; std::cout << "setDoubleMember" << std::endl; } {
std::cout << "doubleMember" << std::endl;
int intMember() const { return m_intMember; } return m_doubleMember;
void setIntMember(const int& val) { m_intMember = val; } }
void setDoubleMember(const double& d)
{
m_doubleMember = d;
std::cout << "setDoubleMember" << std::endl;
}
QString stringMember() const { return m_stringMember; } int intMember() const
void setStringMember(const QString& val) { m_stringMember = val; } {
return m_intMember;
}
void setIntMember(const int& val)
{
m_intMember = val;
}
private: QString stringMember() const
{
return m_stringMember;
}
void setStringMember(const QString& val)
{
m_stringMember = val;
}
private:
double m_doubleMember; double m_doubleMember;
int m_intMember; int m_intMember;
QString m_stringMember; QString m_stringMember;
}; };
class InheritedDemoObj : public DemoPdmObject class InheritedDemoObj : public DemoPdmObject
{ {
public: public:
InheritedDemoObj() InheritedDemoObj()
{ {
this->addField(&m_texts, "Texts"); this->addField(&m_texts, "Texts");
this->addField(&m_childArrayField, "DemoPdmObjectects"); this->addField(&m_childArrayField, "DemoPdmObjectects");
this->addField(&m_ptrField, "m_ptrField"); this->addField(&m_ptrField, "m_ptrField");
this->addField(&m_singleFilePath, "m_singleFilePath"); this->addField(&m_singleFilePath, "m_singleFilePath");
this->addField(&m_multipleFilePath, "m_multipleFilePath"); this->addField(&m_multipleFilePath, "m_multipleFilePath");
} }
caf::PdmDataValueField<QString > m_texts; caf::PdmDataValueField<QString> m_texts;
caf::PdmChildArrayField<DemoPdmObject*> m_childArrayField; caf::PdmChildArrayField<DemoPdmObject*> m_childArrayField;
caf::PdmPtrField<InheritedDemoObj*> m_ptrField; caf::PdmPtrField<InheritedDemoObj*> m_ptrField;
caf::PdmDataValueField<caf::FilePath> m_singleFilePath; caf::PdmDataValueField<caf::FilePath> m_singleFilePath;
caf::PdmDataValueField<std::vector<caf::FilePath>> m_multipleFilePath; caf::PdmDataValueField<std::vector<caf::FilePath>> m_multipleFilePath;
}; };
TEST(BaseTest, Delete) TEST(BaseTest, Delete)
{ {
DemoPdmObject* s2 = new DemoPdmObject; DemoPdmObject* s2 = new DemoPdmObject;
delete s2; delete s2;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// TestPdmDataValueField /// TestPdmDataValueField
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
TEST(BaseTest, TestPdmDataValueField) TEST(BaseTest, TestPdmDataValueField)
{ {
DemoPdmObject* a = new DemoPdmObject; DemoPdmObject* a = new DemoPdmObject;
ASSERT_DOUBLE_EQ(0.0, a->m_memberDoubleField.value());
a->m_memberDoubleField.setValue(1.2);
ASSERT_DOUBLE_EQ(1.2, a->m_memberDoubleField.value());
ASSERT_DOUBLE_EQ(0.0, a->m_memberDoubleField.value()); ASSERT_EQ(0, a->m_memberIntField.value());
a->m_memberDoubleField.setValue(1.2); a->m_memberIntField.setValue(11);
ASSERT_DOUBLE_EQ(1.2, a->m_memberDoubleField.value()); ASSERT_EQ(11, a->m_memberIntField.value());
ASSERT_EQ(0, a->m_memberIntField.value());
a->m_memberIntField.setValue(11);
ASSERT_EQ(11, a->m_memberIntField.value());
ASSERT_TRUE(a->m_memberStringField.value().isEmpty());
a->m_memberStringField.setValue("123");
ASSERT_TRUE(a->m_memberStringField.value() == "123");
ASSERT_TRUE(a->m_memberStringField.value().isEmpty());
a->m_memberStringField.setValue("123");
ASSERT_TRUE(a->m_memberStringField.value() == "123");
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -153,66 +157,63 @@ TEST(BaseTest, TestPdmProxyValueField)
ASSERT_TRUE(a->m_proxyStringField.value() == "abba"); ASSERT_TRUE(a->m_proxyStringField.value() == "abba");
a->m_proxyStringField.setValue("123"); a->m_proxyStringField.setValue("123");
ASSERT_TRUE(a->m_proxyStringField.value() == "123"); ASSERT_TRUE(a->m_proxyStringField.value() == "123");
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
TEST(BaseTest, TestPdmValueFieldInterface) TEST(BaseTest, TestPdmValueFieldInterface)
{ {
DemoPdmObject* a = new DemoPdmObject; DemoPdmObject* a = new DemoPdmObject;
{ {
caf::PdmValueField* valField = dynamic_cast<caf::PdmValueField*>(a->findField("m_proxyDoubleField")); caf::PdmValueField* valField = dynamic_cast<caf::PdmValueField*>(a->findField("m_proxyDoubleField"));
QVariant newVal = 3.4; QVariant newVal = 3.4;
valField->setFromQVariant(newVal); valField->setFromQVariant(newVal);
QVariant var = valField->toQVariant(); QVariant var = valField->toQVariant();
ASSERT_TRUE(newVal == var); ASSERT_TRUE(newVal == var);
} }
{ {
caf::PdmValueField* valField = dynamic_cast<caf::PdmValueField*>(a->findField("m_proxyIntField")); caf::PdmValueField* valField = dynamic_cast<caf::PdmValueField*>(a->findField("m_proxyIntField"));
QVariant newVal = 3; QVariant newVal = 3;
valField->setFromQVariant(newVal); valField->setFromQVariant(newVal);
QVariant var = valField->toQVariant(); QVariant var = valField->toQVariant();
ASSERT_TRUE(newVal == var); ASSERT_TRUE(newVal == var);
} }
{ {
caf::PdmValueField* valField = dynamic_cast<caf::PdmValueField*>(a->findField("m_proxyStringField")); caf::PdmValueField* valField = dynamic_cast<caf::PdmValueField*>(a->findField("m_proxyStringField"));
QVariant newVal = "test"; QVariant newVal = "test";
valField->setFromQVariant(newVal); valField->setFromQVariant(newVal);
QVariant var = valField->toQVariant(); QVariant var = valField->toQVariant();
ASSERT_TRUE(newVal == var); ASSERT_TRUE(newVal == var);
} }
{ {
caf::PdmValueField* valField = dynamic_cast<caf::PdmValueField*>(a->findField("m_memberDoubleField")); caf::PdmValueField* valField = dynamic_cast<caf::PdmValueField*>(a->findField("m_memberDoubleField"));
QVariant newVal = 3.4; QVariant newVal = 3.4;
valField->setFromQVariant(newVal); valField->setFromQVariant(newVal);
QVariant var = valField->toQVariant(); QVariant var = valField->toQVariant();
ASSERT_TRUE(newVal == var); ASSERT_TRUE(newVal == var);
} }
{ {
caf::PdmValueField* valField = dynamic_cast<caf::PdmValueField*>(a->findField("m_memberIntField")); caf::PdmValueField* valField = dynamic_cast<caf::PdmValueField*>(a->findField("m_memberIntField"));
QVariant newVal = 3; QVariant newVal = 3;
valField->setFromQVariant(newVal); valField->setFromQVariant(newVal);
QVariant var = valField->toQVariant(); QVariant var = valField->toQVariant();
ASSERT_TRUE(newVal == var); ASSERT_TRUE(newVal == var);
} }
{
caf::PdmValueField* valField = dynamic_cast<caf::PdmValueField*>(a->findField("m_memberStringField"));
QVariant newVal = "test";
valField->setFromQVariant(newVal);
QVariant var = valField->toQVariant();
ASSERT_TRUE(newVal == var);
}
{
caf::PdmValueField* valField = dynamic_cast<caf::PdmValueField*>(a->findField("m_memberStringField"));
QVariant newVal = "test";
valField->setFromQVariant(newVal);
QVariant var = valField->toQVariant();
ASSERT_TRUE(newVal == var);
}
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Test of PdmDataValueField operations /// Test of PdmDataValueField operations
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -221,19 +222,20 @@ TEST(BaseTest, NormalPdmField)
class A : public caf::PdmObjectHandle class A : public caf::PdmObjectHandle
{ {
public: public:
explicit A(const std::vector<double>& testValue) : field2(testValue), field3(field2) explicit A(const std::vector<double>& testValue)
: field2(testValue)
, field3(field2)
{ {
this->addField(&field1, "field1"); this->addField(&field1, "field1");
this->addField(&field2, "field2"); this->addField(&field2, "field2");
this->addField(&field3, "field3"); this->addField(&field3, "field3");
} }
caf::PdmDataValueField<std::vector<double> > field1; caf::PdmDataValueField<std::vector<double>> field1;
caf::PdmDataValueField<std::vector<double> > field2; caf::PdmDataValueField<std::vector<double>> field2;
caf::PdmDataValueField<std::vector<double> > field3; caf::PdmDataValueField<std::vector<double>> field3;
}; };
std::vector<double> testValue; std::vector<double> testValue;
testValue.push_back(1.1); testValue.push_back(1.1);
testValue.push_back(1.2); testValue.push_back(1.2);
@ -351,14 +353,12 @@ TEST(BaseTest, PdmChildArrayField)
EXPECT_TRUE(s3 == NULL); EXPECT_TRUE(s3 == NULL);
} }
TEST(BaseTest, PdmChildArrayParentField) TEST(BaseTest, PdmChildArrayParentField)
{ {
// Test of instanciating a class with forward declare of object used in PdmChildArrayField and PdmChildField // Test of instanciating a class with forward declare of object used in PdmChildArrayField and PdmChildField
Parent* parentObj = new Parent; Parent* parentObj = new Parent;
delete parentObj; delete parentObj;
} }
#include "Child.h" #include "Child.h"
@ -371,7 +371,7 @@ TEST(BaseTest, PdmPointersFieldInsertVector)
Child* s2 = new Child; Child* s2 = new Child;
Child* s3 = new Child; Child* s3 = new Child;
std::vector<caf::PdmPointer<Child> > typedObjects; std::vector<caf::PdmPointer<Child>> typedObjects;
typedObjects.push_back(s1); typedObjects.push_back(s1);
typedObjects.push_back(s2); typedObjects.push_back(s2);
typedObjects.push_back(s3); typedObjects.push_back(s3);
@ -389,30 +389,29 @@ TEST(BaseTest, PdmPointersFieldInsertVector)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
TEST(BaseTest, PdmChildArrayFieldHandle) TEST(BaseTest, PdmChildArrayFieldHandle)
{ {
// virtual size_t size() const = 0; // virtual size_t size() const = 0;
// virtual bool empty() const = 0; // virtual bool empty() const = 0;
// virtual void clear() = 0; // virtual void clear() = 0;
// virtual PdmObject* createAppendObject(int indexAfter) = 0; // virtual PdmObject* createAppendObject(int indexAfter) = 0;
// virtual void erase(size_t index) = 0; // virtual void erase(size_t index) = 0;
// virtual void deleteAllChildObjects() = 0; // virtual void deleteAllChildObjects() = 0;
// //
// virtual PdmObject* at(size_t index) = 0; // virtual PdmObject* at(size_t index) = 0;
// //
// bool hasSameFieldCountForAllObjects(); // bool hasSameFieldCountForAllObjects();
DemoPdmObject* s0 = new DemoPdmObject; DemoPdmObject* s0 = new DemoPdmObject;
s0->m_memberDoubleField = 1000; s0->m_memberDoubleField = 1000;
DemoPdmObject* s1 = new DemoPdmObject; DemoPdmObject* s1 = new DemoPdmObject;
s1->m_memberDoubleField = 1000; s1->m_memberDoubleField = 1000;
DemoPdmObject* s2 = new DemoPdmObject; DemoPdmObject* s2 = new DemoPdmObject;
s2->m_memberDoubleField = 2000; s2->m_memberDoubleField = 2000;
DemoPdmObject* s3 = new DemoPdmObject; DemoPdmObject* s3 = new DemoPdmObject;
s3->m_memberDoubleField = 3000; s3->m_memberDoubleField = 3000;
InheritedDemoObj* ihd1 = new InheritedDemoObj; InheritedDemoObj* ihd1 = new InheritedDemoObj;
caf::PdmChildArrayFieldHandle* listField = &(ihd1->m_childArrayField); caf::PdmChildArrayFieldHandle* listField = &(ihd1->m_childArrayField);
EXPECT_EQ(0, listField->size()); EXPECT_EQ(0, listField->size());
@ -441,7 +440,6 @@ TEST(BaseTest, PdmChildArrayFieldHandle)
EXPECT_EQ(0, listField->size()); EXPECT_EQ(0, listField->size());
EXPECT_TRUE(listField->hasSameFieldCountForAllObjects()); EXPECT_TRUE(listField->hasSameFieldCountForAllObjects());
EXPECT_TRUE(listField->empty()); EXPECT_TRUE(listField->empty());
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Test of PdmChildField /// Test of PdmChildField
@ -453,8 +451,8 @@ TEST(BaseTest, PdmChildField)
{ {
public: public:
explicit A(Child* a) explicit A(Child* a)
: field2(a), : field2(a)
b(0) , b(0)
{ {
this->addField(&field2, "field2"); this->addField(&field2, "field2");
} }
@ -465,7 +463,7 @@ TEST(BaseTest, PdmChildField)
} }
caf::PdmChildField<Child*> field2; caf::PdmChildField<Child*> field2;
int b; int b;
}; };
{ {
@ -480,7 +478,7 @@ TEST(BaseTest, PdmChildField)
EXPECT_EQ(static_cast<Child*>(nullptr), a.field2); EXPECT_EQ(static_cast<Child*>(nullptr), a.field2);
} }
{ {
A a(NULL); A a(NULL);
Child* c2 = new Child; Child* c2 = new Child;
// Assign // Assign
a.field2 = c2; a.field2 = c2;
@ -490,7 +488,6 @@ TEST(BaseTest, PdmChildField)
EXPECT_EQ(c2, a.field2.value()); EXPECT_EQ(c2, a.field2.value());
EXPECT_TRUE(c2 == a.field2); EXPECT_TRUE(c2 == a.field2);
std::vector<caf::PdmObjectHandle*> objects; std::vector<caf::PdmObjectHandle*> objects;
a.field2.childObjects(&objects); a.field2.childObjects(&objects);
EXPECT_EQ((size_t)1, objects.size()); EXPECT_EQ((size_t)1, objects.size());
@ -498,7 +495,6 @@ TEST(BaseTest, PdmChildField)
} }
} }
TEST(BaseTest, PdmPtrField) TEST(BaseTest, PdmPtrField)
{ {
InheritedDemoObj* ihd1 = new InheritedDemoObj; InheritedDemoObj* ihd1 = new InheritedDemoObj;
@ -508,18 +504,18 @@ TEST(BaseTest, PdmPtrField)
EXPECT_EQ(static_cast<InheritedDemoObj*>(nullptr), ihd1->m_ptrField); EXPECT_EQ(static_cast<InheritedDemoObj*>(nullptr), ihd1->m_ptrField);
// Assignment // Assignment
ihd1->m_ptrField = ihd1; ihd1->m_ptrField = ihd1;
InheritedDemoObj* accessedIhd = ihd1->m_ptrField; InheritedDemoObj* accessedIhd = ihd1->m_ptrField;
EXPECT_EQ(ihd1, accessedIhd); EXPECT_EQ(ihd1, accessedIhd);
ihd1->m_ptrField = caf::PdmPointer<InheritedDemoObj>(ihd2); ihd1->m_ptrField = caf::PdmPointer<InheritedDemoObj>(ihd2);
accessedIhd = ihd1->m_ptrField; accessedIhd = ihd1->m_ptrField;
EXPECT_EQ(ihd2, accessedIhd); EXPECT_EQ(ihd2, accessedIhd);
// Access // Access
accessedIhd = ihd1->m_ptrField; // Conversion accessedIhd = ihd1->m_ptrField; // Conversion
EXPECT_EQ(ihd2, accessedIhd); EXPECT_EQ(ihd2, accessedIhd);
accessedIhd = ihd1->m_ptrField.value(); accessedIhd = ihd1->m_ptrField.value();
EXPECT_EQ(ihd2, accessedIhd); EXPECT_EQ(ihd2, accessedIhd);
caf::PdmPointer<InheritedDemoObj> accessedPdmPtr; caf::PdmPointer<InheritedDemoObj> accessedPdmPtr;
@ -532,43 +528,52 @@ TEST(BaseTest, PdmPtrField)
// Operator == // Operator ==
EXPECT_TRUE(ihd1->m_ptrField == ihd2); EXPECT_TRUE(ihd1->m_ptrField == ihd2);
EXPECT_FALSE(ihd1->m_ptrField == ihd1); EXPECT_FALSE(ihd1->m_ptrField == ihd1);
EXPECT_TRUE(ihd1->m_ptrField == caf::PdmPointer<InheritedDemoObj>(ihd2)); EXPECT_TRUE(ihd1->m_ptrField == caf::PdmPointer<InheritedDemoObj>(ihd2));
// Generic access // Generic access
std::vector<caf::PdmObjectHandle*> objects; {
ihd1->m_ptrField.ptrReferencedObjects(&objects); std::vector<caf::PdmObjectHandle*> objects;
EXPECT_EQ(1, objects.size()); ihd1->m_ptrField.ptrReferencedObjects(&objects);
EXPECT_EQ(ihd2, objects[0]); EXPECT_EQ(1, objects.size());
EXPECT_EQ(ihd2, objects[0]);
}
// Operator -> // Operator ->
ihd1->m_ptrField->m_texts = "Hei PtrField"; ihd1->m_ptrField->m_texts = "Hei PtrField";
EXPECT_TRUE(ihd1->m_ptrField->m_texts == "Hei PtrField"); EXPECT_TRUE(ihd1->m_ptrField->m_texts == "Hei PtrField");
// Refrencing system // Referencing system
std::vector<caf::PdmFieldHandle*> ptrFields; {
ihd2->referringPtrFields(ptrFields); std::vector<caf::PdmFieldHandle*> ptrFields;
EXPECT_EQ(1, ptrFields.size()); ihd2->referringPtrFields(ptrFields);
EXPECT_EQ(&(ihd1->m_ptrField), ptrFields[0]); EXPECT_EQ(1, ptrFields.size());
EXPECT_EQ(&(ihd1->m_ptrField), ptrFields[0]);
}
objects.clear(); {
ihd2->objectsWithReferringPtrFields(objects); std::vector<caf::PdmObjectHandle*> objects;
EXPECT_EQ(1, objects.size()); ihd2->objectsWithReferringPtrFields(objects);
EXPECT_EQ(ihd1, objects[0]); EXPECT_EQ(1, objects.size());
EXPECT_EQ(ihd1, objects[0]);
}
{
std::vector<InheritedDemoObj*> reffingDemoObjects;
ihd2->objectsWithReferringPtrFieldsOfType(reffingDemoObjects);
EXPECT_EQ(1, reffingDemoObjects.size());
}
delete ihd1; delete ihd1;
delete ihd2; delete ihd2;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Tests the features of PdmPointer /// Tests the features of PdmPointer
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
TEST(BaseTest, PdmPointer) TEST(BaseTest, PdmPointer)
{ {
InheritedDemoObj * d = new InheritedDemoObj; InheritedDemoObj* d = new InheritedDemoObj;
{ {
caf::PdmPointer<InheritedDemoObj> p; caf::PdmPointer<InheritedDemoObj> p;
@ -594,12 +599,10 @@ TEST(BaseTest, PdmPointer)
caf::PdmPointer<DemoPdmObject> p3(new DemoPdmObject()); caf::PdmPointer<DemoPdmObject> p3(new DemoPdmObject());
delete p3; delete p3;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
TEST(BaseTest, PdmFilePath) TEST(BaseTest, PdmFilePath)
{ {
@ -615,7 +618,7 @@ TEST(BaseTest, PdmFilePath)
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
TEST(BaseTest, MultiplePdmFilePath) TEST(BaseTest, MultiplePdmFilePath)
{ {
@ -625,7 +628,7 @@ TEST(BaseTest, MultiplePdmFilePath)
d->m_multipleFilePath.v().push_back(newVal); d->m_multipleFilePath.v().push_back(newVal);
d->m_multipleFilePath.v().push_back(newVal); d->m_multipleFilePath.v().push_back(newVal);
QVariant var = d->m_multipleFilePath.toQVariant(); QVariant var = d->m_multipleFilePath.toQVariant();
QStringList str = var.toStringList(); QStringList str = var.toStringList();
EXPECT_EQ(2, str.size()); EXPECT_EQ(2, str.size());

22
Fwk/AppFwk/cafProjectDataModel/cafPdmCore/cafPdmObjectHandle.h
View File

@ -53,6 +53,9 @@ public:
void referringPtrFields(std::vector<PdmFieldHandle*>& fieldsReferringToMe) const; void referringPtrFields(std::vector<PdmFieldHandle*>& fieldsReferringToMe) const;
/// Convenience method to get the objects pointing to this field /// Convenience method to get the objects pointing to this field
void objectsWithReferringPtrFields(std::vector<PdmObjectHandle*>& objects) const; void objectsWithReferringPtrFields(std::vector<PdmObjectHandle*>& objects) const;
/// Convenience method to get the objects of specified type pointing to this field
template <typename T>
void objectsWithReferringPtrFieldsOfType(std::vector<T*>& objectsOfType) const;
// Detach object from all referring fields // Detach object from all referring fields
void prepareForDelete(); void prepareForDelete();
@ -202,5 +205,24 @@ void PdmObjectHandle::descendantsIncludingThisOfType(std::vector<T*>& descendant
} }
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
template <typename T>
void PdmObjectHandle::objectsWithReferringPtrFieldsOfType(std::vector<T*>& objectsOfType) const
{
std::vector<PdmObjectHandle*> objectsReferencingThis;
this->objectsWithReferringPtrFields(objectsReferencingThis);
for (auto object : objectsReferencingThis)
{
if (dynamic_cast<T*>(object))
{
objectsOfType.push_back(dynamic_cast<T*>(object));
}
}
}
} // End of namespace caf } // End of namespace caf