OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-09 13:22:24 +03:00
Code Activity

Coding - Apply .clang-format formatting #286

Browse Source 
Update empty method guards to new style with regex (see PR).
Used clang-format 18.1.8.
New actions to validate code formatting is added.
Update .clang-format with disabling of include sorting.
  It is temporary changes, then include will be sorted.
Apply formatting for /src and /tools folder.
The files with .hxx,.cxx,.lxx,.h,.pxx,.hpp,*.cpp extensions.
This commit is contained in:
dpasukhi
2025-01-25 20:15:22 +00:00
parent dbba6f1289
commit a5a7b3185b
14005 changed files with 1273539 additions and 1195567 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/XmlTObjDrivers/XmlTObjDrivers.cxx
View File

@@ -28,58 +28,54 @@
#include <Plugin_Macro.hxx>
#include <TDocStd_Application.hxx>
static Standard_GUID XmlStorageDriver ("f78ff4a0-a779-11d5-aab4-0050044b1af1");
static Standard_GUID XmlStorageDriver("f78ff4a0-a779-11d5-aab4-0050044b1af1");
static Standard_GUID XmlRetrievalDriver("f78ff4a1-a779-11d5-aab4-0050044b1af1");
const Handle(Standard_Transient)& XmlTObjDrivers::Factory(const Standard_GUID& aGUID)
{
if(aGUID == XmlStorageDriver)
if (aGUID == XmlStorageDriver)
{
#ifdef OCCT_DEBUG
std::cout << "XmlTObjDrivers : Storage Plugin" << std::endl;
#endif
static Handle(Standard_Transient) model_sd
= new XmlTObjDrivers_DocumentStorageDriver
("Copyright: Open CASCADE 2004"); // default copyright
static Handle(Standard_Transient) model_sd =
new XmlTObjDrivers_DocumentStorageDriver("Copyright: Open CASCADE 2004"); // default copyright
return model_sd;
}
if(aGUID == XmlRetrievalDriver)
{
if (aGUID == XmlRetrievalDriver)
{
#ifdef OCCT_DEBUG
std::cout << "XmlTObjDrivers : Retrieval Plugin" << std::endl;
#endif
static Handle (Standard_Transient) model_rd
= new XmlTObjDrivers_DocumentRetrievalDriver;
static Handle(Standard_Transient) model_rd = new XmlTObjDrivers_DocumentRetrievalDriver;
return model_rd;
}
return XmlLDrivers::Factory (aGUID);
return XmlLDrivers::Factory(aGUID);
}
//=======================================================================
//function : DefineFormat
//purpose :
//=======================================================================
void XmlTObjDrivers::DefineFormat (const Handle(TDocStd_Application)& theApp)
//=================================================================================================
void XmlTObjDrivers::DefineFormat(const Handle(TDocStd_Application)& theApp)
{
theApp->DefineFormat ("TObjXml", "Xml TObj OCAF Document", "xml",
new XmlTObjDrivers_DocumentRetrievalDriver,
new XmlTObjDrivers_DocumentStorageDriver ("Copyright: Open Cascade, 2004"));
theApp->DefineFormat("TObjXml",
"Xml TObj OCAF Document",
"xml",
new XmlTObjDrivers_DocumentRetrievalDriver,
new XmlTObjDrivers_DocumentStorageDriver("Copyright: Open Cascade, 2004"));
}
//=======================================================================
//function : AddDrivers
//purpose :
//=======================================================================
void XmlTObjDrivers::AddDrivers (const Handle(XmlMDF_ADriverTable)& aDriverTable,
const Handle(Message_Messenger)& anMsgDrv)
//=================================================================================================
void XmlTObjDrivers::AddDrivers(const Handle(XmlMDF_ADriverTable)& aDriverTable,
const Handle(Message_Messenger)& anMsgDrv)
{
aDriverTable -> AddDriver (new XmlTObjDrivers_ModelDriver (anMsgDrv));
aDriverTable -> AddDriver (new XmlTObjDrivers_ObjectDriver (anMsgDrv));
aDriverTable -> AddDriver (new XmlTObjDrivers_ReferenceDriver (anMsgDrv));
aDriverTable -> AddDriver (new XmlTObjDrivers_XYZDriver (anMsgDrv));
aDriverTable -> AddDriver (new XmlTObjDrivers_IntSparseArrayDriver(anMsgDrv));
aDriverTable->AddDriver(new XmlTObjDrivers_ModelDriver(anMsgDrv));
aDriverTable->AddDriver(new XmlTObjDrivers_ObjectDriver(anMsgDrv));
aDriverTable->AddDriver(new XmlTObjDrivers_ReferenceDriver(anMsgDrv));
aDriverTable->AddDriver(new XmlTObjDrivers_XYZDriver(anMsgDrv));
aDriverTable->AddDriver(new XmlTObjDrivers_IntSparseArrayDriver(anMsgDrv));
}
PLUGIN(XmlTObjDrivers)

16
src/XmlTObjDrivers/XmlTObjDrivers.hxx
View File

@@ -26,22 +26,18 @@ class TDocStd_Application;
//! Class for registering storage/retrieval drivers for TObj XML persistence
class XmlTObjDrivers
class XmlTObjDrivers
{
public:
public:
//! Returns a driver corresponding to <aGUID>. Used for plugin.
Standard_EXPORT static const Handle(Standard_Transient)& Factory
(const Standard_GUID& aGUID);
Standard_EXPORT static const Handle(Standard_Transient)& Factory(const Standard_GUID& aGUID);
//! Defines format "TObjXml" and registers its read and write drivers
//! in the specified application
Standard_EXPORT static void DefineFormat (const Handle(TDocStd_Application)& theApp);
Standard_EXPORT static void AddDrivers
(const Handle(XmlMDF_ADriverTable)& aDriverTable,
const Handle(Message_Messenger)& anMsgDrv);
Standard_EXPORT static void DefineFormat(const Handle(TDocStd_Application)& theApp);
Standard_EXPORT static void AddDrivers(const Handle(XmlMDF_ADriverTable)& aDriverTable,
const Handle(Message_Messenger)& anMsgDrv);
};
#endif

24
src/XmlTObjDrivers/XmlTObjDrivers_DocumentRetrievalDriver.cxx
View File

@@ -19,28 +19,20 @@
#include <XmlLDrivers.hxx>
#include <XmlTObjDrivers.hxx>
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_DocumentRetrievalDriver,XmlLDrivers_DocumentRetrievalDriver)
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_DocumentRetrievalDriver,
XmlLDrivers_DocumentRetrievalDriver)
//=======================================================================
//function : XmlTObjDrivers_DocumentRetrievalDriver
//purpose :
//=======================================================================
//=================================================================================================
XmlTObjDrivers_DocumentRetrievalDriver::XmlTObjDrivers_DocumentRetrievalDriver()
{
}
XmlTObjDrivers_DocumentRetrievalDriver::XmlTObjDrivers_DocumentRetrievalDriver() {}
//=======================================================================
//function : AttributeDrivers
//purpose :
//=======================================================================
//=================================================================================================
Handle(XmlMDF_ADriverTable)
XmlTObjDrivers_DocumentRetrievalDriver::AttributeDrivers
(const Handle(Message_Messenger)& theMsgDrv)
Handle(XmlMDF_ADriverTable) XmlTObjDrivers_DocumentRetrievalDriver::AttributeDrivers(
const Handle(Message_Messenger)& theMsgDrv)
{
// Standard drivers
Handle(XmlMDF_ADriverTable) aTable = XmlLDrivers::AttributeDrivers (theMsgDrv);
Handle(XmlMDF_ADriverTable) aTable = XmlLDrivers::AttributeDrivers(theMsgDrv);
// Native drivers
XmlTObjDrivers::AddDrivers(aTable, theMsgDrv);

20
src/XmlTObjDrivers/XmlTObjDrivers_DocumentRetrievalDriver.hxx
View File

@@ -21,30 +21,28 @@
#include <XmlLDrivers_DocumentRetrievalDriver.hxx>
#include <XmlMDF_ADriverTable.hxx>
// Retrieval driver of a TObj XML document
//
class XmlTObjDrivers_DocumentRetrievalDriver :
public XmlLDrivers_DocumentRetrievalDriver
class XmlTObjDrivers_DocumentRetrievalDriver : public XmlLDrivers_DocumentRetrievalDriver
{
public:
public:
// ---------- PUBLIC METHODS ----------
Standard_EXPORT XmlTObjDrivers_DocumentRetrievalDriver ();
Standard_EXPORT XmlTObjDrivers_DocumentRetrievalDriver();
// Constructor
Standard_EXPORT virtual Handle(XmlMDF_ADriverTable) AttributeDrivers
(const Handle(Message_Messenger)& theMsgDriver) Standard_OVERRIDE;
Standard_EXPORT virtual Handle(XmlMDF_ADriverTable) AttributeDrivers(
const Handle(Message_Messenger)& theMsgDriver) Standard_OVERRIDE;
public:
public:
// Declaration of CASCADE RTTI
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_DocumentRetrievalDriver,XmlLDrivers_DocumentRetrievalDriver)
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_DocumentRetrievalDriver,
XmlLDrivers_DocumentRetrievalDriver)
};
// Definition of HANDLE object using Standard_DefineHandle.hxx
DEFINE_STANDARD_HANDLE (XmlTObjDrivers_DocumentRetrievalDriver,
XmlLDrivers_DocumentRetrievalDriver)
DEFINE_STANDARD_HANDLE(XmlTObjDrivers_DocumentRetrievalDriver, XmlLDrivers_DocumentRetrievalDriver)
#endif

