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

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

@ -14,11 +14,9 @@
#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");
@ -37,8 +35,6 @@ public:
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;
@ -47,12 +43,9 @@ public:
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;
@ -63,16 +56,35 @@ public:
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;
return m_doubleMember;
}
void setDoubleMember(const double& d)
{
m_doubleMember = d;
std::cout << "setDoubleMember" << std::endl;
}
int intMember() const { return m_intMember; } int intMember() const
void setIntMember(const int& val) { m_intMember = val; } {
return m_intMember;
}
void setIntMember(const int& val)
{
m_intMember = val;
}
QString stringMember() const { return m_stringMember; } QString stringMember() const
void setStringMember(const QString& val) { m_stringMember = val; } {
return m_stringMember;
}
void setStringMember(const QString& val)
{
m_stringMember = val;
}
private: private:
double m_doubleMember; double m_doubleMember;
@ -80,11 +92,9 @@ private:
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");
@ -93,7 +103,6 @@ public:
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;
@ -104,14 +113,12 @@ public:
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
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -119,7 +126,6 @@ TEST(BaseTest, TestPdmDataValueField)
{ {
DemoPdmObject* a = new DemoPdmObject; DemoPdmObject* a = new DemoPdmObject;
ASSERT_DOUBLE_EQ(0.0, a->m_memberDoubleField.value()); ASSERT_DOUBLE_EQ(0.0, a->m_memberDoubleField.value());
a->m_memberDoubleField.setValue(1.2); a->m_memberDoubleField.setValue(1.2);
ASSERT_DOUBLE_EQ(1.2, a->m_memberDoubleField.value()); ASSERT_DOUBLE_EQ(1.2, a->m_memberDoubleField.value());
@ -131,8 +137,6 @@ TEST(BaseTest, TestPdmDataValueField)
ASSERT_TRUE(a->m_memberStringField.value().isEmpty()); ASSERT_TRUE(a->m_memberStringField.value().isEmpty());
a->m_memberStringField.setValue("123"); a->m_memberStringField.setValue("123");
ASSERT_TRUE(a->m_memberStringField.value() == "123"); ASSERT_TRUE(a->m_memberStringField.value() == "123");
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -153,7 +157,6 @@ 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");
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -209,10 +212,8 @@ TEST(BaseTest, TestPdmValueFieldInterface)
QVariant var = valField->toQVariant(); QVariant var = valField->toQVariant();
ASSERT_TRUE(newVal == var); ASSERT_TRUE(newVal == var);
} }
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Test of PdmDataValueField operations /// Test of PdmDataValueField operations
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -221,7 +222,9 @@ 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");
@ -233,7 +236,6 @@ TEST(BaseTest, NormalPdmField)
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"
@ -389,7 +389,6 @@ 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;
@ -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");
} }
@ -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;
@ -536,33 +532,42 @@ TEST(BaseTest, PdmPtrField)
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; std::vector<caf::PdmObjectHandle*> objects;
ihd1->m_ptrField.ptrReferencedObjects(&objects); ihd1->m_ptrField.ptrReferencedObjects(&objects);
EXPECT_EQ(1, objects.size()); EXPECT_EQ(1, objects.size());
EXPECT_EQ(ihd2, objects[0]); 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; std::vector<caf::PdmFieldHandle*> ptrFields;
ihd2->referringPtrFields(ptrFields); ihd2->referringPtrFields(ptrFields);
EXPECT_EQ(1, ptrFields.size()); EXPECT_EQ(1, ptrFields.size());
EXPECT_EQ(&(ihd1->m_ptrField), ptrFields[0]); EXPECT_EQ(&(ihd1->m_ptrField), ptrFields[0]);
}
objects.clear(); {
std::vector<caf::PdmObjectHandle*> objects;
ihd2->objectsWithReferringPtrFields(objects); ihd2->objectsWithReferringPtrFields(objects);
EXPECT_EQ(1, objects.size()); EXPECT_EQ(1, objects.size());
EXPECT_EQ(ihd1, objects[0]); 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
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -594,10 +599,8 @@ TEST(BaseTest, PdmPointer)
caf::PdmPointer<DemoPdmObject> p3(new DemoPdmObject()); caf::PdmPointer<DemoPdmObject> p3(new DemoPdmObject());
delete p3; delete p3;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

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