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

Moved Xml related functions from PdmDocument to XmlObjectHandle

Browse Source 
Moved and renamed initAfterReadRecursively, setupBeforeSaveRecursively
and resolveReferencesRecursively to XmlObjectHandle. Updated unit tests.
Removed resolveReferences() from PdmPtrField.
This commit is contained in:
Magne Sjaastad 2015-08-27 11:43:27 +02:00
parent 4f5f50fb4f
commit 492bf96598
12 changed files with 165 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Fwk/AppFwk/cafProjectDataModel/cafPdmCore/cafPdmFieldHandle.h
View File

@ -34,7 +34,6 @@ public:
// Ptr referenced objects
bool hasPtrReferencedObjects();
virtual void ptrReferencedObjects(std::vector<PdmObjectHandle*>*) { }
virtual void resolveReferences() { }
// Capabilities
void addCapability(PdmFieldCapability* capability, bool takeOwnership) { m_capabilities.push_back(std::make_pair(capability, takeOwnership)); }

2
Fwk/AppFwk/cafProjectDataModel/cafPdmCore/cafPdmPtrField.h
View File

@ -68,7 +68,7 @@ public:
// Ptr referenced objects
virtual void ptrReferencedObjects(std::vector<PdmObjectHandle*>* objectsToFill);
virtual void resolveReferences();
private:
PDM_DISABLE_COPY_AND_ASSIGN(PdmPtrField);

14
Fwk/AppFwk/cafProjectDataModel/cafPdmCore/cafPdmPtrField.inl
View File

@ -100,19 +100,5 @@ void PdmPtrField<DataType*>::ptrReferencedObjects(std::vector<PdmObjectHandle*>*
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
template<typename DataType >
void PdmPtrField<DataType*>::resolveReferences()
{
if (m_isResolved) return;
if (m_referenceString.isEmpty()) return;
PdmObjectHandle* objHandle = PdmReferenceHelper::objectFromFieldReference(this, m_referenceString);
this->setRawPtr(objHandle);
m_isResolved = true;
}
} // End of namespace caf

124
Fwk/AppFwk/cafProjectDataModel/cafPdmDocument.cpp
View File