25
src/XmlTObjDrivers/XmlTObjDrivers_DocumentStorageDriver.cxx
View File

@@ -19,30 +19,23 @@
#include <XmlLDrivers.hxx>
#include <XmlTObjDrivers.hxx>
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_DocumentStorageDriver,XmlLDrivers_DocumentStorageDriver)
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_DocumentStorageDriver, XmlLDrivers_DocumentStorageDriver)
//=======================================================================
//function : XmlTObjDrivers_DocumentStorageDriver
//purpose :
//=======================================================================
//=================================================================================================
XmlTObjDrivers_DocumentStorageDriver::XmlTObjDrivers_DocumentStorageDriver
(const TCollection_ExtendedString& theCopyright)
: XmlLDrivers_DocumentStorageDriver (theCopyright)
XmlTObjDrivers_DocumentStorageDriver::XmlTObjDrivers_DocumentStorageDriver(
const TCollection_ExtendedString& theCopyright)
: XmlLDrivers_DocumentStorageDriver(theCopyright)
{
}
//=======================================================================
//function : AttributeDrivers
//purpose :
//=======================================================================
//=================================================================================================
Handle(XmlMDF_ADriverTable)
XmlTObjDrivers_DocumentStorageDriver::AttributeDrivers
(const Handle(Message_Messenger)& theMsgDrv)
Handle(XmlMDF_ADriverTable) XmlTObjDrivers_DocumentStorageDriver::AttributeDrivers(
const Handle(Message_Messenger)& theMsgDrv)
{
// Standard drivers
Handle(XmlMDF_ADriverTable) aTable = XmlLDrivers::AttributeDrivers (theMsgDrv);
Handle(XmlMDF_ADriverTable) aTable = XmlLDrivers::AttributeDrivers(theMsgDrv);
// Native drivers
XmlTObjDrivers::AddDrivers(aTable, theMsgDrv);

21
src/XmlTObjDrivers/XmlTObjDrivers_DocumentStorageDriver.hxx
View File

@@ -21,31 +21,28 @@
#include <XmlLDrivers_DocumentStorageDriver.hxx>
#include <XmlMDF_ADriverTable.hxx>
// Block of comments describing class XmlTObjDrivers_DocumentStorageDriver
//
class XmlTObjDrivers_DocumentStorageDriver :
public XmlLDrivers_DocumentStorageDriver
class XmlTObjDrivers_DocumentStorageDriver : public XmlLDrivers_DocumentStorageDriver
{
public:
public:
// ---------- PUBLIC METHODS ----------
Standard_EXPORT XmlTObjDrivers_DocumentStorageDriver
(const TCollection_ExtendedString& theCopyright);
Standard_EXPORT XmlTObjDrivers_DocumentStorageDriver(
const TCollection_ExtendedString& theCopyright);
// Constructor
Standard_EXPORT virtual Handle(XmlMDF_ADriverTable) AttributeDrivers
(const Handle(Message_Messenger)& theMsgDriver) Standard_OVERRIDE;
Standard_EXPORT virtual Handle(XmlMDF_ADriverTable) AttributeDrivers(
const Handle(Message_Messenger)& theMsgDriver) Standard_OVERRIDE;
public:
public:
// Declaration of CASCADE RTTI
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_DocumentStorageDriver,XmlLDrivers_DocumentStorageDriver)
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_DocumentStorageDriver, XmlLDrivers_DocumentStorageDriver)
};
// Definition of HANDLE object using Standard_DefineHandle.hxx
DEFINE_STANDARD_HANDLE (XmlTObjDrivers_DocumentStorageDriver,
XmlLDrivers_DocumentStorageDriver)
DEFINE_STANDARD_HANDLE(XmlTObjDrivers_DocumentStorageDriver, XmlLDrivers_DocumentStorageDriver)
#endif

