[occt.git] / src / LDOM / LDOM_Document.cxx

// File:      LDOM_Document.cxx
// Created:   26.06.01 10:18:05
// Author:    Alexander GRIGORIEV
// Copyright: OpenCascade 2001
// History:


#include <LDOM_Document.hxx>
#include <LDOM_MemManager.hxx>
#include <LDOM_BasicElement.hxx>
#include <LDOM_BasicText.hxx>

#define MEMORY_GRANULE 10000

//=======================================================================
//function : LDOM_Document()
//purpose  : Constructor
//=======================================================================

LDOM_Document::LDOM_Document ()
{
  myMemManager = new LDOM_MemManager (MEMORY_GRANULE);
}

//=======================================================================
//function : LDOM_Document
//purpose  : Constructor to be used in LDOM_MemManager::Doc()
//=======================================================================

LDOM_Document::LDOM_Document (const LDOM_MemManager& aMemManager)
{
  myMemManager = &aMemManager;
}

//=======================================================================
//function : ~LDOM_Document
//purpose  : Destructor
//=======================================================================

LDOM_Document::~LDOM_Document ()
{}

//=======================================================================
//function : isNull
//purpose  : 
//=======================================================================

Standard_Boolean LDOM_Document::isNull () const
{
  const LDOM_BasicElement * const aRootElement = myMemManager -> RootElement();
  if (aRootElement == NULL) return Standard_True;
  return aRootElement -> isNull();
}

//=======================================================================
//function : getDocumentElement
//purpose  : 
//=======================================================================

LDOM_Element LDOM_Document::getDocumentElement () const
{
  return LDOM_Element (* myMemManager -> RootElement(), myMemManager);
}

//=======================================================================
//function : getElementsByTagName
//purpose  : 
//=======================================================================

LDOM_NodeList LDOM_Document::getElementsByTagName
                                        (const LDOMString& theTagName) const
{
  LDOM_NodeList aList (myMemManager);
  LDOM_BasicElement * anElem = (LDOM_BasicElement *)myMemManager->RootElement();
  const char        * aTagString = theTagName.GetString();
  if (anElem) {
//  if (anElem -> GetTagName().equals(theTagName))
    if (strcmp (anElem -> GetTagName(), aTagString) == 0)
      aList.Append (* anElem);
    anElem -> AddElementsByTagName (aList, theTagName);
  }
  return aList;
}

//=======================================================================
//function : createDocument (static)
//purpose  : 
//=======================================================================

LDOM_Document LDOM_Document::createDocument (const LDOMString& theQualifiedName)
{
  LDOM_Document aDoc;
  const char * aString = theQualifiedName.GetString();
  if (strlen(aString) == 0)
    aString = "document";
  aDoc.myMemManager -> myRootElement =
    & LDOM_BasicElement::Create (aString, strlen(aString), aDoc.myMemManager);
  return aDoc;
}

//=======================================================================
//function : createElement
//purpose  : 
//=======================================================================

LDOM_Element LDOM_Document::createElement (const LDOMString& theTagName)
{
  const char * aTagString = theTagName.GetString();
  LDOM_BasicElement& aBasicElem = LDOM_BasicElement::Create (aTagString,
                                                             strlen(aTagString),
                                                             myMemManager);
  return LDOM_Element (aBasicElem, myMemManager);
}

//=======================================================================
//function : createTextNode
//purpose  : 
//=======================================================================

LDOM_Text LDOM_Document::createTextNode (const LDOMString& theData)
{
  LDOM_BasicText& aBasicText
    = LDOM_BasicText::Create (LDOM_Node::TEXT_NODE,
                              LDOMString (theData, myMemManager), myMemManager);
  return LDOM_Text (aBasicText, myMemManager);
}

//=======================================================================
//function : createCDATASection
//purpose  : 
//=======================================================================