@ -91,8 +91,8 @@ void PdmDocument::readFile(QIODevice* xmlFile)
// Ask all objects to initialize and set up internal datastructure and pointers
// after everything is read from file
PdmDocument::resolveReferencesTraversal(this);
PdmDocument::initAfterReadTraversal(this);
resolveReferencesRecursively();
initAfterReadRecursively();
}
//--------------------------------------------------------------------------------------------------
@ -113,7 +113,7 @@ void PdmDocument::writeFile()
void PdmDocument::writeFile(QIODevice* xmlFile)
{
// Ask all objects to make them ready to write themselves to file
PdmDocument::setupBeforeSaveTraversal(this);
setupBeforeSaveRecursively();
QXmlStreamWriter xmlStream(xmlFile);
xmlStream.setAutoFormatting(true);
@ -129,123 +129,5 @@ void PdmDocument::writeFile(QIODevice* xmlFile)
}
void PdmDocument::setupBeforeSaveTraversal(PdmObjectHandle * object)
{
if (object == NULL) return;
std::vector<PdmFieldHandle*> fields;
object->fields(fields);
std::vector<PdmObjectHandle*> children;
size_t fIdx;
for (fIdx = 0; fIdx < fields.size(); ++fIdx)
{
if (fields[fIdx]) fields[fIdx]->childObjects(&children);
}
size_t cIdx;
for (cIdx = 0; cIdx < children.size(); ++cIdx)
{
PdmDocument::setupBeforeSaveTraversal(children[cIdx]);
}
PdmXmlObjectHandle* xmlObject = xmlObj(object);
if (xmlObject)
{
xmlObject->setupBeforeSave();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void PdmDocument::initAfterReadTraversal(PdmObjectHandle* object)
{
if (object == NULL) return;
std::vector<PdmFieldHandle*> fields;
object->fields(fields);
std::vector<PdmObjectHandle*> children;
size_t fIdx;
for (fIdx = 0; fIdx < fields.size(); ++fIdx)
{
if (fields[fIdx]) fields[fIdx]->childObjects(&children);
}
size_t cIdx;
for (cIdx = 0; cIdx < children.size(); ++cIdx)
{
PdmDocument::initAfterReadTraversal(children[cIdx]);
}
PdmXmlObjectHandle* xmlObject = xmlObj(object);
if (xmlObject)
{
xmlObject->initAfterRead();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void PdmDocument::updateUiIconStateRecursively(PdmObjectHandle* object)
{
if (object == NULL) return;
std::vector<PdmFieldHandle*> fields;
object->fields(fields);
std::vector<PdmObjectHandle*> children;
size_t fIdx;
for (fIdx = 0; fIdx < fields.size(); ++fIdx)
{
if (fields[fIdx]) fields[fIdx]->childObjects(&children);
}
size_t cIdx;
for (cIdx = 0; cIdx < children.size(); ++cIdx)
{
PdmDocument::updateUiIconStateRecursively(children[cIdx]);
}
PdmUiObjectHandle* uiObjectHandle = uiObj(object);
if (uiObjectHandle)
{
uiObjectHandle->updateUiIconFromToggleField();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void PdmDocument::resolveReferencesTraversal(PdmObjectHandle* object)
{
if (object == NULL) return;
std::vector<PdmFieldHandle*> fields;
object->fields(fields);
std::vector<PdmObjectHandle*> children;
size_t fIdx;
for (fIdx = 0; fIdx < fields.size(); ++fIdx)
{
PdmFieldHandle* field = fields[fIdx];
if (field)
{
field->childObjects(&children);
field->resolveReferences();
}
}
size_t cIdx;
for (cIdx = 0; cIdx < children.size(); ++cIdx)
{
PdmDocument::resolveReferencesTraversal(children[cIdx]);
}
}
} //End of namespace caf

5
Fwk/AppFwk/cafProjectDataModel/cafPdmDocument.h
View File

@ -62,11 +62,6 @@ class PdmDocument: public PdmObject
void writeFile(QIODevice* device);
static void updateUiIconStateRecursively(PdmObjectHandle* root);
static void initAfterReadTraversal(PdmObjectHandle* root);
static void resolveReferencesTraversal(PdmObjectHandle* root);
private:
static void setupBeforeSaveTraversal(PdmObjectHandle * root);
};

14
Fwk/AppFwk/cafProjectDataModel/cafPdmXml/cafInternalPdmXmlFieldCapability.h
View File

@ -28,14 +28,26 @@ class PdmFieldXmlCap< PdmPtrField<DataType*> > : public PdmXmlFieldHandle
{
typedef PdmPtrField<DataType*> FieldType;
public:
PdmFieldXmlCap(FieldType* field, bool giveOwnership) : PdmXmlFieldHandle(field, giveOwnership) { m_field = field; m_childClassKeyword = DataType::classKeywordStatic(); }
PdmFieldXmlCap(FieldType* field, bool giveOwnership) : PdmXmlFieldHandle(field, giveOwnership)
{
m_field = field;
m_childClassKeyword = DataType::classKeywordStatic();
m_isResolved = false;
m_referenceString = "";
}
// Xml Serializing
public:
virtual void readFieldData(QXmlStreamReader& xmlStream, PdmObjectFactory* objectFactory);
virtual void writeFieldData(QXmlStreamWriter& xmlStream);
virtual void resolveReferences();
private:
FieldType* m_field;
// Resolving
QString m_referenceString;
bool m_isResolved;
};

21
Fwk/AppFwk/cafProjectDataModel/cafPdmXml/cafInternalPdmXmlFieldCapability.inl
View File

@ -67,8 +67,9 @@ template<typename FieldType >
//
// and then we need a traversal of the object hierarchy to resolve all references before initAfterRead.
m_field->m_isResolved = false;
m_field->m_referenceString = dataString;
m_isResolved = false;
m_referenceString = dataString;
m_field->setRawPtr(NULL);
}
//--------------------------------------------------------------------------------------------------
@ -87,6 +88,22 @@ template<typename FieldType >
xmlStream.writeCharacters(dataString);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
template < typename DataType>
void caf::PdmFieldXmlCap< PdmPtrField<DataType*> >::resolveReferences()
{
if (m_isResolved) return;
if (m_referenceString.isEmpty()) return;
PdmObjectHandle* objHandle = PdmReferenceHelper::objectFromFieldReference(this->fieldHandle(), m_referenceString);
m_field->setRawPtr(objHandle);
m_isResolved = true;
}
//==================================================================================================
/// XML Implementation for PdmChildField<>
//==================================================================================================

31
Fwk/AppFwk/cafProjectDataModel/cafPdmXml/cafPdmXmlFieldHandle.h
View File

@ -26,29 +26,28 @@ public:
virtual ~PdmXmlFieldHandle() { }
PdmFieldHandle* fieldHandle() { return m_owner; }
private:
PdmFieldHandle* m_owner;
/// Xml Serialization
public:
virtual void readFieldData(QXmlStreamReader& xmlStream, PdmObjectFactory* objectFactory) = 0;
virtual void writeFieldData(QXmlStreamWriter& xmlStream) = 0;
bool isIOReadable() { return m_isIOReadable; }
bool isIOWritable() { return m_isIOWritable; }
void setIOWritable(bool isWritable) { m_isIOWritable = isWritable; }
void setIOReadable(bool isReadable) { m_isIOReadable = isReadable; }
bool isIOReadable() { return m_isIOReadable; }
bool isIOWritable() { return m_isIOWritable; }
void setIOWritable(bool isWritable) { m_isIOWritable = isWritable; }
void setIOReadable(bool isReadable) { m_isIOReadable = isReadable; }
QString childClassKeyword();
virtual void readFieldData(QXmlStreamReader& xmlStream, PdmObjectFactory* objectFactory) = 0;
virtual void writeFieldData(QXmlStreamWriter& xmlStream) = 0;
virtual void resolveReferences() { };
QString childClassKeyword();
protected:
bool assertValid() const;
QString m_childClassKeyword; ///< Must be set in constructor of derived XmlFieldHandle
bool assertValid() const;
QString m_childClassKeyword; ///< Must be set in constructor of derived XmlFieldHandle
private:
bool m_isIOReadable;
bool m_isIOWritable;
bool m_isIOReadable;
bool m_isIOWritable;
PdmFieldHandle* m_owner;
};
} // End of namespace caf

90
Fwk/AppFwk/cafProjectDataModel/cafPdmXml/cafPdmXmlObjectHandle.cpp
View File

@ -228,6 +228,96 @@ bool PdmXmlObjectHandle::isValidXmlElementName(const QString& name)
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void PdmXmlObjectHandle::initAfterReadRecursively(PdmObjectHandle* object)
{
if (object == NULL) return;
std::vector<PdmFieldHandle*> fields;
object->fields(fields);
std::vector<PdmObjectHandle*> children;
size_t fIdx;
for (fIdx = 0; fIdx < fields.size(); ++fIdx)
{
if (fields[fIdx]) fields[fIdx]->childObjects(&children);
}
size_t cIdx;
for (cIdx = 0; cIdx < children.size(); ++cIdx)
{
initAfterReadRecursively(children[cIdx]);
}
PdmXmlObjectHandle* xmlObject = xmlObj(object);
if (xmlObject)
{
xmlObject->initAfterRead();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void PdmXmlObjectHandle::resolveReferencesRecursively(PdmObjectHandle* object)
{
if (object == NULL) return;
std::vector<PdmFieldHandle*> fields;
object->fields(fields);
std::vector<PdmObjectHandle*> children;
size_t fIdx;
for (fIdx = 0; fIdx < fields.size(); ++fIdx)
{
PdmFieldHandle* field = fields[fIdx];
if (field)
{
field->childObjects(&children);
field->xmlCapability()->resolveReferences();
}
}
size_t cIdx;
for (cIdx = 0; cIdx < children.size(); ++cIdx)
{
resolveReferencesRecursively(children[cIdx]);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void PdmXmlObjectHandle::setupBeforeSaveRecursively(PdmObjectHandle* object)
{
if (object == NULL) return;
std::vector<PdmFieldHandle*> fields;
object->fields(fields);
std::vector<PdmObjectHandle*> children;
size_t fIdx;
for (fIdx = 0; fIdx < fields.size(); ++fIdx)
{
if (fields[fIdx]) fields[fIdx]->childObjects(&children);
}
size_t cIdx;
for (cIdx = 0; cIdx < children.size(); ++cIdx)
{
setupBeforeSaveRecursively(children[cIdx]);
}
PdmXmlObjectHandle* xmlObject = xmlObj(object);
if (xmlObject)
{
xmlObject->setupBeforeSave();
}
}
//--------------------------------------------------------------------------------------------------
/// Implementation of xmlCapability() defined in cafPdmObjectHandle.h

11
Fwk/AppFwk/cafProjectDataModel/cafPdmXml/cafPdmXmlObjectHandle.h
View File

@ -45,6 +45,10 @@ public:
/// Check if a string is a valid Xml element name
static bool isValidXmlElementName(const QString& name);
void initAfterReadRecursively() { initAfterReadRecursively(this->m_owner); };
void setupBeforeSaveRecursively() { setupBeforeSaveRecursively(this->m_owner); };
void resolveReferencesRecursively() { resolveReferencesRecursively(this->m_owner); };
protected: // Virtual
/// Method gets called from PdmDocument after all objects are read.
/// Re-implement to set up internal pointers etc. in your data structure
@ -57,10 +61,13 @@ protected: // Virtual
// if user uses them on wrong type of objects
bool isInheritedFromPdmXmlSerializable() { return true; }
private:
void initAfterReadRecursively(PdmObjectHandle* object);
void setupBeforeSaveRecursively(PdmObjectHandle * object);
void resolveReferencesRecursively(PdmObjectHandle* object);
private:
friend class PdmObjectHandle ; // Only temporary for void PdmObject::addFieldNoDefault( ) accessing findField
friend class PdmDocument; // To access setupBeforeSave()
friend class PdmObjectGroup; // To access initAfterRead
PdmObjectHandle* m_owner;
};

2
Fwk/AppFwk/cafProjectDataModel/cafPdmXml/cafPdmXml_UnitTests/cafPdmAdvancedTemplateTest.cpp
View File

@ -194,7 +194,7 @@ TEST(AdvancedObjectTest, FieldWrite)
sibling->m_demoObjs.push_back(a);
a->readObjectFromXmlString(serializedString, caf::PdmDefaultObjectFactory::instance());
//caf::PdmDocument::resolveReferencesTraversal(a);
a->xmlCapability()->resolveReferencesRecursively();
ASSERT_TRUE(a->m_pointerToItem() == container->m_items[1]);
}

24
Fwk/AppFwk/cafTests/cafProjectDataModel_UnitTests/cafPdmBasicTest.cpp
View File

@ -44,6 +44,7 @@
#include "cafPdmDocument.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmObjectGroup.h"
#include "cafPdmPointer.h"
#include "cafPdmProxyValueField.h"
#include "cafPdmReferenceHelper.h"
@ -51,7 +52,6 @@
#include <QFile>
#include <memory>
#include "cafPdmObjectGroup.h"
/// Demo objects to show the usage of the Pdm system
@ -102,7 +102,7 @@ public:
caf::PdmField<double> m_dir;
caf::PdmField<double> m_up;
caf::PdmField<std::vector<double> > m_numbers;
caf::PdmProxyValueField<double> m_proxyDouble;
caf::PdmProxyValueField<double> m_proxyDouble;
void setDoubleMember(const double& d) { m_doubleMember = d; std::cout << "setDoubleMember" << std::endl; }
double doubleMember() const { std::cout << "doubleMember" << std::endl; return m_doubleMember; }
@ -176,7 +176,7 @@ public:
caf::PdmField<std::vector<QString> > m_texts;
caf::PdmField< caf::AppEnum<TestEnumType> > m_testEnumField;
caf::PdmChildArrayField<SimpleObj*> m_simpleObjectsField;
caf::PdmChildArrayField<SimpleObj*> m_simpleObjectsField;
};
CAF_PDM_SOURCE_INIT(InheritedDemoObj, "InheritedDemoObj");
@ -644,21 +644,27 @@ TEST(BaseTest, ReadWrite)
f3.close();
// Read the document containing errors
/*
caf::PdmDocument xmlErrorDoc;
MyPdmDocument xmlErrorDoc;
xmlErrorDoc.fileName = "PdmTestFilWithError.xml";
xmlErrorDoc.readFile();
caf::PdmObjectGroup pog;
for (size_t i = 0; i < xmlErrorDoc.objects.size(); i++)
{
pog.addObject(xmlErrorDoc.objects[i]);
}
// Check the pointersfield
std::vector<caf::PdmPointer<InheritedDemoObj> > ihDObjs;
xmlErrorDoc.objectsByType(&ihDObjs);
pog.objectsByType(&ihDObjs);
EXPECT_EQ(size_t(2), ihDObjs.size() );
ASSERT_EQ(size_t(3), ihDObjs[0]->m_simpleObjectsField.size());
// check single pointer field
std::vector<caf::PdmPointer<DemoPdmObject> > demoObjs;
xmlErrorDoc.objectsByType(&demoObjs);
pog.objectsByType(&demoObjs);
EXPECT_EQ(size_t(4), demoObjs.size() );
EXPECT_TRUE(demoObjs[0]->m_simpleObjPtrField == NULL );
@ -666,11 +672,9 @@ TEST(BaseTest, ReadWrite)
// check single pointer field
std::vector<caf::PdmPointer<SimpleObj> > simpleObjs;
xmlErrorDoc.objectsByType(&simpleObjs);
pog.objectsByType(&simpleObjs);
EXPECT_EQ(size_t(1), simpleObjs.size() );
EXPECT_EQ(size_t(0), simpleObjs[0]->m_numbers().size());
*/
}
}