97
src/XmlTObjDrivers/XmlTObjDrivers_IntSparseArrayDriver.cxx
View File

@@ -22,26 +22,22 @@
#include <TCollection_AsciiString.hxx>
#include <TDF_Tool.hxx>
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_IntSparseArrayDriver,XmlMDF_ADriver)
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_IntSparseArrayDriver, XmlMDF_ADriver)
#define ITEM_ID "itemId_"
#define ITEM_VALUE "itemValue_"
//=======================================================================
//function : XmlTObjDrivers_IntSparseArrayDriver
//purpose : constructor
//=======================================================================
//=================================================================================================
XmlTObjDrivers_IntSparseArrayDriver::XmlTObjDrivers_IntSparseArrayDriver
(const Handle(Message_Messenger)& theMessageDriver)
: XmlMDF_ADriver( theMessageDriver, NULL)
XmlTObjDrivers_IntSparseArrayDriver::XmlTObjDrivers_IntSparseArrayDriver(
const Handle(Message_Messenger)& theMessageDriver)
: XmlMDF_ADriver(theMessageDriver, NULL)
{
}
//=======================================================================
//function : NewEmpty
//purpose : Creates a new attribute
// function : NewEmpty
// purpose : Creates a new attribute
//=======================================================================
Handle(TDF_Attribute) XmlTObjDrivers_IntSparseArrayDriver::NewEmpty() const
@@ -50,37 +46,34 @@ Handle(TDF_Attribute) XmlTObjDrivers_IntSparseArrayDriver::NewEmpty() const
}
//=======================================================================
//function : Paste
//purpose : Retrieve. Translate the contents of <theSource> and put it
// function : Paste
// purpose : Retrieve. Translate the contents of <theSource> and put it
// into <theTarget>.
//=======================================================================
Standard_Boolean XmlTObjDrivers_IntSparseArrayDriver::Paste
(const XmlObjMgt_Persistent& theSource,
const Handle(TDF_Attribute)& theTarget,
XmlObjMgt_RRelocationTable&) const
Standard_Boolean XmlTObjDrivers_IntSparseArrayDriver::Paste(const XmlObjMgt_Persistent& theSource,
const Handle(TDF_Attribute)& theTarget,
XmlObjMgt_RRelocationTable&) const
{
const XmlObjMgt_Element& anElement = theSource;
Handle(TObj_TIntSparseArray) aTarget =
Handle(TObj_TIntSparseArray)::DownCast(theTarget);
const XmlObjMgt_Element& anElement = theSource;
Handle(TObj_TIntSparseArray) aTarget = Handle(TObj_TIntSparseArray)::DownCast(theTarget);
// get pairs (ID, value) while ID != 0
Standard_Integer i = 1;
Standard_Integer i = 1;
TCollection_AsciiString anItemID;
TCollection_AsciiString anIdStr = TCollection_AsciiString( ITEM_ID ) +
TCollection_AsciiString( i );
anItemID = anElement.getAttribute( anIdStr.ToCString() );
while( anItemID.IsIntegerValue() && anItemID.IntegerValue() != 0 )
TCollection_AsciiString anIdStr = TCollection_AsciiString(ITEM_ID) + TCollection_AsciiString(i);
anItemID = anElement.getAttribute(anIdStr.ToCString());
while (anItemID.IsIntegerValue() && anItemID.IntegerValue() != 0)
{
TCollection_AsciiString aStrIndex = TCollection_AsciiString( ITEM_VALUE ) +
TCollection_AsciiString( i );
TCollection_AsciiString anItemValue = anElement.getAttribute( aStrIndex.ToCString() );
if ( anItemValue.IsIntegerValue() )
TCollection_AsciiString aStrIndex =
TCollection_AsciiString(ITEM_VALUE) + TCollection_AsciiString(i);
TCollection_AsciiString anItemValue = anElement.getAttribute(aStrIndex.ToCString());
if (anItemValue.IsIntegerValue())
{
// store the value in the target array
aTarget->SetDoBackup (Standard_False);
aTarget->SetValue (anItemID.IntegerValue(), anItemValue.IntegerValue());
aTarget->SetDoBackup (Standard_True);
aTarget->SetDoBackup(Standard_False);
aTarget->SetValue(anItemID.IntegerValue(), anItemValue.IntegerValue());
aTarget->SetDoBackup(Standard_True);
}
i++;
}
@@ -88,41 +81,37 @@ Standard_Boolean XmlTObjDrivers_IntSparseArrayDriver::Paste
}
//=======================================================================
//function : Paste
//purpose : Store. Translate the contents of <theSource> and put it
// function : Paste
// purpose : Store. Translate the contents of <theSource> and put it
// into <theTarget>
//=======================================================================
void XmlTObjDrivers_IntSparseArrayDriver::Paste
(const Handle(TDF_Attribute)& theSource,
XmlObjMgt_Persistent& theTarget,
XmlObjMgt_SRelocationTable&) const
void XmlTObjDrivers_IntSparseArrayDriver::Paste(const Handle(TDF_Attribute)& theSource,
XmlObjMgt_Persistent& theTarget,
XmlObjMgt_SRelocationTable&) const
{
Handle(TObj_TIntSparseArray) aSource =
Handle(TObj_TIntSparseArray)::DownCast (theSource);
Handle(TObj_TIntSparseArray) aSource = Handle(TObj_TIntSparseArray)::DownCast(theSource);
// put only non-null values as pairs (ID, value)
// terminate the list by ID=0
TObj_TIntSparseArray::Iterator anIt = aSource->GetIterator();
Standard_Integer i = 1;
for ( ; anIt.More() ; anIt.Next() )
Standard_Integer i = 1;
for (; anIt.More(); anIt.Next())
{
Standard_Integer aValue = anIt.Value();
if (aValue == 0)
continue;
TCollection_AsciiString anIdStr = TCollection_AsciiString( ITEM_ID ) +
TCollection_AsciiString( i );
TCollection_AsciiString aStrIndex = TCollection_AsciiString( ITEM_VALUE ) +
TCollection_AsciiString( i );
theTarget.Element().setAttribute( anIdStr.ToCString(), (Standard_Integer)anIt.Index() );
theTarget.Element().setAttribute( aStrIndex.ToCString(), anIt.Value() );
TCollection_AsciiString anIdStr = TCollection_AsciiString(ITEM_ID) + TCollection_AsciiString(i);
TCollection_AsciiString aStrIndex =
TCollection_AsciiString(ITEM_VALUE) + TCollection_AsciiString(i);
theTarget.Element().setAttribute(anIdStr.ToCString(), (Standard_Integer)anIt.Index());
theTarget.Element().setAttribute(aStrIndex.ToCString(), anIt.Value());
i++;
}
// write last item
TCollection_AsciiString anIdStr = TCollection_AsciiString( ITEM_ID ) +
TCollection_AsciiString( i );
TCollection_AsciiString aStrIndex = TCollection_AsciiString( ITEM_VALUE ) +
TCollection_AsciiString( i );
theTarget.Element().setAttribute( anIdStr.ToCString(), 0 );
theTarget.Element().setAttribute( aStrIndex.ToCString(), 0 );
TCollection_AsciiString anIdStr = TCollection_AsciiString(ITEM_ID) + TCollection_AsciiString(i);
TCollection_AsciiString aStrIndex =
TCollection_AsciiString(ITEM_VALUE) + TCollection_AsciiString(i);
theTarget.Element().setAttribute(anIdStr.ToCString(), 0);
theTarget.Element().setAttribute(aStrIndex.ToCString(), 0);
}