LDOM_CDATASection LDOM_Document::createCDATASection (const LDOMString& theData)
{
  LDOM_BasicText& aBasicText =
    LDOM_BasicText::Create (LDOM_Node::CDATA_SECTION_NODE,
                            LDOMString (theData, myMemManager), myMemManager);
  const LDOM_CDATASection aNewNode (aBasicText, myMemManager);
  aNewNode.SetValueClear(); // no use to beware markup characters
  return aNewNode;
}

//=======================================================================
//function : createComment
//purpose  : 
//=======================================================================

LDOM_Comment LDOM_Document::createComment (const LDOMString& theData)
{
  LDOM_BasicText& aBasicText =
    LDOM_BasicText::Create (LDOM_Node::COMMENT_NODE,
                            LDOMString (theData, myMemManager), myMemManager);
  return LDOM_Comment (aBasicText, myMemManager);
}

//=======================================================================
//function : operator =
//purpose  : Nullify
//=======================================================================

LDOM_Document& LDOM_Document::operator = (const LDOM_NullPtr *)
{
  myMemManager = new LDOM_MemManager (MEMORY_GRANULE);
  return * this;
}

//=======================================================================
//function : operator ==
//purpose  : Compare to NULL
//=======================================================================

Standard_Boolean LDOM_Document::operator == (const LDOM_NullPtr *) const
{
  return myMemManager -> RootElement() == NULL;
}

//=======================================================================
//function : operator !=
//purpose  : Compare to NULL
//=======================================================================

Standard_Boolean LDOM_Document::operator != (const LDOM_NullPtr *) const
{
  return myMemManager -> RootElement() != NULL;
}
Commit	Line	Data
7fd59977	1	// File: LDOM_Document.cxx
	2	// Created: 26.06.01 10:18:05
	3	// Author: Alexander GRIGORIEV
	4	// Copyright: OpenCascade 2001
	5	// History:
	6
	7
	8	#include <LDOM_Document.hxx>
	9	#include <LDOM_MemManager.hxx>
	10	#include <LDOM_BasicElement.hxx>
	11	#include <LDOM_BasicText.hxx>
	12
	13	#define MEMORY_GRANULE 10000
	14
	15	//=======================================================================
	16	//function : LDOM_Document()
	17	//purpose : Constructor
	18	//=======================================================================
	19
	20	LDOM_Document::LDOM_Document ()
	21	{
	22	myMemManager = new LDOM_MemManager (MEMORY_GRANULE);
	23	}
	24
	25	//=======================================================================
	26	//function : LDOM_Document
	27	//purpose : Constructor to be used in LDOM_MemManager::Doc()
	28	//=======================================================================
	29
	30	LDOM_Document::LDOM_Document (const LDOM_MemManager& aMemManager)
	31	{
	32	myMemManager = &aMemManager;
	33	}
	34
	35	//=======================================================================
	36	//function : ~LDOM_Document
	37	//purpose : Destructor
	38	//=======================================================================
	39
	40	LDOM_Document::~LDOM_Document ()
	41	{}
	42
	43	//=======================================================================
	44	//function : isNull
	45	//purpose :
	46	//=======================================================================
	47
	48	Standard_Boolean LDOM_Document::isNull () const
	49	{
	50	const LDOM_BasicElement * const aRootElement = myMemManager -> RootElement();
	51	if (aRootElement == NULL) return Standard_True;
	52	return aRootElement -> isNull();
	53	}
	54
	55	//=======================================================================
	56	//function : getDocumentElement
	57	//purpose :
	58	//=======================================================================
	59
	60	LDOM_Element LDOM_Document::getDocumentElement () const
	61	{
	62	return LDOM_Element (* myMemManager -> RootElement(), myMemManager);
	63	}
	64
