From: srn Date: Wed, 31 Oct 2007 08:56:46 +0000 (+0000) Subject: Data structure for tree of Labels and Attributes X-Git-Tag: V4_1_0a3~27 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=517ff513d5ed29d35720b4385e29af69a136f13c;p=modules%2Fkernel.git Data structure for tree of Labels and Attributes --- diff --git a/src/DF/DF_Application.cxx b/src/DF/DF_Application.cxx new file mode 100644 index 000000000..1e2c50f1b --- /dev/null +++ b/src/DF/DF_Application.cxx @@ -0,0 +1,79 @@ +#include "DF_definitions.hxx" +#include "DF_Application.hxx" + +using namespace std; + +//Constructor +DF_Application::DF_Application() +{ + _currentID = 0; +} + +DF_Application::~DF_Application() +{ + _documents.clear(); +} + +//Creates a new document with given type, returns a smart pointer to +//newly created document. +DF_Document* DF_Application::NewDocument(const string& theDocumentType) +{ + DF_Document* aDoc = new DF_Document(theDocumentType); + aDoc->_id = ++_currentID; + _documents[aDoc->_id] = aDoc; + aDoc->_appli = this; + return aDoc; +} + +//Closes and removes the given Document +void DF_Application::Close(const DF_Document* theDocument) +{ + int id = -1; + if(theDocument) id = theDocument->GetDocumentID(); + + if(_documents.find(id) != _documents.end()) { + _documents[id]->Clear(); + _documents.erase(id); + delete theDocument; + } +} + +//Returns a Document by Document's ID +DF_Document* DF_Application::GetDocument(int theDocumentID) +{ + if(_documents.find(theDocumentID) == _documents.end()) return NULL; + + return _documents[theDocumentID]; +} + +//Returns a list of IDs of all currently opened documents +vector DF_Application::GetDocumentIDs() +{ + vector ids; + typedef map::const_iterator DI; + for(DI p = _documents.begin(); p!=_documents.end(); p++) + ids.push_back(p->first); + return ids; +} + +//Returns a number of existent documents +int DF_Application::NbDocuments() +{ + return _documents.size(); +} + + +//Restores a Document from the given file, returns a smart +//pointer to opened document. +DF_Document* DF_Application::Open(const string& theFileName) +{ + //Not implemented + return NULL; +} + + +//Saves a Document in a given file with name theFileName +void DF_Application::SaveAs(const DF_Document* theDocument, const string& theFileName) +{ + //Not implemented +} diff --git a/src/DF/DF_Application.hxx b/src/DF/DF_Application.hxx new file mode 100644 index 000000000..bae155e73 --- /dev/null +++ b/src/DF/DF_Application.hxx @@ -0,0 +1,47 @@ +#ifndef DFAPPLICATION_HXX +#define DFAPPLICATION_HXX + +#include "DF_definitions.hxx" +#include "DF_Document.hxx" +#include +#include + +//Class DF_Application responsible for creation and manipulation of Documents +class DF_Application { +public: + //Constructor + Standard_EXPORT DF_Application(); + + Standard_EXPORT ~DF_Application(); + + //Creates a new document with given type, returns a smart pointer to + //newly created document. + Standard_EXPORT DF_Document* NewDocument(const std::string& theDocumentType); + + //Closes and removes the given Document + Standard_EXPORT void Close(const DF_Document* theDocument); + + //Returns a Document by Document's ID + Standard_EXPORT DF_Document* GetDocument(int theDocumentID); + + //Returns a list of IDs of all currently opened documents + Standard_EXPORT std::vector GetDocumentIDs(); + + //Returns a number of existent documents + Standard_EXPORT int NbDocuments(); + + //Virtual methods to be redefined if required by specific application + + //Restores a Document from the given file, returns a smart + //pointer to opened document. + Standard_EXPORT virtual DF_Document* Open(const std::string& theFileName); + + //Saves a Document in a given file with name theFileName + Standard_EXPORT virtual void SaveAs(const DF_Document* theDocument, const std::string& theFileName); + +private: + int _currentID; + std::map _documents; + +}; +#endif diff --git a/src/DF/DF_Attribute.cxx b/src/DF/DF_Attribute.cxx new file mode 100644 index 000000000..c392dd9d2 --- /dev/null +++ b/src/DF/DF_Attribute.cxx @@ -0,0 +1,42 @@ +#include "DF_definitions.hxx" +#include "DF_Label.hxx" +#include "DF_Attribute.hxx" + +using namespace std; + +//Class DF_Attribute is used to store some data defined by the DF_Attribute type + +//Constructor +DF_Attribute::DF_Attribute() +{ + _node = NULL; +} + +DF_Attribute::~DF_Attribute() +{ + //Remove an attribute from a map of the node's attributes to + //avoid double deletion on the node destruction + if(_node) { + map::iterator mi; + for(mi =_node->_attributes.begin(); mi != _node->_attributes.end(); mi++) { + if(mi->second == this) { + _node->_attributes.erase(mi); + } + } + } +} + + //Returns a Label on which this Attribute is located. +DF_Label DF_Attribute::Label() const +{ + return DF_Label(_node); +} + + //Searches an Attribute with given ID located on the same Label as this Attribute. +DF_Attribute* DF_Attribute::FindAttribute(const string& theID) const +{ + if(!_node) return NULL; + return Label().FindAttribute(theID); +} + + diff --git a/src/DF/DF_Attribute.hxx b/src/DF/DF_Attribute.hxx new file mode 100644 index 000000000..5d2e65da3 --- /dev/null +++ b/src/DF/DF_Attribute.hxx @@ -0,0 +1,60 @@ +#ifndef DFATTRIBUTE_HXX +#define DFATTRIBUTE_HXX + +#include "DF_definitions.hxx" +#include + +class DF_Label; +class DF_LabelNode; + +//Class DF_Attribute is used to store some data defined by the DF_Attribute type +class DF_Attribute { +protected: + DF_LabelNode* _node; + +public: + //Constructor + Standard_EXPORT DF_Attribute(); + + Standard_EXPORT virtual ~DF_Attribute(); + + //Returns a Label on which this Attribute is located. + Standard_EXPORT DF_Label Label() const; + + //Searches an Attribute with given ID located on the same Label as this Attribute. + Standard_EXPORT DF_Attribute* FindAttribute(const std::string& theID) const; + + + Standard_EXPORT virtual std::string Save() { return ""; } + Standard_EXPORT virtual void Load(const std::string&) {} + + //######## Virtual methods that must be redefined in descendants of the DF_Attribute + + //This method must be redefined in all descendents of the DF_Attribute + //ID is a std::string that uniquely identify the given type of Attributes within the Application. + Standard_EXPORT virtual const std::string& ID() const = 0; + + //Restores a content of this Attribute from another Attribute + Standard_EXPORT virtual void Restore(DF_Attribute* theAttribute) = 0; + + //Creates a new empty copy oà this Attribute + Standard_EXPORT virtual DF_Attribute* NewEmpty() const = 0; + + //Pastes a content of this Attribute into another Attribute + Standard_EXPORT virtual void Paste(DF_Attribute* theIntoAttribute) = 0; + + + //######## Callbacks + + Standard_EXPORT virtual void AfterAddition() {} + Standard_EXPORT virtual void BeforeForget() {} + +protected: + void Backup() {} + + +friend class DF_Label; + +}; + +#endif diff --git a/src/DF/DF_ChildIterator.cxx b/src/DF/DF_ChildIterator.cxx new file mode 100644 index 000000000..fe4573bcb --- /dev/null +++ b/src/DF/DF_ChildIterator.cxx @@ -0,0 +1,80 @@ +#include "DF_ChildIterator.hxx" + +using namespace std; + + +//Constructor +DF_ChildIterator::DF_ChildIterator(const DF_Label& theLabel, bool allLevels) + :_root(NULL), _current(NULL) +{ + Init(theLabel, allLevels); +} + +DF_ChildIterator::DF_ChildIterator() + :_root(NULL), _current(NULL) +{ +} + +DF_ChildIterator::~DF_ChildIterator() +{ + _root = NULL; + _current = NULL; +} + +//Initializes the iterator +void DF_ChildIterator::Init(const DF_Label& theLabel, bool allLevels) +{ + _root = theLabel._node; + _allLevels = allLevels; + if(_root) _current = _root->_firstChild; +} + +//Returns a current Label +DF_Label DF_ChildIterator::Value() +{ + return DF_Label(_current); +} + +//Returns true if there is a current Label +bool DF_ChildIterator::More() +{ + return bool(_current); +} + +//Moves to the next Label +void DF_ChildIterator::Next() +{ + if(!_allLevels) { + _current = _current->_next; //Move to the next brother + return; + } + else { + if(_current->_firstChild) { //Go down to the first child + _current = _current->_firstChild; + } + else { + if(_current->_next) { //Next Brother + _current = _current->_next; + } + else { + if(_current->_father && _current->_father != _root) { + DF_LabelNode *father = _current->_father; + _current = father->_next; + if(!_current) { + while(father && father != _root) { + father = father->_father; + if(father->_next) break; + } + if(father == _root) father = NULL; + if(father) _current = father->_next; + else _current = NULL; + } + } + else { + _current = NULL; //We iterate the whole sub tree + } + } + } + } +} + diff --git a/src/DF/DF_ChildIterator.hxx b/src/DF/DF_ChildIterator.hxx new file mode 100644 index 000000000..54e5ed6bc --- /dev/null +++ b/src/DF/DF_ChildIterator.hxx @@ -0,0 +1,38 @@ +#ifndef DFCHILDITERATOR_HXX +#define DFCHILDITERATOR_HXX + +#include "DF_definitions.hxx" +#include "DF_Label.hxx" + +#include + +//Class DF_ChildIterator is used to iterate a tree of Labels in the Document +class DF_ChildIterator { +public: + //Constructor + Standard_EXPORT DF_ChildIterator(const DF_Label& theLabel, bool allLevels = false); + + Standard_EXPORT DF_ChildIterator(); + + Standard_EXPORT ~DF_ChildIterator(); + + //Initializes the iterator, if allLevels is true the iterator before iterating the next + //brother of the current Label iterates the Label children + Standard_EXPORT void Init(const DF_Label& theLabel, bool allLevels = false); + + //Returns a current Label + Standard_EXPORT DF_Label Value(); + + //Returns true if there is a current Label + Standard_EXPORT bool More(); + + //Moves to the next Label + Standard_EXPORT void Next(); + +private: + DF_LabelNode* _root; + DF_LabelNode* _current; + bool _allLevels; +}; + +#endif diff --git a/src/DF/DF_Container.cxx b/src/DF/DF_Container.cxx new file mode 100644 index 000000000..d5f056486 --- /dev/null +++ b/src/DF/DF_Container.cxx @@ -0,0 +1,196 @@ +#include "DF_definitions.hxx" +#include "DF_Label.hxx" +#include "DF_Container.hxx" + +using namespace std; + +//Static method that returns an ID of the give type of attributes +const string& DF_Container::GetID() +{ + static string id = "DF_Container_srn"; + return id; +} + +//Creates if not exists a Container attribute and places if is not placed it the Label +DF_Container* DF_Container::Set(DF_Label& theLabel) +{ + DF_Attribute* attr = NULL; + if(!(attr = theLabel.FindAttribute(DF_Container::GetID()))) { + attr = new DF_Container; + theLabel.AddAttribute(attr); + } + + return dynamic_cast(attr); +} + +//Constructor +DF_Container::DF_Container() +{ + _ints.clear(); + _doubles.clear(); + _bools.clear(); + _strings.clear(); +} + +//Destructor +DF_Container::~DF_Container() +{ + _ints.clear(); + _doubles.clear(); + _bools.clear(); + _strings.clear(); +} + +//Sets an integer value of the attribute with given ID +void DF_Container::SetInt(const string& theID, int theValue) +{ + _ints[theID] = theValue; +} + +//Returns an integer value of the attribute with given ID +int DF_Container::GetInt(const string& theID) +{ + if(!HasIntID(theID)) + return 0; + return _ints[theID]; +} + +//Returns True if there is an integer with given ID +bool DF_Container::HasIntID(const string& theID) +{ + if(_ints.find(theID) != _ints.end()) return true; + return false; +} + +//Sets a double value of the attribute with given ID +void DF_Container::SetDouble(const string& theID, const double& theValue) +{ + _doubles[theID] = theValue; +} + + +//Returns a double value of the attribute with given ID +double DF_Container::GetDouble(const string& theID) +{ + if(!HasDoubleID(theID)) return 0.0; + return _doubles[theID]; +} + +//Returns True if there is a double with given ID +bool DF_Container::HasDoubleID(const string& theID) +{ + if(_doubles.find(theID) != _doubles.end()) return true; + return false; +} + +//Sets a string value of the attribute with given ID +void DF_Container::SetString(const string& theID, const string& theValue) +{ + _strings[theID] = theValue; +} + +//Returns a string value of the attribute with given ID +string DF_Container::GetString(const string& theID) +{ + if(!HasStringID(theID)) return ""; + return _strings[theID]; +} + +//Returns True if there is a string with given ID +bool DF_Container::HasStringID(const string& theID) +{ + if(_strings.find(theID) != _strings.end()) return true; + return false; +} + +//Sets a boolean value of the attribute with given ID +void DF_Container::SetBool(const string& theID, bool theValue) +{ + _bools[theID] = theValue; +} + +//Returns a boolean value of the attribute with given ID +bool DF_Container::GetBool(const string& theID) +{ + if(!HasBoolID(theID)) return false; + return _bools[theID]; +} + +//Returns True if there is a boolean value with given ID +bool DF_Container::HasBoolID(const string& theID) +{ + if(_bools.find(theID) != _bools.end()) return true; + return false; +} + +//Clears a content of the attribute +void DF_Container::Clear() +{ + _ints.clear(); + _doubles.clear(); + _strings.clear(); + _bools.clear(); +} + +//ID is a string that uniquely identify the given type of Attributes within the Application. +const string& DF_Container::ID() const +{ + return GetID(); +} + +//Restores a content of this Attribute from another Attribute +void DF_Container::Restore(DF_Attribute* theAttribute) +{ + Clear(); + + DF_Container* attr = dynamic_cast(theAttribute); + if(!attr) return; + + typedef map::const_iterator SI; + for(SI p = attr->_ints.begin(); p != attr->_ints.end(); p++) + _ints[p->first] = p->second; + + typedef map::const_iterator SD; + for(SD p = attr->_doubles.begin(); p != attr->_doubles.end(); p++) + _doubles[p->first] = p->second; + + typedef map::const_iterator SS; + for(SS p = attr->_strings.begin(); p != attr->_strings.end(); p++) + _strings[p->first] = p->second; + + typedef map::const_iterator SB; + for(SB p = attr->_bools.begin(); p != attr->_bools.end(); p++) + _bools[p->first] = p->second; +} + +//Creates a new empty copy oà this Attribute +DF_Attribute* DF_Container::NewEmpty() const +{ + return new DF_Container(); +} + +//Pastes a content of this Attribute into another Attribute +void DF_Container::Paste(DF_Attribute* theIntoAttribute) +{ + DF_Container* attr = dynamic_cast(theIntoAttribute); + if(!attr) return; + + attr->Clear(); + + typedef map::const_iterator SI; + for(SI p = _ints.begin(); p != _ints.end(); p++) + attr->_ints[p->first] = p->second; + + typedef map::const_iterator SD; + for(SD p = _doubles.begin(); p != _doubles.end(); p++) + attr->_doubles[p->first] = p->second; + + typedef map::const_iterator SS; + for(SS p = _strings.begin(); p != _strings.end(); p++) + attr->_strings[p->first] = p->second; + + typedef map::const_iterator SB; + for(SB p = _bools.begin(); p != _bools.end(); p++) + attr-> _bools[p->first] = p->second; +} + diff --git a/src/DF/DF_Container.hxx b/src/DF/DF_Container.hxx new file mode 100644 index 000000000..f26ce8d9e --- /dev/null +++ b/src/DF/DF_Container.hxx @@ -0,0 +1,85 @@ +#ifndef DFCONTAINER_HXX +#define DFCONTAINER_HXX + +#include "DF_definitions.hxx" +#include "DF_Attribute.hxx" +#include +#include + +//Class DF_Container is used to store several types of data +class DF_Container : public DF_Attribute +{ +public: + + //Static method that returns an ID of the give type of attributes + Standard_EXPORT static const std::string& GetID(); + + //Creates if not exists a Container attribute and places if is not placed it the Label + Standard_EXPORT static DF_Container* Set(DF_Label& theLabel); + + //Constructor + Standard_EXPORT DF_Container(); + + //Destructor + Standard_EXPORT ~DF_Container(); + + //Sets an integer value of the attribute with given ID + Standard_EXPORT void SetInt(const std::string& theID, int theValue); + + //Returns an integer value of the attribute with given ID + Standard_EXPORT int GetInt(const std::string& theID); + + //Returns True if there is an integer with given ID + Standard_EXPORT bool HasIntID(const std::string& theID); + + //Sets a double value of the attribute with given ID + Standard_EXPORT void SetDouble(const std::string& theID, const double& theValue); + + //Returns a double value of the attribute with given ID + Standard_EXPORT double GetDouble(const std::string& theID); + + //Returns True if there is a double with given ID + Standard_EXPORT bool HasDoubleID(const std::string& theID); + + //Sets a string value of the attribute with given ID + Standard_EXPORT void SetString(const std::string& theID, const std::string& theValue); + + //Returns a string value of the attribute with given ID + Standard_EXPORT std::string GetString(const std::string& theID); + + //Returns True if there is a string with given ID + Standard_EXPORT bool HasStringID(const std::string& theID); + + //Sets a boolean value of the attribute with given ID + Standard_EXPORT void SetBool(const std::string& theID, bool theValue); + + //Returns a boolean value of the attribute with given ID + Standard_EXPORT bool GetBool(const std::string& theID); + + //Returns True if there is a boolean value with given ID + Standard_EXPORT bool HasBoolID(const std::string& theID); + + //Clears a content of the attribute + Standard_EXPORT void Clear(); + + //ID is a std::string that uniquely identify the given type of Attributes within the Application. + Standard_EXPORT virtual const std::string& ID() const; + + //Restores a content of this Attribute from another Attribute + Standard_EXPORT virtual void Restore(DF_Attribute* theAttribute); + + //Creates a new empty copy of this Attribute + Standard_EXPORT virtual DF_Attribute* NewEmpty() const; + + //Pastes a content of this Attribute into another Attribute + Standard_EXPORT virtual void Paste(DF_Attribute* theIntoAttribute); + + +protected: + std::map _ints; + std::map _doubles; + std::map _strings; + std::map _bools; +}; + +#endif diff --git a/src/DF/DF_Document.cxx b/src/DF/DF_Document.cxx new file mode 100644 index 000000000..47b9516e7 --- /dev/null +++ b/src/DF/DF_Document.cxx @@ -0,0 +1,125 @@ +#include "DF_definitions.hxx" +#include "DF_Document.hxx" +#include "DF_Label.hxx" +#include "DF_ChildIterator.hxx" + +using namespace std; + +//Class DF_Document is container for user's data stored as a tree of Labels +//with assigned Attributes + +DF_Document::DF_Document(const string& theDocumentType) +{ + _id = -1; + _type = theDocumentType; + _modified = true; +} + +DF_Document::~DF_Document() +{ + Clear(); +} + +DF_Application* DF_Document::GetApplication() +{ + return _appli; +} + +//Returns a Label of this Document with entry "0:1" +DF_Label DF_Document::Main() +{ + if(!_main.IsNull()) return _main; + + if(_root.IsNull()) { + _root = DF_Label(new DF_LabelNode()); + _root._node->_document = this; + } + + _main = _root.FindChild(1, true); + + return _main; +} + +//Returns a Label of this Document with entry "0:" +DF_Label DF_Document::Root() +{ + if(!_root.IsNull()) return _root; + + if(_root.IsNull()) { + _root = DF_Label(new DF_LabelNode()); + _root._node->_document = this; + } + + return _root; +} + + +//Returns an ID of this +int DF_Document::GetDocumentID() const +{ + return _id; +} + +//Returns a type of the Document +string DF_Document::GetDocumentType() +{ + return _type; +} + +//Clears the content of this Document +void DF_Document::Clear() +{ + if(_root.IsNull()) return; + + vector vn; + DF_ChildIterator CI(_root, true); + for(; CI.More(); CI.Next()) { + DF_LabelNode* node = CI.Value()._node; + if(node) vn.push_back(node); + } + + for(int i = 0, len = vn.size(); iReset(); +} + +//Returns true if this document is empty +bool DF_Document::IsEmpty() +{ + if(_root.IsNull()) return true; + + DF_ChildIterator CI(_root, true); + for(; CI.More(); CI.Next()) { + DF_LabelNode* node = CI.Value()._node; + if(node->_attributes.size()) return false; + } + + return true; +} + +//Returns true if this document is modified +bool DF_Document::IsModified() +{ + return _modified; +} + +//Sets whether a document is modified +void DF_Document::SetModified(bool isModified) +{ + _modified = isModified; +} + + +//Restores a content of the Document from the std::string theData +void DF_Document::Load(const std::string& theData) +{ + //Not implemented +} + +//Converts a content of the Document into the std::string +string DF_Document::Save() +{ + //Not implemented + return ""; +} diff --git a/src/DF/DF_Document.hxx b/src/DF/DF_Document.hxx new file mode 100644 index 000000000..de51652ae --- /dev/null +++ b/src/DF/DF_Document.hxx @@ -0,0 +1,65 @@ +#ifndef DFDOCUMENT_HXX +#define DFDOCUMENT_HXX + +#include "DF_definitions.hxx" +#include "DF_Label.hxx" + +#include + +class DF_Application; + +//Class DF_Document is container for user's data stored as a tree of Labels +//with assigned Attributes +class DF_Document { +public: + //Constructor + Standard_EXPORT DF_Document(const std::string& theDocumentType); + + Standard_EXPORT ~DF_Document(); + + Standard_EXPORT DF_Application* GetApplication(); + + //Returns a Label of this Document with entry "0:1" + Standard_EXPORT DF_Label Main(); + + //Returns a root Label with entry "0:" + Standard_EXPORT DF_Label Root(); + + //Returns an ID of this + Standard_EXPORT int GetDocumentID() const; + + //Returns a type of the Document + Standard_EXPORT std::string GetDocumentType(); + + //Clears the content of this Document + Standard_EXPORT void Clear(); + + //Returns true if this document is empty + Standard_EXPORT bool IsEmpty(); + + //Returns true if this document is modified + Standard_EXPORT bool IsModified(); + + //Returns true if this document is modified + Standard_EXPORT void SetModified(bool isModified); + + //########### Load/Save virtual methods ## + + //Restores a content of the Document from the std::string theData + Standard_EXPORT virtual void Load(const std::string& theData); + + //Converts a content of the Document into the std::string + Standard_EXPORT virtual std::string Save(); + + friend class DF_Application; + +private: + DF_Label _main; + DF_Label _root; + std::string _type; + int _id; + bool _modified; + DF_Application* _appli; +}; + +#endif diff --git a/src/DF/DF_Label.cxx b/src/DF/DF_Label.cxx new file mode 100644 index 000000000..b44b19bf9 --- /dev/null +++ b/src/DF/DF_Label.cxx @@ -0,0 +1,463 @@ +#include "DF_definitions.hxx" +#include "DF_Label.hxx" +#include "DF_Document.hxx" +#include "DF_Attribute.hxx" +#include "DF_ChildIterator.hxx" + +#include + +using namespace std; + +//Class DF_Label defines a persistence reference in DF_Document that contains a tree of Labels. +//This reference is named "entry" and is a sequence of tags divided by ":". The root entry is "0:". +//For example "0:1:1" corresponds the following structure +// 0_ +// | +// |_1_ +// | +// |_ 1 + +DF_Label DF_Label::Label(const DF_Label& theLabel, const string& theEntry, bool isCreated) +{ + if(theLabel.IsNull()) return DF_Label(); + + DF_Label aLabel = theLabel.Root(); + if(theEntry == "0:") return aLabel; + if(theEntry == "0:1") return theLabel.GetDocument()->Main(); + + char* cc = (char*)theEntry.c_str(); + int n = 0; + vector tags; + + while (*cc != '\0') { + while ( *cc >= '0' && *cc <= '9') { + n = 10*n + (*cc - '0'); + ++cc; + } + if (*cc == ':' || *cc == '\0') { + tags.push_back(n); + n = 0; + if (*cc != '\0') ++cc; + } + else { + tags.clear(); + break; + } + } + + if(!tags.size()) return DF_Label(); + + for(int i = 1, len = tags.size(); !aLabel.IsNull() && i_document; +} + +//Returns true if theLabel equals to this label +bool DF_Label::operator==(const DF_Label& theLabel) +{ + if(IsNull() || theLabel.IsNull()) return false; + return (theLabel.Entry() == Entry()); +} + +//Returns true if theLabel doesn't equals to this label +bool DF_Label::operator!=(const DF_Label& theLabel) +{ + if(IsNull() || theLabel.IsNull()) return true; + return (theLabel.Entry() != Entry()); +} + + +//Returns a tag of this Label +int DF_Label::Tag() const +{ + if(!_node) return -1; + return _node->_tag; +} + +//Returns true if this Label is attached to the tree in the Document. +bool DF_Label::IsAttached() +{ + if(!_node) return false; + return (bool)(_node->_document); +} + +//Searches an Attribute with given ID located on this Label. +//Returns true if the Attribute is found. +DF_Attribute* DF_Label::FindAttribute(const std::string& theID) const +{ + if(!_node) return NULL; + + if(_node->_attributes.find(theID) == _node->_attributes.end()) return NULL; + return _node->_attributes[theID]; +} + +//Returns true if there is an Attribute with given ID on this Label. +bool DF_Label::IsAttribute(const std::string& theID) const +{ + if(!_node) return false; + + return (_node->_attributes.find(theID) != _node->_attributes.end()); +} + +//Adds theAttribute to the Label where this Attribute is located. +//Returns true if theAttribute was added. +bool DF_Label::AddAttribute(DF_Attribute* theAttribute) const +{ + if(!_node) return false; + + if(_node->_attributes.find(theAttribute->ID()) != _node->_attributes.end()) return false; + theAttribute->_node = _node; + _node->_attributes[theAttribute->ID()] = theAttribute; + + return true; +} + +//Forgets an Attribute with given ID located on the this Label. +bool DF_Label::ForgetAttribute(const std::string& theID) const +{ + if(!_node) return false; + + if(_node->_attributes.find(theID) == _node->_attributes.end()) return false; + DF_Attribute* attr = _node->_attributes[theID]; + _node->_attributes.erase(theID); + delete attr; + + return true; +} + +//Forgets all Attributes located on this Label. +bool DF_Label::ForgetAllAttributes(bool clearChildren) const +{ + if(!_node) return false; + + vector va = GetAttributes(); + _node->_attributes.clear(); + + for(int i = 0, len = va.size(); i_father; +} + +//Returns is this Label is not initialized +bool DF_Label::IsNull() const +{ + return (!_node || (_node->_document == NULL)); +} + +//Returns is this Label is a Root label +bool DF_Label::IsRoot() const +{ + if(IsNull() || Father().IsNull()) return true; + return false; +} + + +//Returns true if this Label has Attributes. +bool DF_Label::HasAttributes() const +{ + if(!_node) return false; + + return !(_node->_attributes.empty()); +} + +//Returns a list of Attributes of this Label. +vector DF_Label::GetAttributes() const +{ + vector attributes; + if(!_node) return attributes; + + typedef map::const_iterator AI; + vector sorted; + for(AI p = _node->_attributes.begin(); p!=_node->_attributes.end(); p++) + sorted.push_back(p->first); + + sort(sorted.begin(), sorted.end()); + int len = sorted.size(); + for(int i = 0; i_attributes[sorted[i]]); + + return attributes; +} + +//Returns true if this Label has a child Label. +bool DF_Label::HasChild() const +{ + if(!_node) return false; + + return (bool)(_node->_firstChild); +} + +//Returns a number of child Labels. +int DF_Label::NbChildren() const +{ + if(!_node) return -1; + + if(!_node->_firstChild) return 0; + int nb = 1; + DF_LabelNode* next = _node->_firstChild->_next; + while(next) { + nb++; + next = next->_next; + } + + return nb; +} + +//Returns the depth (a number of fathers required to identify the Label) of this Label in the tree. +int DF_Label::Depth() const +{ + if(!_node) return -1; + + return _node->_depth; +} + +//Returns true if this Label is a descendant of theLabel. +bool DF_Label::IsDescendant(const DF_Label& theLabel) +{ + if(!_node) return false; + + DF_LabelNode* father = _node->_father; + if(!father) return false; + + while(father) { + if(father == theLabel._node) return true; + father = father->_father; + } + + return false; +} + +//Returns the root Label of a Label tree to which this Label belongs. +DF_Label DF_Label::Root() const +{ + if(!_node) return DF_Label(); + + return _node->_document->Main().Father(); +} + +//Finds a child Label of this Label with a given tag. If isCreate = true and there is no child +//Label with the given tag, the child Label is created. +DF_Label DF_Label::FindChild(int theTag, bool isCreate) +{ + if(!_node || IsNull()) return DF_Label(); + + DF_LabelNode *aLabel = NULL, *aPrevious = NULL, *aNext = NULL; + if(!_node->_firstChild && !isCreate) return DF_Label(); + + aLabel = _node->_firstChild; + while(aLabel) { + if(aLabel->_tag == theTag) return DF_Label(aLabel); + if(aLabel->_tag > theTag) { + aNext = aLabel; + break; + } + if(aLabel->_tag < theTag) aPrevious = aLabel; + aLabel = aLabel->_next; + } + + if(!isCreate) return DF_Label(); + + DF_LabelNode* aChild = new DF_LabelNode(); + aChild->_father = this->_node; + aChild->_document = _node->_document; + aChild->_tag = theTag; + aChild->_depth = _node->_depth+1; + if(aNext) { + aChild->_previous = aNext->_previous; + aChild->_next = aNext; + aNext->_previous = aChild; + } + if(aPrevious) { + aChild->_previous = aPrevious; + aChild->_next = aPrevious->_next; + aPrevious->_next = aChild; + } + + if(!_node->_firstChild || (aNext && aNext == _node->_firstChild) ) _node->_firstChild = aChild; + if(!_node->_lastChild && !aNext) _node->_lastChild = aChild; + + return aChild; +} + +//Creates a new child Label of this Label. +DF_Label DF_Label::NewChild() +{ + if(!_node || IsNull()) return DF_Label(); + + int tag = 1; + if(_node->_lastChild) tag = _node->_lastChild->_tag+1; + + return FindChild(tag, true); +} + +//Returns a string entry of this Label +string DF_Label::Entry() const +{ + string entry = ""; + vector vi; + DF_LabelNode* father = this->_node; + while(father) { + vi.push_back(father->_tag); + father = father->_father; + } + + int len = vi.size(); + if(len == 1) { + entry = "0:"; + } + else { + char buffer[128]; + for(int i = len-1; i>=0; i--) { + int tag = vi[i]; + sprintf(buffer, "%d", tag); + entry+=string(buffer); + if(i) entry += ":"; + } + } + + return entry; +} + +bool DF_Label::IsEqual(const DF_Label& theLabel) +{ + if(theLabel.IsNull() || IsNull()) return false; + DF_Label L(theLabel); + return (L.Entry() == Entry()); +} + + +void DF_Label::Nullify() +{ + delete _node; + _node = NULL; +} + +void DF_Label::dump() +{ + if(!_node) cout << "DF_Label addr : " << this << " NULL " << endl; + else { + cout << "DF_Label addr : " << this->_node << " entry : " << Entry() << endl; + if(_node->_father) cout << " Father : " << _node->_father << " entry : " << Father().Entry() << endl; + else cout << " Father : NULL " << endl; + + if(_node->_firstChild) cout << " FirstChild : " << _node->_firstChild << " entry : " << DF_Label(_node->_firstChild).Entry() << endl; + else cout << " FirstChild : NULL " << endl; + + if(_node->_lastChild) cout << " LastChild : " << _node->_lastChild << " entry : " << DF_Label(_node->_lastChild).Entry() << endl; + else cout << " LastChild : NULL " << endl; + + if(_node->_previous) cout << " Previous : " << _node->_previous << " entry : " << DF_Label(_node->_previous).Entry() << endl; + else cout << " Previous : NULL " << endl; + + if(_node->_next) cout << " Next : " << _node->_next << " entry : " << DF_Label(_node->_next).Entry() << endl; + else cout << " Next : NULL " << endl; + } +} + + +/* + ############################################### + DF_LabelNode methods + ############################################### +*/ + +DF_LabelNode::DF_LabelNode() +{ + _depth = 0; + _tag = 0; + _attributes.clear(); + _document = NULL; + _father = NULL; + _firstChild = NULL; + _lastChild = NULL; + _previous = NULL; + _next = NULL; +} + +DF_LabelNode::~DF_LabelNode() +{ + vector va; + typedef map::const_iterator AI; + for(AI p = _attributes.begin(); p!=_attributes.end(); p++) + va.push_back(p->second); + + for(int i = 0, len = va.size(); i va; + typedef map::const_iterator AI; + for(AI p = _attributes.begin(); p!=_attributes.end(); p++) + va.push_back(p->second); + + for(int i = 0, len = va.size(); i +#include +#include + +class DF_Document; + + +class DF_LabelNode +{ +public: + DF_LabelNode(); + ~DF_LabelNode(); + void Reset(); +private: + int _tag; + int _depth; + DF_LabelNode* _father; + DF_LabelNode* _previous; + DF_LabelNode* _next; + DF_LabelNode* _firstChild; + DF_LabelNode* _lastChild; + DF_Document* _document; + std::map< std::string, DF_Attribute* > _attributes; + + friend class DF_Document; + friend class DF_Label; + friend class DF_ChildIterator; + friend class DF_Attribute; +}; + +//Class DF_Label defines a persistence reference in DF_Document that contains a tree of Labels. +//This reference is named "entry" and is a sequence of tags divided by ":". The root entry is "0:". +//For example "0:1:1" corresponds the following structure +// 0_ +// | +// |_1_ +// | +// |_ 1 + +class DF_Label { +public: + + //Returns a Label by its entry, if isCreated true the Label will be created if not exists + Standard_EXPORT static DF_Label Label(const DF_Label& theLabel, const std::string& theEntry, bool isCreated = true); + + //Constructors: creates a root label + Standard_EXPORT DF_Label(); + + //Copy constructor + Standard_EXPORT DF_Label(const DF_Label& theLabel); + + //Creates a Label from the LabelNode + Standard_EXPORT DF_Label(DF_LabelNode* theNode); + + //Operator = + Standard_EXPORT DF_Label& operator=(const DF_Label& theLabel); + + //Destructor + Standard_EXPORT ~DF_Label(); + + //Returns a smart pointer to Document which contains this Label + Standard_EXPORT DF_Document* GetDocument() const; + + //Returns true if theLabel equals to this label + Standard_EXPORT bool operator==(const DF_Label& theLabel); + + //Returns true if theLabel doesn't equals to this label + Standard_EXPORT bool operator!=(const DF_Label& theLabel); + + //Returns a tag of this Label + Standard_EXPORT int Tag() const; + + //Returns true if this Label is attached to the tree in the Document. + Standard_EXPORT bool IsAttached(); + + //Searches an Attribute with given ID located on this Label. + //Returns true if the Attribute is found. + Standard_EXPORT DF_Attribute* FindAttribute(const std::string& theID) const; + + //Returns true if there is an Attribute with given ID on this Label. + Standard_EXPORT bool IsAttribute(const std::string& theID) const; + + //Adds theAttribute to the Label where this Attribute is located. + //Returns true if theAttribute was added. + Standard_EXPORT bool AddAttribute(DF_Attribute* theAttribute) const; + + //Forgets an Attribute with given ID located on the this Label. + Standard_EXPORT bool ForgetAttribute(const std::string& theID) const; + + //Forgets all Attributes located on this Label. + Standard_EXPORT bool ForgetAllAttributes(bool clearChildren = true) const; + + //Returns Father of this Label. + Standard_EXPORT DF_Label Father() const; + + //Return true if the label is not initialized + Standard_EXPORT bool IsNull() const; + + //Return true if the label is a Root label + Standard_EXPORT bool IsRoot() const; + + //Returns true if this Label has Attributes. + Standard_EXPORT bool HasAttributes() const; + + //Returns a list of Attributes of this Label. + Standard_EXPORT std::vector GetAttributes() const; + + //Returns true if this Label has a child Label. + Standard_EXPORT bool HasChild() const; + + //Returns a number of child Labels. + Standard_EXPORT int NbChildren() const; + + //Returns the depth (a number of fathers required to identify the Label) of this Label in the tree. + Standard_EXPORT int Depth() const; + + //Returns true if this Label is a descendant of theLabel. + Standard_EXPORT bool IsDescendant(const DF_Label& theLabel); + + //Returns the root Label of a Label tree to which this Label belongs. + Standard_EXPORT DF_Label Root() const; + + //Finds a child Label of this Label with a given tag. If isCreate = true and there is no child + //Label with the given tag, the child Label is created. + Standard_EXPORT DF_Label FindChild(int theTag, bool isCreate = true); + + //Creates a new child Label of this Label. + Standard_EXPORT DF_Label NewChild(); + + //Returns a string presentation of the entry + Standard_EXPORT std::string Entry() const; + + //Returns true if theLabel is the same as me + Standard_EXPORT bool IsEqual(const DF_Label& theLabel); + + Standard_EXPORT void dump(); + +private: + //Nullifies the content of the label + void Nullify(); + +friend class DF_Document; +friend class DF_ChildIterator; + +private: + DF_LabelNode* _node; +}; + +#endif diff --git a/src/DF/DF_definitions.hxx b/src/DF/DF_definitions.hxx new file mode 100644 index 000000000..816839cfa --- /dev/null +++ b/src/DF/DF_definitions.hxx @@ -0,0 +1,125 @@ +// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// +#ifndef DF_DEF_HXX +#define DF_DEF_HXX + +#ifdef WIN32 +# ifdef DF_EXPORTS +# define DF_EXPORT __declspec( dllexport ) +# else +# define DF_EXPORT __declspec( dllimport ) +# endif +#else +# define DF_EXPORT +#endif + +#include +#include +#include + +template class df_shared_ptr: public boost::shared_ptr +{ +public: + df_shared_ptr() {} + + template + explicit df_shared_ptr(Y * p) + { + boost::shared_ptr::reset(p); + } + + template + df_shared_ptr(df_shared_ptr const & r): + boost::shared_ptr(r,boost::detail::dynamic_cast_tag()) + {} + + template + df_shared_ptr & operator=(df_shared_ptr const & r) + { + df_shared_ptr(r).swap(*this); + return *this; + } + + template df_shared_ptr& operator()(Y * p) // Y must be complete + { + if(T* pt = dynamic_cast(p)) + boost::shared_ptr::reset(pt); + else + boost::throw_exception(std::bad_cast()); + return *this; + } + +}; + +# if defined(WNT) && !defined(HAVE_NO_DLL) + +# ifndef Standard_EXPORT +# define Standard_EXPORT __declspec( dllexport ) +// For global variables : +# define Standard_EXPORTEXTERN __declspec( dllexport ) extern +# define Standard_EXPORTEXTERNC extern "C" __declspec( dllexport ) +# endif /* Standard_EXPORT */ + +# ifndef Standard_IMPORT +# define Standard_IMPORT __declspec( dllimport ) extern +# define Standard_IMPORTC extern "C" __declspec( dllimport ) +# endif /* Standard_IMPORT */ + +# else /* WNT */ + +# ifndef Standard_EXPORT +# define Standard_EXPORT +// For global variables : +# define Standard_EXPORTEXTERN extern +# define Standard_EXPORTEXTERNC extern "C" +# endif /* Standard_EXPORT */ + +# ifndef Standard_IMPORT +# define Standard_IMPORT extern +# define Standard_IMPORTC extern "C" +# endif /* Standard_IMPORT */ + +# endif /* WNT */ + +# ifndef __Standard_API +//# ifdef WNT +# if !defined(WNT) +# define __Standard_API Standard_EXPORT +# define __Standard_APIEXTERN Standard_EXPORTEXTERN +# else +# define __Standard_API Standard_IMPORT +# define __Standard_APIEXTERN Standard_IMPORT +# endif // __Standard_DLL +//# else +//# define __Standard_API +//# endif // WNT +# endif // __Standard_API + +#include +class Standard_EXPORT DFexception +{ +public : + DFexception(const char *message) { + std::cerr << message << std::endl; + } +}; + + +#endif diff --git a/src/DF/Makefile.am b/src/DF/Makefile.am new file mode 100644 index 000000000..5f494ae92 --- /dev/null +++ b/src/DF/Makefile.am @@ -0,0 +1,100 @@ +# Copyright (C) 2005 OPEN CASCADE, CEA, EDF R&D, LEG +# PRINCIPIA R&D, EADS CCR, Lip6, BV, CEDRAT +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +# File : Makefile.am +# Author : Guillaume Boulant (CSSI) +# Module : KERNEL + +include $(top_srcdir)/salome_adm/unix/make_common_starter.am + +# +# =============================================================== +# Files to be installed +# =============================================================== +# +# header files +salomeinclude_HEADERS= \ + DF_Attribute.hxx \ + DF_Label.hxx \ + DF_Application.hxx \ + DF_Document.hxx \ + DF_ChildIterator.hxx \ + DF_Container.hxx \ + DF_definitions.hxx + +# +# =============================================================== +# Local definitions +# =============================================================== +# + +# This local variable defines the list of CPPFLAGS common to all target in this package. +COMMON_CPPFLAGS=\ + @CAS_CPPFLAGS@ @CAS_CXXFLAGS@ \ + -I$(srcdir)/../Basics \ + -I$(srcdir)/../SALOMELocalTrace \ + -I$(srcdir)/../HDFPersist \ + @HDF5_INCLUDES@ + +# This flag is used to resolve the dependencies of OCC libraries. +LDXMUFLAGS = -L/usr/X11R6/lib@LIB_LOCATION_SUFFIX@ -lXmu + +# This local variable defines the list of dependant libraries common to all target in this package. +COMMON_LIBS =\ + ../HDFPersist/libSalomeHDFPersist.la \ + @CAS_OCAF@ \ + @HDF5_LIBS@ \ + $(LDXMUFLAGS) + + +# +# =============================================================== +# Libraries targets +# =============================================================== +# +lib_LTLIBRARIES = libDF.la +libDF_la_SOURCES = \ + DF_Attribute.cxx \ + DF_Label.cxx \ + DF_Document.cxx \ + DF_Application.cxx \ + DF_ChildIterator.cxx \ + DF_Container.cxx \ +\ + DF_Attribute.hxx \ + DF_Label.hxx \ + DF_Application.hxx \ + DF_Document.hxx \ + DF_ChildIterator.hxx \ + DF_Container.hxx \ + DF_definitions.hxx + +libDF_la_CPPFLAGS = $(COMMON_CPPFLAGS) +libDF_la_LDFLAGS = -no-undefined -version-info=0:0:0 +libDF_la_LIBADD = $(COMMON_LIBS) + +# +# =============================================================== +# Executables targets +# =============================================================== +# +bin_PROGRAMS = testDF +testDF_SOURCES = testDF.cxx +testDF_CPPFLAGS = $(COMMON_CPPFLAGS) +testDF_LDADD = libDF.la $(COMMON_LIBS) + diff --git a/src/DF/Makefile.in b/src/DF/Makefile.in new file mode 100644 index 000000000..9ee743c94 --- /dev/null +++ b/src/DF/Makefile.in @@ -0,0 +1,890 @@ +# Makefile.in generated by automake 1.9 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004 Free Software Foundation, Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# Copyright (C) 2005 OPEN CASCADE, CEA, EDF R&D, LEG +# PRINCIPIA R&D, EADS CCR, Lip6, BV, CEDRAT +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +# File : Makefile.am +# Author : Guillaume Boulant (CSSI) +# Module : KERNEL + +# +# ============================================================ +# This file defines the common definitions used in several +# Makefile. This file must be included, if needed, by the file +# Makefile.am. +# ============================================================ +# + + + +SOURCES = $(libDF_la_SOURCES) $(testDF_SOURCES) + +srcdir = @srcdir@ +top_srcdir = @top_srcdir@ +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +top_builddir = ../.. +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +INSTALL = @INSTALL@ +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +host_triplet = @host@ +DIST_COMMON = $(salomeinclude_HEADERS) $(srcdir)/Makefile.am \ + $(srcdir)/Makefile.in \ + $(top_srcdir)/salome_adm/unix/make_common_starter.am +bin_PROGRAMS = testDF$(EXEEXT) +subdir = ./src/DF +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/salome_adm/unix/config_files/ac_cxx_depend_flag.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/ac_cxx_have_sstream.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/ac_cxx_namespaces.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/ac_cxx_option.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/ac_cxx_template_options.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/ac_cxx_use_std_iostream.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/ac_cxx_warnings.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/ac_linker_options.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/acx_pthread.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_boost.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_cas.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_corba.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_cppunit.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_hdf5.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_htmlgen.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_lam.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_libxml.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_local.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_lsf.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_mpi.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_mpich.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_omniorb.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_openmpi.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_openpbs.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_paco++.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_sockets.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/check_swig.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/enable_pthreads.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/production.m4 \ + $(top_srcdir)/salome_adm/unix/config_files/python.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_CLEAN_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = `echo $$p | sed -e 's|^.*/||'`; +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)" \ + "$(DESTDIR)$(salomeincludedir)" +libLTLIBRARIES_INSTALL = $(INSTALL) +LTLIBRARIES = $(lib_LTLIBRARIES) +am__DEPENDENCIES_1 = +am__DEPENDENCIES_2 = ../HDFPersist/libSalomeHDFPersist.la \ + $(am__DEPENDENCIES_1) +libDF_la_DEPENDENCIES = $(am__DEPENDENCIES_2) +am_libDF_la_OBJECTS = libDF_la-DF_Attribute.lo libDF_la-DF_Label.lo \ + libDF_la-DF_Document.lo libDF_la-DF_Application.lo \ + libDF_la-DF_ChildIterator.lo libDF_la-DF_Container.lo +libDF_la_OBJECTS = $(am_libDF_la_OBJECTS) +binPROGRAMS_INSTALL = $(INSTALL_PROGRAM) +PROGRAMS = $(bin_PROGRAMS) +am_testDF_OBJECTS = testDF-testDF.$(OBJEXT) +testDF_OBJECTS = $(am_testDF_OBJECTS) +testDF_DEPENDENCIES = libDF.la $(am__DEPENDENCIES_2) +DEFAULT_INCLUDES = -I. -I$(srcdir) +depcomp = $(SHELL) $(top_srcdir)/salome_adm/unix/config_files/depcomp +am__depfiles_maybe = depfiles +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) --mode=link --tag=CXX $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +LTCOMPILE = $(LIBTOOL) --mode=compile --tag=CC $(CC) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CFLAGS) $(CFLAGS) +CCLD = $(CC) +LINK = $(LIBTOOL) --mode=link --tag=CC $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ + $(AM_LDFLAGS) $(LDFLAGS) -o $@ +SOURCES = $(libDF_la_SOURCES) $(testDF_SOURCES) +DIST_SOURCES = $(libDF_la_SOURCES) $(testDF_SOURCES) +salomeincludeHEADERS_INSTALL = $(INSTALL_HEADER) +HEADERS = $(salomeinclude_HEADERS) +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMDEP_FALSE = @AMDEP_FALSE@ +AMDEP_TRUE = @AMDEP_TRUE@ +AMTAR = @AMTAR@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +BOOST_CPPFLAGS = @BOOST_CPPFLAGS@ +BOOST_LIBS = @BOOST_LIBS@ +BOOST_LIBSUFFIX = @BOOST_LIBSUFFIX@ +BOOST_PROGRAM_OPTIONS_LIB = @BOOST_PROGRAM_OPTIONS_LIB@ +CAS_CPPFLAGS = @CAS_CPPFLAGS@ +CAS_CXXFLAGS = @CAS_CXXFLAGS@ +CAS_DATAEXCHANGE = @CAS_DATAEXCHANGE@ +CAS_KERNEL = @CAS_KERNEL@ +CAS_LDFLAGS = @CAS_LDFLAGS@ +CAS_LDPATH = @CAS_LDPATH@ +CAS_MATH = @CAS_MATH@ +CAS_MODELER = @CAS_MODELER@ +CAS_OCAF = @CAS_OCAF@ +CAS_OCAFVIS = @CAS_OCAFVIS@ +CAS_STDPLUGIN = @CAS_STDPLUGIN@ +CAS_TKTopAlgo = @CAS_TKTopAlgo@ +CAS_VIEWER = @CAS_VIEWER@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CORBA_CXXFLAGS = @CORBA_CXXFLAGS@ +CORBA_GEN_FALSE = @CORBA_GEN_FALSE@ +CORBA_GEN_TRUE = @CORBA_GEN_TRUE@ +CORBA_INCLUDES = @CORBA_INCLUDES@ +CORBA_LIBS = @CORBA_LIBS@ +CORBA_ROOT = @CORBA_ROOT@ +CP = @CP@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CPPUNIT_INCLUDES = @CPPUNIT_INCLUDES@ +CPPUNIT_IS_OK_FALSE = @CPPUNIT_IS_OK_FALSE@ +CPPUNIT_IS_OK_TRUE = @CPPUNIT_IS_OK_TRUE@ +CPPUNIT_LIBS = @CPPUNIT_LIBS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CXXTMPDPTHFLAGS = @CXXTMPDPTHFLAGS@ +CXX_DEPEND_FLAG = @CXX_DEPEND_FLAG@ +CYGPATH_W = @CYGPATH_W@ +C_DEPEND_FLAG = @C_DEPEND_FLAG@ +DEFS = @DEFS@ +DEPCC = @DEPCC@ +DEPCXX = @DEPCXX@ +DEPCXXFLAGS = @DEPCXXFLAGS@ +DEPDIR = @DEPDIR@ +DOT = @DOT@ +DOXYGEN = @DOXYGEN@ +DOXYGEN_WITH_PYTHON = @DOXYGEN_WITH_PYTHON@ +DOXYGEN_WITH_STL = @DOXYGEN_WITH_STL@ +DVIPS = @DVIPS@ +ECHO = @ECHO@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +F77 = @F77@ +FFLAGS = @FFLAGS@ +HAVE_SSTREAM = @HAVE_SSTREAM@ +HDF5_INCLUDES = @HDF5_INCLUDES@ +HDF5_LIBS = @HDF5_LIBS@ +HDF5_MT_LIBS = @HDF5_MT_LIBS@ +IDL = @IDL@ +IDLCXXFLAGS = @IDLCXXFLAGS@ +IDLPYFLAGS = @IDLPYFLAGS@ +IDL_CLN_CXX = @IDL_CLN_CXX@ +IDL_CLN_H = @IDL_CLN_H@ +IDL_CLN_OBJ = @IDL_CLN_OBJ@ +IDL_SRV_CXX = @IDL_SRV_CXX@ +IDL_SRV_H = @IDL_SRV_H@ +IDL_SRV_OBJ = @IDL_SRV_OBJ@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LATEX = @LATEX@ +LDEXPDYNFLAGS = @LDEXPDYNFLAGS@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIBXML_INCLUDES = @LIBXML_INCLUDES@ +LIBXML_LIBS = @LIBXML_LIBS@ +LIB_LOCATION_SUFFIX = @LIB_LOCATION_SUFFIX@ +LN_S = @LN_S@ +LSF_INCLUDES = @LSF_INCLUDES@ +LSF_LDFLAGS = @LSF_LDFLAGS@ +LSF_LIBS = @LSF_LIBS@ +LTLIBOBJS = @LTLIBOBJS@ +MACHINE = @MACHINE@ +MAKEINFO = @MAKEINFO@ +MODULE_NAME = @MODULE_NAME@ +MPI_INCLUDES = @MPI_INCLUDES@ +MPI_IS_OK_FALSE = @MPI_IS_OK_FALSE@ +MPI_IS_OK_TRUE = @MPI_IS_OK_TRUE@ +MPI_LIBS = @MPI_LIBS@ +OBJEXT = @OBJEXT@ +OMNIORB_CXXFLAGS = @OMNIORB_CXXFLAGS@ +OMNIORB_IDL = @OMNIORB_IDL@ +OMNIORB_IDLCXXFLAGS = @OMNIORB_IDLCXXFLAGS@ +OMNIORB_IDLPYFLAGS = @OMNIORB_IDLPYFLAGS@ +OMNIORB_IDL_CLN_CXX = @OMNIORB_IDL_CLN_CXX@ +OMNIORB_IDL_CLN_H = @OMNIORB_IDL_CLN_H@ +OMNIORB_IDL_CLN_OBJ = @OMNIORB_IDL_CLN_OBJ@ +OMNIORB_IDL_SRV_CXX = @OMNIORB_IDL_SRV_CXX@ +OMNIORB_IDL_SRV_H = @OMNIORB_IDL_SRV_H@ +OMNIORB_IDL_SRV_OBJ = @OMNIORB_IDL_SRV_OBJ@ +OMNIORB_IDL_TIE_CXX = @OMNIORB_IDL_TIE_CXX@ +OMNIORB_IDL_TIE_H = @OMNIORB_IDL_TIE_H@ +OMNIORB_INCLUDES = @OMNIORB_INCLUDES@ +OMNIORB_LIBS = @OMNIORB_LIBS@ +OMNIORB_ROOT = @OMNIORB_ROOT@ +OPENPBS = @OPENPBS@ +OPENPBS_INCLUDES = @OPENPBS_INCLUDES@ +OPENPBS_LIBDIR = @OPENPBS_LIBDIR@ +OPENPBS_LIBS = @OPENPBS_LIBS@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PACOPATH = @PACOPATH@ +PACO_IDL = @PACO_IDL@ +PACO_INCLUDES = @PACO_INCLUDES@ +PACO_LIBS = @PACO_LIBS@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PDFLATEX = @PDFLATEX@ +PTHREAD_CC = @PTHREAD_CC@ +PTHREAD_CFLAGS = @PTHREAD_CFLAGS@ +PTHREAD_LIBS = @PTHREAD_LIBS@ +PYTHON = @PYTHON@ +PYTHONHOME = @PYTHONHOME@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_INCLUDES = @PYTHON_INCLUDES@ +PYTHON_LIBS = @PYTHON_LIBS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE = @PYTHON_SITE@ +PYTHON_SITE_EXEC = @PYTHON_SITE_EXEC@ +PYTHON_SITE_INSTALL = @PYTHON_SITE_INSTALL@ +PYTHON_SITE_PACKAGE = @PYTHON_SITE_PACKAGE@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +RCP = @RCP@ +RM = @RM@ +ROOT_BUILDDIR = @ROOT_BUILDDIR@ +ROOT_SRCDIR = @ROOT_SRCDIR@ +RSH = @RSH@ +RST2HTML = @RST2HTML@ +RST2HTML_IS_OK_FALSE = @RST2HTML_IS_OK_FALSE@ +RST2HTML_IS_OK_TRUE = @RST2HTML_IS_OK_TRUE@ +SCP = @SCP@ +SETX = @SETX@ +SET_MAKE = @SET_MAKE@ +SH = @SH@ +SHELL = @SHELL@ +SOCKETFLAGS = @SOCKETFLAGS@ +SOCKETLIBS = @SOCKETLIBS@ +SSH = @SSH@ +STDLIB = @STDLIB@ +STRIP = @STRIP@ +SWIG = @SWIG@ +SWIG_FLAGS = @SWIG_FLAGS@ +VERSION = @VERSION@ +WITHMPI = @WITHMPI@ +WITHOPENPBS = @WITHOPENPBS@ +WITH_BATCH = @WITH_BATCH@ +WITH_BATCH_FALSE = @WITH_BATCH_FALSE@ +WITH_BATCH_TRUE = @WITH_BATCH_TRUE@ +WITH_LOCAL = @WITH_LOCAL@ +WITH_LOCAL_FALSE = @WITH_LOCAL_FALSE@ +WITH_LOCAL_TRUE = @WITH_LOCAL_TRUE@ +WITH_LSF = @WITH_LSF@ +WITH_LSF_FALSE = @WITH_LSF_FALSE@ +WITH_LSF_TRUE = @WITH_LSF_TRUE@ +WITH_OPENPBS_FALSE = @WITH_OPENPBS_FALSE@ +WITH_OPENPBS_TRUE = @WITH_OPENPBS_TRUE@ +WITH_PACO_PARALLEL_FALSE = @WITH_PACO_PARALLEL_FALSE@ +WITH_PACO_PARALLEL_TRUE = @WITH_PACO_PARALLEL_TRUE@ +XVERSION = @XVERSION@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_F77 = @ac_ct_F77@ +ac_ct_RANLIB = @ac_ct_RANLIB@ +ac_ct_STRIP = @ac_ct_STRIP@ +acx_pthread_config = @acx_pthread_config@ +am__fastdepCC_FALSE = @am__fastdepCC_FALSE@ +am__fastdepCC_TRUE = @am__fastdepCC_TRUE@ +am__fastdepCXX_FALSE = @am__fastdepCXX_FALSE@ +am__fastdepCXX_TRUE = @am__fastdepCXX_TRUE@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = $(prefix)/bin/@PACKAGE@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +cppunit_ok = @cppunit_ok@ +datadir = @datadir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = $(prefix)/lib@LIB_LOCATION_SUFFIX@/@PACKAGE@ +libexecdir = @libexecdir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +mpi_ok = @mpi_ok@ +oldincludedir = @oldincludedir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +sysconfdir = @sysconfdir@ +target = @target@ +target_alias = @target_alias@ +target_cpu = @target_cpu@ +target_os = @target_os@ +target_vendor = @target_vendor@ + +# Standard directory for installation +salomeincludedir = $(includedir)/@PACKAGE@ +salomescriptdir = $(bindir) + +# Directory for installing idl files +salomeidldir = $(prefix)/idl/@PACKAGE@ + +# Directory for installing resource files +salomeresdir = $(prefix)/share/@PACKAGE@/resources/@MODULE_NAME@ + +# Directories for installing admin files +salomeadmdir = $(prefix)/salome_adm +salomeadmuxdir = $(salomeadmdir)/unix +salomem4dir = $(salomeadmdir)/unix/config_files +salome4deprdir = $(salomeadmdir)/unix/config_files/DEPRECATED + +# Shared modules installation directory +sharedpkgpythondir = $(pkgpythondir)/shared_modules + +# Documentation directory +docdir = $(datadir)/doc/@PACKAGE@ + +# +# =============================================================== +# Files to be installed +# =============================================================== +# +# header files +salomeinclude_HEADERS = \ + DF_Attribute.hxx \ + DF_Label.hxx \ + DF_Application.hxx \ + DF_Document.hxx \ + DF_ChildIterator.hxx \ + DF_Container.hxx \ + DF_definitions.hxx + + +# +# =============================================================== +# Local definitions +# =============================================================== +# + +# This local variable defines the list of CPPFLAGS common to all target in this package. +COMMON_CPPFLAGS = \ + @CAS_CPPFLAGS@ @CAS_CXXFLAGS@ \ + -I$(srcdir)/../Basics \ + -I$(srcdir)/../SALOMELocalTrace \ + -I$(srcdir)/../HDFPersist \ + @HDF5_INCLUDES@ + + +# This flag is used to resolve the dependencies of OCC libraries. +LDXMUFLAGS = -L/usr/X11R6/lib@LIB_LOCATION_SUFFIX@ -lXmu + +# This local variable defines the list of dependant libraries common to all target in this package. +COMMON_LIBS = \ + ../HDFPersist/libSalomeHDFPersist.la \ + @CAS_OCAF@ \ + @HDF5_LIBS@ \ + $(LDXMUFLAGS) + + +# +# =============================================================== +# Libraries targets +# =============================================================== +# +lib_LTLIBRARIES = libDF.la +libDF_la_SOURCES = \ + DF_Attribute.cxx \ + DF_Label.cxx \ + DF_Document.cxx \ + DF_Application.cxx \ + DF_ChildIterator.cxx \ + DF_Container.cxx \ +\ + DF_Attribute.hxx \ + DF_Label.hxx \ + DF_Application.hxx \ + DF_Document.hxx \ + DF_ChildIterator.hxx \ + DF_Container.hxx \ + DF_definitions.hxx + +libDF_la_CPPFLAGS = $(COMMON_CPPFLAGS) +libDF_la_LDFLAGS = -no-undefined -version-info=0:0:0 +libDF_la_LIBADD = $(COMMON_LIBS) +testDF_SOURCES = testDF.cxx +testDF_CPPFLAGS = $(COMMON_CPPFLAGS) +testDF_LDADD = libDF.la $(COMMON_LIBS) +all: all-am + +.SUFFIXES: +.SUFFIXES: .cxx .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(top_srcdir)/salome_adm/unix/make_common_starter.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu ./src/DF/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu ./src/DF/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + test -z "$(libdir)" || $(mkdir_p) "$(DESTDIR)$(libdir)" + @list='$(lib_LTLIBRARIES)'; for p in $$list; do \ + if test -f $$p; then \ + f=$(am__strip_dir) \ + echo " $(LIBTOOL) --mode=install $(libLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) '$$p' '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) --mode=install $(libLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) "$$p" "$(DESTDIR)$(libdir)/$$f"; \ + else :; fi; \ + done + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @set -x; list='$(lib_LTLIBRARIES)'; for p in $$list; do \ + p=$(am__strip_dir) \ + echo " $(LIBTOOL) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$p'"; \ + $(LIBTOOL) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$p"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; for p in $$list; do \ + dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \ + test "$$dir" != "$$p" || dir=.; \ + echo "rm -f \"$${dir}/so_locations\""; \ + rm -f "$${dir}/so_locations"; \ + done +libDF.la: $(libDF_la_OBJECTS) $(libDF_la_DEPENDENCIES) + $(CXXLINK) -rpath $(libdir) $(libDF_la_LDFLAGS) $(libDF_la_OBJECTS) $(libDF_la_LIBADD) $(LIBS) +install-binPROGRAMS: $(bin_PROGRAMS) + @$(NORMAL_INSTALL) + test -z "$(bindir)" || $(mkdir_p) "$(DESTDIR)$(bindir)" + @list='$(bin_PROGRAMS)'; for p in $$list; do \ + p1=`echo $$p|sed 's/$(EXEEXT)$$//'`; \ + if test -f $$p \ + || test -f $$p1 \ + ; then \ + f=`echo "$$p1" | sed 's,^.*/,,;$(transform);s/$$/$(EXEEXT)/'`; \ + echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) --mode=install $(binPROGRAMS_INSTALL) '$$p' '$(DESTDIR)$(bindir)/$$f'"; \ + $(INSTALL_PROGRAM_ENV) $(LIBTOOL) --mode=install $(binPROGRAMS_INSTALL) "$$p" "$(DESTDIR)$(bindir)/$$f" || exit 1; \ + else :; fi; \ + done + +uninstall-binPROGRAMS: + @$(NORMAL_UNINSTALL) + @list='$(bin_PROGRAMS)'; for p in $$list; do \ + f=`echo "$$p" | sed 's,^.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/'`; \ + echo " rm -f '$(DESTDIR)$(bindir)/$$f'"; \ + rm -f "$(DESTDIR)$(bindir)/$$f"; \ + done + +clean-binPROGRAMS: + @list='$(bin_PROGRAMS)'; for p in $$list; do \ + f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f $$p $$f"; \ + rm -f $$p $$f ; \ + done +testDF$(EXEEXT): $(testDF_OBJECTS) $(testDF_DEPENDENCIES) + @rm -f testDF$(EXEEXT) + $(CXXLINK) $(testDF_LDFLAGS) $(testDF_OBJECTS) $(testDF_LDADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libDF_la-DF_Application.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libDF_la-DF_Attribute.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libDF_la-DF_ChildIterator.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libDF_la-DF_Container.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libDF_la-DF_Document.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libDF_la-DF_Label.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/testDF-testDF.Po@am__quote@ + +.cxx.o: +@am__fastdepCXX_TRUE@ if $(CXXCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ $< + +.cxx.obj: +@am__fastdepCXX_TRUE@ if $(CXXCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ `$(CYGPATH_W) '$<'`; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cxx.lo: +@am__fastdepCXX_TRUE@ if $(LTCXXCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Plo"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LTCXXCOMPILE) -c -o $@ $< + +libDF_la-DF_Attribute.lo: DF_Attribute.cxx +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libDF_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libDF_la-DF_Attribute.lo -MD -MP -MF "$(DEPDIR)/libDF_la-DF_Attribute.Tpo" -c -o libDF_la-DF_Attribute.lo `test -f 'DF_Attribute.cxx' || echo '$(srcdir)/'`DF_Attribute.cxx; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libDF_la-DF_Attribute.Tpo" "$(DEPDIR)/libDF_la-DF_Attribute.Plo"; else rm -f "$(DEPDIR)/libDF_la-DF_Attribute.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='DF_Attribute.cxx' object='libDF_la-DF_Attribute.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libDF_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libDF_la-DF_Attribute.lo `test -f 'DF_Attribute.cxx' || echo '$(srcdir)/'`DF_Attribute.cxx + +libDF_la-DF_Label.lo: DF_Label.cxx +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libDF_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libDF_la-DF_Label.lo -MD -MP -MF "$(DEPDIR)/libDF_la-DF_Label.Tpo" -c -o libDF_la-DF_Label.lo `test -f 'DF_Label.cxx' || echo '$(srcdir)/'`DF_Label.cxx; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libDF_la-DF_Label.Tpo" "$(DEPDIR)/libDF_la-DF_Label.Plo"; else rm -f "$(DEPDIR)/libDF_la-DF_Label.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='DF_Label.cxx' object='libDF_la-DF_Label.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libDF_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libDF_la-DF_Label.lo `test -f 'DF_Label.cxx' || echo '$(srcdir)/'`DF_Label.cxx + +libDF_la-DF_Document.lo: DF_Document.cxx +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libDF_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libDF_la-DF_Document.lo -MD -MP -MF "$(DEPDIR)/libDF_la-DF_Document.Tpo" -c -o libDF_la-DF_Document.lo `test -f 'DF_Document.cxx' || echo '$(srcdir)/'`DF_Document.cxx; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libDF_la-DF_Document.Tpo" "$(DEPDIR)/libDF_la-DF_Document.Plo"; else rm -f "$(DEPDIR)/libDF_la-DF_Document.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='DF_Document.cxx' object='libDF_la-DF_Document.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libDF_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libDF_la-DF_Document.lo `test -f 'DF_Document.cxx' || echo '$(srcdir)/'`DF_Document.cxx + +libDF_la-DF_Application.lo: DF_Application.cxx +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libDF_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libDF_la-DF_Application.lo -MD -MP -MF "$(DEPDIR)/libDF_la-DF_Application.Tpo" -c -o libDF_la-DF_Application.lo `test -f 'DF_Application.cxx' || echo '$(srcdir)/'`DF_Application.cxx; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libDF_la-DF_Application.Tpo" "$(DEPDIR)/libDF_la-DF_Application.Plo"; else rm -f "$(DEPDIR)/libDF_la-DF_Application.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='DF_Application.cxx' object='libDF_la-DF_Application.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libDF_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libDF_la-DF_Application.lo `test -f 'DF_Application.cxx' || echo '$(srcdir)/'`DF_Application.cxx + +libDF_la-DF_ChildIterator.lo: DF_ChildIterator.cxx +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libDF_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libDF_la-DF_ChildIterator.lo -MD -MP -MF "$(DEPDIR)/libDF_la-DF_ChildIterator.Tpo" -c -o libDF_la-DF_ChildIterator.lo `test -f 'DF_ChildIterator.cxx' || echo '$(srcdir)/'`DF_ChildIterator.cxx; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libDF_la-DF_ChildIterator.Tpo" "$(DEPDIR)/libDF_la-DF_ChildIterator.Plo"; else rm -f "$(DEPDIR)/libDF_la-DF_ChildIterator.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='DF_ChildIterator.cxx' object='libDF_la-DF_ChildIterator.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libDF_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libDF_la-DF_ChildIterator.lo `test -f 'DF_ChildIterator.cxx' || echo '$(srcdir)/'`DF_ChildIterator.cxx + +libDF_la-DF_Container.lo: DF_Container.cxx +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libDF_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libDF_la-DF_Container.lo -MD -MP -MF "$(DEPDIR)/libDF_la-DF_Container.Tpo" -c -o libDF_la-DF_Container.lo `test -f 'DF_Container.cxx' || echo '$(srcdir)/'`DF_Container.cxx; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libDF_la-DF_Container.Tpo" "$(DEPDIR)/libDF_la-DF_Container.Plo"; else rm -f "$(DEPDIR)/libDF_la-DF_Container.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='DF_Container.cxx' object='libDF_la-DF_Container.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LIBTOOL) --mode=compile --tag=CXX $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libDF_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libDF_la-DF_Container.lo `test -f 'DF_Container.cxx' || echo '$(srcdir)/'`DF_Container.cxx + +testDF-testDF.o: testDF.cxx +@am__fastdepCXX_TRUE@ if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(testDF_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT testDF-testDF.o -MD -MP -MF "$(DEPDIR)/testDF-testDF.Tpo" -c -o testDF-testDF.o `test -f 'testDF.cxx' || echo '$(srcdir)/'`testDF.cxx; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/testDF-testDF.Tpo" "$(DEPDIR)/testDF-testDF.Po"; else rm -f "$(DEPDIR)/testDF-testDF.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='testDF.cxx' object='testDF-testDF.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(testDF_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o testDF-testDF.o `test -f 'testDF.cxx' || echo '$(srcdir)/'`testDF.cxx + +testDF-testDF.obj: testDF.cxx +@am__fastdepCXX_TRUE@ if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(testDF_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT testDF-testDF.obj -MD -MP -MF "$(DEPDIR)/testDF-testDF.Tpo" -c -o testDF-testDF.obj `if test -f 'testDF.cxx'; then $(CYGPATH_W) 'testDF.cxx'; else $(CYGPATH_W) '$(srcdir)/testDF.cxx'; fi`; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/testDF-testDF.Tpo" "$(DEPDIR)/testDF-testDF.Po"; else rm -f "$(DEPDIR)/testDF-testDF.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='testDF.cxx' object='testDF-testDF.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(testDF_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o testDF-testDF.obj `if test -f 'testDF.cxx'; then $(CYGPATH_W) 'testDF.cxx'; else $(CYGPATH_W) '$(srcdir)/testDF.cxx'; fi` + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +distclean-libtool: + -rm -f libtool +uninstall-info-am: +install-salomeincludeHEADERS: $(salomeinclude_HEADERS) + @$(NORMAL_INSTALL) + test -z "$(salomeincludedir)" || $(mkdir_p) "$(DESTDIR)$(salomeincludedir)" + @list='$(salomeinclude_HEADERS)'; for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + f=$(am__strip_dir) \ + echo " $(salomeincludeHEADERS_INSTALL) '$$d$$p' '$(DESTDIR)$(salomeincludedir)/$$f'"; \ + $(salomeincludeHEADERS_INSTALL) "$$d$$p" "$(DESTDIR)$(salomeincludedir)/$$f"; \ + done + +uninstall-salomeincludeHEADERS: + @$(NORMAL_UNINSTALL) + @list='$(salomeinclude_HEADERS)'; for p in $$list; do \ + f=$(am__strip_dir) \ + echo " rm -f '$(DESTDIR)$(salomeincludedir)/$$f'"; \ + rm -f "$(DESTDIR)$(salomeincludedir)/$$f"; \ + done + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$tags $$unique; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + test -z "$(CTAGS_ARGS)$$tags$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$tags $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && cd $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) $$here + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + $(mkdir_p) $(distdir)/../../salome_adm/unix + @srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \ + list='$(DISTFILES)'; for file in $$list; do \ + case $$file in \ + $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \ + $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \ + esac; \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test "$$dir" != "$$file" && test "$$dir" != "."; then \ + dir="/$$dir"; \ + $(mkdir_p) "$(distdir)$$dir"; \ + else \ + dir=''; \ + fi; \ + if test -d $$d/$$file; then \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \ + fi; \ + cp -pR $$d/$$file $(distdir)$$dir || exit 1; \ + else \ + test -f $(distdir)/$$file \ + || cp -p $$d/$$file $(distdir)/$$file \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) $(PROGRAMS) $(HEADERS) +install-binPROGRAMS: install-libLTLIBRARIES + +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)" "$(DESTDIR)$(salomeincludedir)"; do \ + test -z "$$dir" || $(mkdir_p) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-libtool distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +info: info-am + +info-am: + +install-data-am: install-salomeincludeHEADERS + +install-exec-am: install-binPROGRAMS install-libLTLIBRARIES + +install-info: install-info-am + +install-man: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-binPROGRAMS uninstall-info-am \ + uninstall-libLTLIBRARIES uninstall-salomeincludeHEADERS + +.PHONY: CTAGS GTAGS all all-am check check-am clean clean-binPROGRAMS \ + clean-generic clean-libLTLIBRARIES clean-libtool ctags \ + distclean distclean-compile distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-binPROGRAMS \ + install-data install-data-am install-exec install-exec-am \ + install-info install-info-am install-libLTLIBRARIES \ + install-man install-salomeincludeHEADERS install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags uninstall uninstall-am uninstall-binPROGRAMS \ + uninstall-info-am uninstall-libLTLIBRARIES \ + uninstall-salomeincludeHEADERS + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/src/DF/testDF.cxx b/src/DF/testDF.cxx new file mode 100644 index 000000000..69dd8920c --- /dev/null +++ b/src/DF/testDF.cxx @@ -0,0 +1,311 @@ +// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// +//File: testDF.cxx +//Author: Sergey RUIN + +#include +#include +#include +#include + +#include "DF_definitions.hxx" +#include "DF_Application.hxx" +#include "DF_Document.hxx" +#include "DF_Attribute.hxx" +#include "DF_Label.hxx" +#include "DF_Container.hxx" +#include "DF_ChildIterator.hxx" + +#ifndef WNT +#include +#include +#include +#include +#else +#include +#include +#endif + +using namespace std; + +void printStr(const string& theValue) +{ + cout << "printStr: " << theValue << endl; +} + +void GetSystemDate(int& year, int& month, int& day, int& hours, int& minutes, int& seconds) +{ +#ifdef WNT + SYSTEMTIME st; + + GetLocalTime ( &st ); + + month = st.wMonth; + day = st.wDay; + year = st.wYear; + hours = st.wHour; + minutes = st.wMinute; + seconds = st.wSecond; +#else + struct tm transfert; + struct timeval tval; + struct timezone tzone; + int status; + + status = gettimeofday( &tval, &tzone ); + memcpy(&transfert, localtime((time_t *)&tval.tv_sec), sizeof(tm)); + + month = transfert.tm_mon + 1; + day = transfert.tm_mday; + year = transfert.tm_year + 1900; + hours = transfert.tm_hour; + minutes = transfert.tm_min ; + seconds = transfert.tm_sec ; +#endif +} + +string GetUserName() +{ +#ifdef WNT + char* pBuff = new char[UNLEN + 1]; + DWORD dwSize = UNLEN + 1; + string retVal; + GetUserName ( pBuff, &dwSize ); + string theTmpUserName(pBuff,(int)dwSize -1 ); + retVal = theTmpUserName; + delete [] pBuff; + return retVal; +#else + struct passwd *infos; + infos = getpwuid(getuid()); + return string(infos->pw_name); +#endif +} + +string GetNameFromPath(const string& thePath) { + if (thePath.empty()) return ""; + int pos1 = thePath.rfind('/'); + int pos2 = thePath.rfind('\\'); + if(pos1 > 0) return thePath.substr(pos1+1, thePath.size()); + if(pos2 > 0) return thePath.substr(pos2+1, thePath.size()); + return thePath; +} + +string GetDirFromPath(const string& thePath) { + if (thePath.empty()) return ""; + + int pos = thePath.rfind('/'); + string path; + if(pos > 0) { + path = thePath.substr(0, pos+1); + } + if(path.empty()) { + pos = thePath.rfind('\\'); + if(pos > 0) path = thePath.substr(0, pos+1); + } + if(path.empty()) { + pos = thePath.rfind('|'); + if(pos > 0) path = thePath.substr(0, pos+1); + } + if(path.empty()) { + path = thePath+"/"; + } + +#ifdef WNT //Check if the only disk letter is given as path + if(path.size() == 2 && path[1] == ":") path +='\\'; +#endif + + for(int i = 0, len = path.size(); i splitString(const string& theValue, char separator) +{ + vector vs; + if(theValue[0] == separator && theValue.size() == 1) return vs; + int pos = theValue.find(separator); + if(pos < 0) { + vs.push_back(theValue); + return vs; + } + + string s = theValue; + if(s[0] == separator) s = s.substr(1, s.size()); + while((pos = s.find(separator)) >= 0) { + vs.push_back(s.substr(0, pos)); + s = s.substr(pos+1, s.size()); + } + + if(!s.empty() && s[0] != separator) vs.push_back(s); + return vs; +} + + +int main (int argc, char * argv[]) +{ + cout << "Test started " << endl; + + DF_Application* appli = new DF_Application; + DF_Document* doc1 = appli->NewDocument("doc_1"); + + /* + DF_Label root1 = doc1->Main(); + DF_Label child = root1.FindChild(3, true); //0:1:3 + + DF_Container* attr1 = DF_Container::Set(child); + attr1->SetInt("eighteen", 18); + + + DF_Attribute* attr = NULL; + if(!(attr = child.FindAttribute(DF_Container::GetID()))) { + cout << "Attribute wasn't found" << endl; + } + else { + attr1 = dynamic_cast(attr); + cout << "Attribute was found " << " HasID " << attr1->HasIntID("eighteen") << " value = " << attr1->GetInt("eighteen")<< endl; + } + + DF_Container *attr2 = (DF_Container*)child.FindAttribute(DF_Container::GetID()); + + if(!attr2) cout << "Can't find the attribute" << endl; + + cout << "Change find : " << attr2->GetInt("eighteen") << endl; + + + cout << "Forgetting " << child.ForgetAttribute(DF_Container::GetID()) << endl; + if(!child.FindAttribute(DF_Container::GetID())) { + cout << "Attribute wasn't found" << endl; + } + + + child = root1.NewChild(); //0:1:4 + + child.NewChild();//0:1:4:1 + + child.NewChild();//0:1:4:2 + + cout << "Is equal " << (child == child) << endl; + cout << "Is equal " << (child == root1) << endl; + + child = root1.NewChild(); //0:1:5 + + child.NewChild();//0:1:5:1 + root1.NewChild();//0:1:6 + + + DF_ChildIterator CI(root1.Father(), true); + //root1.dump(); + for(; CI.More(); CI.Next()) { + cout << CI.Value().Entry() << endl; + //CI.Value().dump(); + } + + DF_Label L = DF_Label::Label(child, "0:1:4:1"); + cout << "Found Label " << L.Entry() << endl; + + std::string s("012-56"); + + int pos = s.find('-'); + cout << "Fisrt part : " << s.substr(0, pos) << endl; + cout << "Last part : " << s.substr(pos+1, s.size()) << endl; + + vector vs = splitString("/dn20/salome/srn/salome2/", '/'); + for(int i = 0; iMain(); + DF_Label sco = root2.NewChild(); //0:1:1 + DF_Label so1 = sco.FindChild(3, true); //0:1:1:3 + DF_Label so5 = so1.FindChild(5, true); //0:1:1:5 + DF_Label so51 = so5.NewChild(); //0:1:1:5:1 + DF_Label so511 = so51.NewChild(); //0:1:1:5:1:1 + DF_Label so513 = so51.FindChild(3, true); //0:1:1:5:1:3 + DF_Label so5131 = so513.NewChild(); //0:1:1:5:1:3:1 + + + so51.FindChild(2, true); + + + DF_ChildIterator CI2(so5, true); + so5.dump(); + for(; CI2.More(); CI2.Next()) { + cout << " ###### Found child with entry = " << CI2.Value().Entry() << endl; + //CI2.Value().dump(); + } + + delete appli; + + cout << "Test finished " << endl; + return 0; +} +