30
src/XmlTObjDrivers/XmlTObjDrivers_IntSparseArrayDriver.hxx
View File

@@ -20,39 +20,37 @@
#include <XmlMDF_ADriver.hxx>
class XmlTObjDrivers_IntSparseArrayDriver : public XmlMDF_ADriver
class XmlTObjDrivers_IntSparseArrayDriver : public XmlMDF_ADriver
{
public:
Standard_EXPORT XmlTObjDrivers_IntSparseArrayDriver
(const Handle(Message_Messenger)& theMessageDriver);
public:
Standard_EXPORT XmlTObjDrivers_IntSparseArrayDriver(
const Handle(Message_Messenger)& theMessageDriver);
// constructor
Standard_EXPORT Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
// Creates a new attribute
Standard_EXPORT Standard_Boolean Paste
(const XmlObjMgt_Persistent& theSource,
const Handle(TDF_Attribute)& theTarget,
XmlObjMgt_RRelocationTable& theRelocTable) const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean
Paste(const XmlObjMgt_Persistent& theSource,
const Handle(TDF_Attribute)& theTarget,
XmlObjMgt_RRelocationTable& theRelocTable) const Standard_OVERRIDE;
// Translate the contents of <theSource> and put it
// into <theTarget>
Standard_EXPORT void Paste
(const Handle(TDF_Attribute)& theSource,
XmlObjMgt_Persistent& theTarget,
XmlObjMgt_SRelocationTable& theRelocTable) const Standard_OVERRIDE;
Standard_EXPORT void Paste(const Handle(TDF_Attribute)& theSource,
XmlObjMgt_Persistent& theTarget,
XmlObjMgt_SRelocationTable& theRelocTable) const Standard_OVERRIDE;
// Translate the contents of <aSource> and put it
// into <aTarget>
public:
public:
// CASCADE RTTI
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_IntSparseArrayDriver,XmlMDF_ADriver)
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_IntSparseArrayDriver, XmlMDF_ADriver)
};
// Define handle class
DEFINE_STANDARD_HANDLE(XmlTObjDrivers_IntSparseArrayDriver,XmlMDF_ADriver)
DEFINE_STANDARD_HANDLE(XmlTObjDrivers_IntSparseArrayDriver, XmlMDF_ADriver)
#endif

66
src/XmlTObjDrivers/XmlTObjDrivers_ModelDriver.cxx
View File