65	//=======================================================================
66	//function : getElementsByTagName
67	//purpose :
68	//=======================================================================
69
70	LDOM_NodeList LDOM_Document::getElementsByTagName
71	(const LDOMString& theTagName) const
72	{
73	LDOM_NodeList aList (myMemManager);
74	LDOM_BasicElement * anElem = (LDOM_BasicElement *)myMemManager->RootElement();
75	const char * aTagString = theTagName.GetString();
76	if (anElem) {
77	// if (anElem -> GetTagName().equals(theTagName))
78	if (strcmp (anElem -> GetTagName(), aTagString) == 0)
79	aList.Append (* anElem);
80	anElem -> AddElementsByTagName (aList, theTagName);
81	}
82	return aList;
83	}
84
85	//=======================================================================
86	//function : createDocument (static)
87	//purpose :
88	//=======================================================================
89
90	LDOM_Document LDOM_Document::createDocument (const LDOMString& theQualifiedName)
91	{
92	LDOM_Document aDoc;
93	const char * aString = theQualifiedName.GetString();
94	if (strlen(aString) == 0)
95	aString = "document";
96	aDoc.myMemManager -> myRootElement =
97	& LDOM_BasicElement::Create (aString, strlen(aString), aDoc.myMemManager);
98	return aDoc;
99	}
100
101	//=======================================================================
102	//function : createElement
103	//purpose :
104	//=======================================================================
105
106	LDOM_Element LDOM_Document::createElement (const LDOMString& theTagName)
107	{
108	const char * aTagString = theTagName.GetString();
109	LDOM_BasicElement& aBasicElem = LDOM_BasicElement::Create (aTagString,
110	strlen(aTagString),
111	myMemManager);
112	return LDOM_Element (aBasicElem, myMemManager);
113	}
114
115	//=======================================================================
116	//function : createTextNode
117	//purpose :
118	//=======================================================================
119
120	LDOM_Text LDOM_Document::createTextNode (const LDOMString& theData)
121	{
122	LDOM_BasicText& aBasicText
123	= LDOM_BasicText::Create (LDOM_Node::TEXT_NODE,
124	LDOMString (theData, myMemManager), myMemManager);
125	return LDOM_Text (aBasicText, myMemManager);
126	}
127
128	//=======================================================================
129	//function : createCDATASection
130	//purpose :
131	//=======================================================================
132
133	LDOM_CDATASection LDOM_Document::createCDATASection (const LDOMString& theData)
134	{
135	LDOM_BasicText& aBasicText =
136	LDOM_BasicText::Create (LDOM_Node::CDATA_SECTION_NODE,
137	LDOMString (theData, myMemManager), myMemManager);
138	const LDOM_CDATASection aNewNode (aBasicText, myMemManager);
139	aNewNode.SetValueClear(); // no use to beware markup characters
140	return aNewNode;
141	}
142
143	//=======================================================================
144	//function : createComment
145	//purpose :
146	//=======================================================================
147
148	LDOM_Comment LDOM_Document::createComment (const LDOMString& theData)
149	{
150	LDOM_BasicText& aBasicText =
151	LDOM_BasicText::Create (LDOM_Node::COMMENT_NODE,
152	LDOMString (theData, myMemManager), myMemManager);
153	return LDOM_Comment (aBasicText, myMemManager);
154	}
155
156	//=======================================================================
157	//function : operator =
158	//purpose : Nullify
159	//=======================================================================
160
161	LDOM_Document& LDOM_Document::operator = (const LDOM_NullPtr *)
162	{
163	myMemManager = new LDOM_MemManager (MEMORY_GRANULE);
164	return * this;
165	}
166
167	//=======================================================================
168	//function : operator ==
169	//purpose : Compare to NULL
170	//=======================================================================
171
172	Standard_Boolean LDOM_Document::operator == (const LDOM_NullPtr *) const
173	{
174	return myMemManager -> RootElement() == NULL;
175	}
176
177	//=======================================================================
178	//function : operator !=
179	//purpose : Compare to NULL
180	//=======================================================================
181
182	Standard_Boolean LDOM_Document::operator != (const LDOM_NullPtr *) const
183	{
184	return myMemManager -> RootElement() != NULL;
185	}