@@ -15,7 +15,6 @@
// The original implementation Copyright: (C) RINA S.p.A
#include "XmlTObjDrivers_ModelDriver.hxx"
#include <XmlObjMgt_Persistent.hxx>
@@ -27,25 +26,19 @@
#include <TObj_Model.hxx>
#include <TObj_Assistant.hxx>
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_ModelDriver, XmlMDF_ADriver)
//=================================================================================================
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_ModelDriver,XmlMDF_ADriver)
//=======================================================================
//function : XmlTObjDrivers_ModelDriver
//purpose : constructor
//=======================================================================
XmlTObjDrivers_ModelDriver::XmlTObjDrivers_ModelDriver
(const Handle(Message_Messenger)& theMessageDriver)
: XmlMDF_ADriver( theMessageDriver, NULL)
XmlTObjDrivers_ModelDriver::XmlTObjDrivers_ModelDriver(
const Handle(Message_Messenger)& theMessageDriver)
: XmlMDF_ADriver(theMessageDriver, NULL)
{
}
//=======================================================================
//function : NewEmpty
//purpose : Creates a new attribute
// function : NewEmpty
// purpose : Creates a new attribute
//=======================================================================
Handle(TDF_Attribute) XmlTObjDrivers_ModelDriver::NewEmpty() const
@@ -54,29 +47,28 @@ Handle(TDF_Attribute) XmlTObjDrivers_ModelDriver::NewEmpty() const
}
//=======================================================================
//function : Paste
//purpose : Translate the contents of <aSource> and put it
// function : Paste
// purpose : Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
// Set CurrentModel of TObj_Assistant into Target TObj_TModel
// if its GUID and GUID stored in Source are same
//=======================================================================
Standard_Boolean XmlTObjDrivers_ModelDriver::Paste
(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& /*RelocTable*/) const
Standard_Boolean XmlTObjDrivers_ModelDriver::Paste(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& /*RelocTable*/) const
{
TCollection_ExtendedString aString;
if (XmlObjMgt::GetExtendedString (Source, aString))
if (XmlObjMgt::GetExtendedString(Source, aString))
{
Standard_GUID aGUID (aString.ToExtString());
Standard_GUID aGUID(aString.ToExtString());
Handle(TObj_Model) aCurrentModel = TObj_Assistant::GetCurrentModel();
if (aGUID == aCurrentModel->GetGUID())
if (aGUID == aCurrentModel->GetGUID())
{
Handle(TObj_TModel) aTModel = Handle(TObj_TModel)::DownCast( Target );
aCurrentModel->SetLabel ( aTModel->Label() );
aTModel->Set( aCurrentModel );
Handle(TObj_TModel) aTModel = Handle(TObj_TModel)::DownCast(Target);
aCurrentModel->SetLabel(aTModel->Label());
aTModel->Set(aCurrentModel);
return Standard_True;
}
myMessageDriver->Send("TObj_TModel retrieval: wrong model GUID", Message_Fail);
@@ -87,25 +79,23 @@ Standard_Boolean XmlTObjDrivers_ModelDriver::Paste
}
//=======================================================================
//function : Paste
//purpose : Translate the contents of <aSource> and put it
// function : Paste
// purpose : Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
// a Model is stored as its GUID
//=======================================================================
void XmlTObjDrivers_ModelDriver::Paste
(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& /*RelocTable*/) const
void XmlTObjDrivers_ModelDriver::Paste(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& /*RelocTable*/) const
{
Handle(TObj_TModel) aTModel =
Handle(TObj_TModel)::DownCast( Source );
Handle(TObj_Model) aModel = aTModel->Model();
Handle(TObj_TModel) aTModel = Handle(TObj_TModel)::DownCast(Source);
Handle(TObj_Model) aModel = aTModel->Model();
// Store model GUID.
Standard_PCharacter aPGuidString = new Standard_Character[256];
aModel->GetGUID().ToCString( aPGuidString );
XmlObjMgt::SetExtendedString (Target, aPGuidString);
delete []aPGuidString;
aModel->GetGUID().ToCString(aPGuidString);
XmlObjMgt::SetExtendedString(Target, aPGuidString);
delete[] aPGuidString;
}

32
src/XmlTObjDrivers/XmlTObjDrivers_ModelDriver.hxx
View File

@@ -20,45 +20,41 @@
#include <XmlMDF_ADriver.hxx>
class XmlTObjDrivers_ModelDriver : public XmlMDF_ADriver
class XmlTObjDrivers_ModelDriver : public XmlMDF_ADriver
{
public:
Standard_EXPORT XmlTObjDrivers_ModelDriver
(const Handle(Message_Messenger)& theMessageDriver);
public:
Standard_EXPORT XmlTObjDrivers_ModelDriver(const Handle(Message_Messenger)& theMessageDriver);
// constructor
Standard_EXPORT Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
// Creates a new attribute
Standard_EXPORT Standard_Boolean Paste
(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& RelocTable) const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean
Paste(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& RelocTable) const Standard_OVERRIDE;
// Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
// Set CurrentModel of TObj_Persistence into Target TObj_TModel
// if its GUID and GUID stored in Source are same
Standard_EXPORT void Paste
(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& RelocTable) const Standard_OVERRIDE;
Standard_EXPORT void Paste(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& RelocTable) const Standard_OVERRIDE;
// Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
// a Model is stored as its GUID
public:
public:
// CASCADE RTTI
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_ModelDriver,XmlMDF_ADriver)
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_ModelDriver, XmlMDF_ADriver)
};
// Define handle class
DEFINE_STANDARD_HANDLE(XmlTObjDrivers_ModelDriver,XmlMDF_ADriver)
DEFINE_STANDARD_HANDLE(XmlTObjDrivers_ModelDriver, XmlMDF_ADriver)
#endif

64
src/XmlTObjDrivers/XmlTObjDrivers_ObjectDriver.cxx
View File

@@ -15,7 +15,6 @@
// The original implementation Copyright: (C) RINA S.p.A
#include <Message_Messenger.hxx>
#include "XmlTObjDrivers_ObjectDriver.hxx"
#include <TObj_TObject.hxx>
@@ -24,25 +23,19 @@
#include <XmlObjMgt_RRelocationTable.hxx>
#include <XmlObjMgt.hxx>
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_ObjectDriver, XmlMDF_ADriver)
//=================================================================================================
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_ObjectDriver,XmlMDF_ADriver)
//=======================================================================
//function : XmlTObjDrivers_ObjectDriver
//purpose : constructor
//=======================================================================
XmlTObjDrivers_ObjectDriver::XmlTObjDrivers_ObjectDriver
(const Handle(Message_Messenger)& theMessageDriver)
: XmlMDF_ADriver( theMessageDriver, NULL)
XmlTObjDrivers_ObjectDriver::XmlTObjDrivers_ObjectDriver(
const Handle(Message_Messenger)& theMessageDriver)
: XmlMDF_ADriver(theMessageDriver, NULL)
{
}
//=======================================================================
//function : NewEmpty
//purpose : Creates a new attribute
// function : NewEmpty
// purpose : Creates a new attribute
//=======================================================================
Handle(TDF_Attribute) XmlTObjDrivers_ObjectDriver::NewEmpty() const
@@ -51,24 +44,24 @@ Handle(TDF_Attribute) XmlTObjDrivers_ObjectDriver::NewEmpty() const
}
//=======================================================================
//function : Paste
//purpose : Translate the contents of <aSource> and put it
// function : Paste
// purpose : Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
//=======================================================================
Standard_Boolean XmlTObjDrivers_ObjectDriver::Paste
(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& /*RelocTable*/) const
Standard_Boolean XmlTObjDrivers_ObjectDriver::Paste(
const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& /*RelocTable*/) const
{
TCollection_ExtendedString aString;
if (XmlObjMgt::GetExtendedString (Source, aString))
if (XmlObjMgt::GetExtendedString(Source, aString))
{
TCollection_AsciiString anAscii (aString);
Handle(TObj_Object) anObject =
TObj_Persistence::CreateNewObject(anAscii.ToCString(),Target->Label());
Handle(TObj_TObject)::DownCast (Target) ->Set( anObject );
TCollection_AsciiString anAscii(aString);
Handle(TObj_Object) anObject =
TObj_Persistence::CreateNewObject(anAscii.ToCString(), Target->Label());
Handle(TObj_TObject)::DownCast(Target)->Set(anObject);
return Standard_True;
}
myMessageDriver->Send("error retrieving ExtendedString for type TObj_TModel", Message_Fail);
@@ -76,22 +69,19 @@ Standard_Boolean XmlTObjDrivers_ObjectDriver::Paste
}
//=======================================================================
//function : Paste
//purpose : Translate the contents of <aSource> and put it
// function : Paste
// purpose : Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
// anObject is stored as a Name of class derived from TObj_Object
//=======================================================================
void XmlTObjDrivers_ObjectDriver::Paste
(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& /*RelocTable*/) const
void XmlTObjDrivers_ObjectDriver::Paste(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& /*RelocTable*/) const
{
Handle(TObj_TObject) aTObj =
Handle(TObj_TObject)::DownCast( Source );
Handle(TObj_Object) anIObject = aTObj->Get();
XmlObjMgt::SetExtendedString (Target, anIObject->DynamicType()->Name());
}
Handle(TObj_TObject) aTObj = Handle(TObj_TObject)::DownCast(Source);
Handle(TObj_Object) anIObject = aTObj->Get();
XmlObjMgt::SetExtendedString(Target, anIObject->DynamicType()->Name());
}

31
src/XmlTObjDrivers/XmlTObjDrivers_ObjectDriver.hxx
View File

@@ -15,51 +15,46 @@
// The original implementation Copyright: (C) RINA S.p.A
#ifndef XmlTObjDrivers_ObjectDriver_HeaderFile
#define XmlTObjDrivers_ObjectDriver_HeaderFile
#include <XmlMDF_ADriver.hxx>
class XmlTObjDrivers_ObjectDriver : public XmlMDF_ADriver
class XmlTObjDrivers_ObjectDriver : public XmlMDF_ADriver
{
public:
Standard_EXPORT XmlTObjDrivers_ObjectDriver
(const Handle(Message_Messenger)& theMessageDriver);
public:
Standard_EXPORT XmlTObjDrivers_ObjectDriver(const Handle(Message_Messenger)& theMessageDriver);
// constructor
Standard_EXPORT Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
// Creates a new attribute
Standard_EXPORT Standard_Boolean Paste
(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& RelocTable) const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean
Paste(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& RelocTable) const Standard_OVERRIDE;
// Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
// an TObj_Object is restored by TObj_Persistence basing on class name
// stored in Source
Standard_EXPORT void Paste
(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& RelocTable) const Standard_OVERRIDE;
Standard_EXPORT void Paste(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& RelocTable) const Standard_OVERRIDE;
// Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
// anObject is stored as a Name of class derived from TObj_Object
public:
public:
// CASCADE RTTI
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_ObjectDriver,XmlMDF_ADriver)
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_ObjectDriver, XmlMDF_ADriver)
};
// Define handle class
DEFINE_STANDARD_HANDLE(XmlTObjDrivers_ObjectDriver,XmlMDF_ADriver)
DEFINE_STANDARD_HANDLE(XmlTObjDrivers_ObjectDriver, XmlMDF_ADriver)
#endif

84
src/XmlTObjDrivers/XmlTObjDrivers_ReferenceDriver.cxx
View File

@@ -15,7 +15,6 @@
// The original implementation Copyright: (C) RINA S.p.A
#include "XmlTObjDrivers_ReferenceDriver.hxx"
#include <TDF_Tool.hxx>
@@ -30,26 +29,22 @@
#include <TObj_Object.hxx>
#include <TObj_Assistant.hxx>
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_ReferenceDriver, XmlMDF_ADriver)
IMPLEMENT_DOMSTRING(MasterEntry, "master")
IMPLEMENT_DOMSTRING(ReferredEntry, "entry")
IMPLEMENT_DOMSTRING(ReferredModelEntry, "modelentry")
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_ReferenceDriver,XmlMDF_ADriver)
IMPLEMENT_DOMSTRING (MasterEntry, "master")
IMPLEMENT_DOMSTRING (ReferredEntry, "entry")
IMPLEMENT_DOMSTRING (ReferredModelEntry, "modelentry")
//=================================================================================================
//=======================================================================
//function : XmlTObjDrivers_ReferenceDriver
//purpose : constructor
//=======================================================================
XmlTObjDrivers_ReferenceDriver::XmlTObjDrivers_ReferenceDriver
(const Handle(Message_Messenger)& theMessageDriver)
: XmlMDF_ADriver( theMessageDriver, NULL)
XmlTObjDrivers_ReferenceDriver::XmlTObjDrivers_ReferenceDriver(
const Handle(Message_Messenger)& theMessageDriver)
: XmlMDF_ADriver(theMessageDriver, NULL)
{
}
//=======================================================================
//function : NewEmpty
//purpose : Creates a new attribute
// function : NewEmpty
// purpose : Creates a new attribute
//=======================================================================
Handle(TDF_Attribute) XmlTObjDrivers_ReferenceDriver::NewEmpty() const
@@ -58,60 +53,56 @@ Handle(TDF_Attribute) XmlTObjDrivers_ReferenceDriver::NewEmpty() const
}
//=======================================================================
//function : Paste
//purpose : Translate the contents of <aSource> and put it
// function : Paste
// purpose : Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
//=======================================================================
Standard_Boolean XmlTObjDrivers_ReferenceDriver::Paste
(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& /*RelocTable*/) const
Standard_Boolean XmlTObjDrivers_ReferenceDriver::Paste(
const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& /*RelocTable*/) const
{
const XmlObjMgt_Element& anElement = Source;
// get entries
TCollection_AsciiString RefEntry = anElement.getAttribute(::ReferredEntry());
TCollection_AsciiString MasterEntry = anElement.getAttribute(::MasterEntry());
// entry in model holder
TCollection_AsciiString InHolderEntry =
anElement.getAttribute(::ReferredModelEntry());
TCollection_AsciiString InHolderEntry = anElement.getAttribute(::ReferredModelEntry());
// master label
TDF_Label aLabel, aMasterLabel;
TDF_Tool::Label (Target->Label().Data(), MasterEntry, aMasterLabel);
TDF_Tool::Label(Target->Label().Data(), MasterEntry, aMasterLabel);
// referred label
if (InHolderEntry.IsEmpty())
TDF_Tool::Label (Target->Label().Data(), RefEntry, aLabel, Standard_True);
TDF_Tool::Label(Target->Label().Data(), RefEntry, aLabel, Standard_True);
else
{
Handle(TObj_Model) aModel = TObj_Assistant::FindModel (InHolderEntry.ToCString());
TDF_Tool::Label (aModel->GetLabel().Data(), RefEntry, aLabel, Standard_True);
Handle(TObj_Model) aModel = TObj_Assistant::FindModel(InHolderEntry.ToCString());
TDF_Tool::Label(aModel->GetLabel().Data(), RefEntry, aLabel, Standard_True);
}
Handle(TObj_TReference) aTarget =
Handle(TObj_TReference)::DownCast (Target);
aTarget->Set ( aLabel, aMasterLabel );
Handle(TObj_TReference) aTarget = Handle(TObj_TReference)::DownCast(Target);
aTarget->Set(aLabel, aMasterLabel);
return !aLabel.IsNull() && !aMasterLabel.IsNull();
}
//=======================================================================
//function : Paste
//purpose : Translate the contents of <aSource> and put it
// function : Paste
// purpose : Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
// Store master and referred labels as entry, the other model referred
// as entry in model-container
//=======================================================================
void XmlTObjDrivers_ReferenceDriver::Paste
(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& /*RelocTable*/) const
void XmlTObjDrivers_ReferenceDriver::Paste(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& /*RelocTable*/) const
{
Handle(TObj_TReference) aSource =
Handle(TObj_TReference)::DownCast (Source);
Handle(TObj_TReference) aSource = Handle(TObj_TReference)::DownCast(Source);
Handle(TObj_Object) aLObject = aSource->Get();
if (aLObject.IsNull())
@@ -119,20 +110,21 @@ void XmlTObjDrivers_ReferenceDriver::Paste
// referred entry
TCollection_AsciiString entry;
TDF_Label aLabel = aLObject->GetLabel();
TDF_Tool::Entry( aLabel, entry );
TDF_Label aLabel = aLObject->GetLabel();
TDF_Tool::Entry(aLabel, entry);
Target.Element().setAttribute(::ReferredEntry(), entry.ToCString());
// master entry
entry.Clear();
TDF_Label aMasterLabel = aSource->GetMasterLabel();
TDF_Tool::Entry( aMasterLabel, entry );
TDF_Tool::Entry(aMasterLabel, entry);
Target.Element().setAttribute(::MasterEntry(), entry.ToCString());
// is reference to other document
if (aLabel.Root() == aMasterLabel.Root()) return;
// is reference to other document
if (aLabel.Root() == aMasterLabel.Root())
return;
Handle(TObj_Model) aModel = aLObject->GetModel();
TCollection_AsciiString aModelName( aModel->GetModelName()->String() );
Handle(TObj_Model) aModel = aLObject->GetModel();
TCollection_AsciiString aModelName(aModel->GetModelName()->String());
Target.Element().setAttribute(::ReferredModelEntry(), aModelName.ToCString());
}

34
src/XmlTObjDrivers/XmlTObjDrivers_ReferenceDriver.hxx
View File

@@ -15,50 +15,46 @@
// The original implementation Copyright: (C) RINA S.p.A
#ifndef XmlTObjDrivers_ReferenceDriver_HeaderFile
#define XmlTObjDrivers_ReferenceDriver_HeaderFile
#include <XmlMDF_ADriver.hxx>
class XmlTObjDrivers_ReferenceDriver : public XmlMDF_ADriver
class XmlTObjDrivers_ReferenceDriver : public XmlMDF_ADriver
{
public:
Standard_EXPORT XmlTObjDrivers_ReferenceDriver
(const Handle(Message_Messenger)& theMessageDriver);
public:
Standard_EXPORT XmlTObjDrivers_ReferenceDriver(const Handle(Message_Messenger)& theMessageDriver);
// constructor
Standard_EXPORT Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
// Creates a new attribute
Standard_EXPORT Standard_Boolean Paste
(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& RelocTable) const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean
Paste(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& RelocTable) const Standard_OVERRIDE;
// Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
Standard_EXPORT void Paste
(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& RelocTable) const Standard_OVERRIDE;
Standard_EXPORT void Paste(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& RelocTable) const Standard_OVERRIDE;
// Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
// Store master and referred labels as entry, the other model referred
// Store master and referred labels as entry, the other model referred
// as entry in model-container
// The reference pointing nowhere is not stored
// The reference pointing nowhere is not stored
public:
public:
// CASCADE RTTI
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_ReferenceDriver,XmlMDF_ADriver)
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_ReferenceDriver, XmlMDF_ADriver)
};
// Define handle class
DEFINE_STANDARD_HANDLE(XmlTObjDrivers_ReferenceDriver,XmlMDF_ADriver)
DEFINE_STANDARD_HANDLE(XmlTObjDrivers_ReferenceDriver, XmlMDF_ADriver)
#endif

78
src/XmlTObjDrivers/XmlTObjDrivers_XYZDriver.cxx
View File

@@ -15,7 +15,6 @@
// The original implementation Copyright: (C) RINA S.p.A
#include <XmlTObjDrivers_XYZDriver.hxx>
#include <Message_Messenger.hxx>
@@ -26,26 +25,22 @@
#include <TObj_TXYZ.hxx>
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_XYZDriver, XmlMDF_ADriver)
IMPLEMENT_DOMSTRING(CoordX, "X")
IMPLEMENT_DOMSTRING(CoordY, "Y")
IMPLEMENT_DOMSTRING(CoordZ, "Z")
IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_XYZDriver,XmlMDF_ADriver)
IMPLEMENT_DOMSTRING (CoordX, "X")
IMPLEMENT_DOMSTRING (CoordY, "Y")
IMPLEMENT_DOMSTRING (CoordZ, "Z")
//=================================================================================================
//=======================================================================
//function : XmlTObjDrivers_XYZDriver
//purpose : constructor
//=======================================================================
XmlTObjDrivers_XYZDriver::XmlTObjDrivers_XYZDriver
(const Handle(Message_Messenger)& theMessageDriver)
: XmlMDF_ADriver( theMessageDriver, NULL)
XmlTObjDrivers_XYZDriver::XmlTObjDrivers_XYZDriver(
const Handle(Message_Messenger)& theMessageDriver)
: XmlMDF_ADriver(theMessageDriver, NULL)
{
}
//=======================================================================
//function : NewEmpty
//purpose : Creates a new attribute
// function : NewEmpty
// purpose : Creates a new attribute
//=======================================================================
Handle(TDF_Attribute) XmlTObjDrivers_XYZDriver::NewEmpty() const
@@ -54,80 +49,81 @@ Handle(TDF_Attribute) XmlTObjDrivers_XYZDriver::NewEmpty() const
}
//=======================================================================
//function : Paste
//purpose : Translate the contents of <aSource> and put it
// function : Paste
// purpose : Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
//=======================================================================
Standard_Boolean XmlTObjDrivers_XYZDriver::Paste
(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& /*RelocTable*/) const
Standard_Boolean XmlTObjDrivers_XYZDriver::Paste(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& /*RelocTable*/) const
{
const XmlObjMgt_Element& anElement = Source;
// get coordinates
TCollection_AsciiString CoordX = anElement.getAttribute(::CoordX());
TCollection_AsciiString CoordY = anElement.getAttribute(::CoordY());
TCollection_AsciiString CoordZ = anElement.getAttribute(::CoordZ());
// creating gp_XYZ
gp_XYZ aXYZ;
gp_XYZ aXYZ;
Standard_CString aStr;
Standard_Real aCoord;
Standard_Real aCoord;
aStr = CoordX.ToCString();
if(!XmlObjMgt::GetReal( aStr, aCoord )) return Standard_False;
if (!XmlObjMgt::GetReal(aStr, aCoord))
return Standard_False;
aXYZ.SetX(aCoord);
aStr = CoordY.ToCString();
if(!XmlObjMgt::GetReal( aStr, aCoord )) return Standard_False;
if (!XmlObjMgt::GetReal(aStr, aCoord))
return Standard_False;
aXYZ.SetY(aCoord);
aStr = CoordZ.ToCString();
if(!XmlObjMgt::GetReal( aStr, aCoord )) return Standard_False;
if (!XmlObjMgt::GetReal(aStr, aCoord))
return Standard_False;
aXYZ.SetZ(aCoord);
// setting gp_XYZ
Handle(TObj_TXYZ) aTarget = Handle(TObj_TXYZ)::DownCast (Target);
aTarget->Set ( aXYZ );
Handle(TObj_TXYZ) aTarget = Handle(TObj_TXYZ)::DownCast(Target);
aTarget->Set(aXYZ);
return Standard_True;
}
//=======================================================================
//function : Paste
//purpose : Translate the contents of <aSource> and put it
// function : Paste
// purpose : Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
// Store master and referred labels as entry, the other model referred
// as entry in model-container
//=======================================================================
void XmlTObjDrivers_XYZDriver::Paste
(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& /*RelocTable*/) const
void XmlTObjDrivers_XYZDriver::Paste(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& /*RelocTable*/) const
{
Handle(TObj_TXYZ) aSource =
Handle(TObj_TXYZ)::DownCast (Source);
Handle(TObj_TXYZ) aSource = Handle(TObj_TXYZ)::DownCast(Source);
if(aSource.IsNull()) return;
if (aSource.IsNull())
return;
gp_XYZ aXYZ = aSource->Get();
TCollection_AsciiString aCoord;
// coordinate X
aCoord = TCollection_AsciiString( aXYZ.X() );
aCoord = TCollection_AsciiString(aXYZ.X());
Target.Element().setAttribute(::CoordX(), aCoord.ToCString());
// coordinate Y
aCoord = TCollection_AsciiString( aXYZ.Y() );
aCoord = TCollection_AsciiString(aXYZ.Y());
Target.Element().setAttribute(::CoordY(), aCoord.ToCString());
// coordinate Z
aCoord = TCollection_AsciiString( aXYZ.Z() );
aCoord = TCollection_AsciiString(aXYZ.Z());
Target.Element().setAttribute(::CoordZ(), aCoord.ToCString());
}

34
src/XmlTObjDrivers/XmlTObjDrivers_XYZDriver.hxx
View File

@@ -15,50 +15,46 @@
// The original implementation Copyright: (C) RINA S.p.A
#ifndef XmlTObjDrivers_XYZDriver_HeaderFile
#define XmlTObjDrivers_XYZDriver_HeaderFile
#include <XmlMDF_ADriver.hxx>
class XmlTObjDrivers_XYZDriver : public XmlMDF_ADriver
class XmlTObjDrivers_XYZDriver : public XmlMDF_ADriver
{
public:
Standard_EXPORT XmlTObjDrivers_XYZDriver
(const Handle(Message_Messenger)& theMessageDriver);
public:
Standard_EXPORT XmlTObjDrivers_XYZDriver(const Handle(Message_Messenger)& theMessageDriver);
// constructor
Standard_EXPORT Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
// Creates a new attribute
Standard_EXPORT Standard_Boolean Paste
(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& RelocTable) const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean
Paste(const XmlObjMgt_Persistent& Source,
const Handle(TDF_Attribute)& Target,
XmlObjMgt_RRelocationTable& RelocTable) const Standard_OVERRIDE;
// Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
Standard_EXPORT void Paste
(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& RelocTable) const Standard_OVERRIDE;
Standard_EXPORT void Paste(const Handle(TDF_Attribute)& Source,
XmlObjMgt_Persistent& Target,
XmlObjMgt_SRelocationTable& RelocTable) const Standard_OVERRIDE;
// Translate the contents of <aSource> and put it
// into <aTarget>, using the relocation table
// <aRelocTable> to keep the sharings.
// Store master and referred labels as entry, the other model referred
// Store master and referred labels as entry, the other model referred
// as entry in model-container
// The XYZ pointing nowhere is not stored
// The XYZ pointing nowhere is not stored
public:
public:
// CASCADE RTTI
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_XYZDriver,XmlMDF_ADriver)
DEFINE_STANDARD_RTTIEXT(XmlTObjDrivers_XYZDriver, XmlMDF_ADriver)
};
// Define handle class
DEFINE_STANDARD_HANDLE(XmlTObjDrivers_XYZDriver,XmlMDF_ADriver)
DEFINE_STANDARD_HANDLE(XmlTObjDrivers_XYZDriver, XmlMDF_ADriver)
#endif