0024186: Eliminate remaining compiler warnings in MSVC++ 2010 64 bit with warning...
[occt.git] / src / LDOM / LDOM_BasicElement.cxx
1 // Created on: 2001-06-26
2 // Created by: Alexander GRIGORIEV
3 // Copyright (c) 2001-2012 OPEN CASCADE SAS
4 //
5 // The content of this file is subject to the Open CASCADE Technology Public
6 // License Version 6.5 (the "License"). You may not use the content of this file
7 // except in compliance with the License. Please obtain a copy of the License
8 // at http://www.opencascade.org and read it completely before using this file.
9 //
10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12 //
13 // The Original Code and all software distributed under the License is
14 // distributed on an "AS IS" basis, without warranty of any kind, and the
15 // Initial Developer hereby disclaims all such warranties, including without
16 // limitation, any warranties of merchantability, fitness for a particular
17 // purpose or non-infringement. Please see the License for the specific terms
18 // and conditions governing the rights and limitations under the License.
19
20 //AGV 140202: Replace(const char *) for (LDOMBasicString)=>myTagName
21
22 #include <LDOM_BasicElement.hxx>
23 #include <LDOM_BasicAttribute.hxx>
24 #include <LDOM_BasicText.hxx>
25 #include <LDOM_MemManager.hxx>
26
27 //=======================================================================
28 //function : Create
29 //purpose  : construction in the Document's data pool
30 //=======================================================================
31
32 LDOM_BasicElement& LDOM_BasicElement::Create
33                                         (const char                     * aName,
34                                          const Standard_Integer         aLen,
35                                          const Handle(LDOM_MemManager)& aDoc)
36 {
37   if (aName == NULL) {
38     static LDOM_BasicElement aVoidElement;
39     aVoidElement = LDOM_BasicElement();
40     return aVoidElement;
41   }
42   void * aMem = aDoc -> Allocate (sizeof(LDOM_BasicElement));
43   LDOM_BasicElement * aNewElem = new (aMem) LDOM_BasicElement;
44
45   Standard_Integer aHash;
46 //  aDoc -> HashedAllocate (aString, strlen(aString), aNewElem -> myTagName);
47   aNewElem -> myTagName =  aDoc -> HashedAllocate (aName, aLen, aHash);
48
49   aNewElem -> myNodeType = LDOM_Node::ELEMENT_NODE;
50   return * aNewElem;
51 }
52
53 //=======================================================================
54 //function : RemoveNodes
55 //purpose  : 
56 //=======================================================================
57
58 void LDOM_BasicElement::RemoveNodes ()
59 {
60   const LDOM_BasicNode * aNode = (const LDOM_BasicNode *) myFirstChild;
61   while (aNode) {
62     const LDOM_BasicNode * aNext = aNode -> GetSibling();
63     switch (aNode -> getNodeType ()) {
64     case LDOM_Node::ELEMENT_NODE:
65       {
66         LDOM_BasicElement& anElement = * (LDOM_BasicElement *) aNode;
67         anElement = NULL;
68         break;
69       }
70     case LDOM_Node::ATTRIBUTE_NODE:
71       {
72         LDOM_BasicAttribute& anAttr = * (LDOM_BasicAttribute *) aNode;
73         anAttr = NULL;
74         break;
75       }
76     case LDOM_Node::TEXT_NODE:
77     case LDOM_Node::COMMENT_NODE:
78     case LDOM_Node::CDATA_SECTION_NODE:
79       {
80         LDOM_BasicText& aTxt = * (LDOM_BasicText *) aNode;
81         aTxt = NULL;
82         break;
83       }
84     default: ;
85     }
86     aNode = aNext;
87   }
88   myFirstChild = NULL;
89 }
90
91 //=======================================================================
92 //function : operator =
93 //purpose  : Nullify
94 //=======================================================================
95
96 LDOM_BasicElement& LDOM_BasicElement:: operator = (const LDOM_NullPtr * aNull)
97 {
98   myTagName = NULL;
99   RemoveNodes ();
100   LDOM_BasicNode::operator= (aNull);
101   return * this;
102 }
103
104 //=======================================================================
105 //function : LDOM_BasicElement
106 //purpose  : Constructor
107 //=======================================================================
108 /*
109 LDOM_BasicElement::LDOM_BasicElement (const LDOM_Element& anElement)
110      : LDOM_BasicNode   (LDOM_Node::ELEMENT_NODE),
111        myAttributeMask  (0),
112        myFirstChild     (NULL)
113 {
114 //  LDOMString aNewTagName (anElement.getTagName(), anElement.myDocument);
115 //  myTagName = aNewTagName;
116   const LDOM_BasicElement& anOther =
117     (const LDOM_BasicElement&) anElement.Origin();
118   myTagName = anOther.GetTagName();
119 }
120 */
121 //=======================================================================
122 //function : ~LDOM_BasicElement
123 //purpose  : Destructor
124 //=======================================================================
125
126 LDOM_BasicElement::~LDOM_BasicElement ()
127 {
128   myTagName = NULL;
129   RemoveNodes ();
130 }
131
132 //=======================================================================
133 //function : GetLastChild
134 //purpose  : 
135 //=======================================================================
136
137 const LDOM_BasicNode * LDOM_BasicElement::GetLastChild () const
138 {
139   const LDOM_BasicNode * aNode = myFirstChild;
140   if (aNode) {
141     if (aNode -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE)
142       aNode = NULL;
143     else
144       while (aNode -> mySibling) {
145         if (aNode -> mySibling -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE)
146           break;
147         aNode = aNode -> mySibling;
148       }
149   }
150   return aNode;
151 }
152
153 //=======================================================================
154 //function : GetAttribute
155 //purpose  : 
156 //=======================================================================
157
158 const LDOM_BasicAttribute& LDOM_BasicElement::GetAttribute
159                                      (const LDOMBasicString& aName,
160                                       const LDOM_BasicNode   * aLastCh) const
161 {
162   const LDOM_BasicNode * aNode;
163   if (aLastCh)
164     aNode = aLastCh -> GetSibling (); 
165   else
166     aNode = myFirstChild;
167   const char * aNameStr = aName.GetString();
168   while (aNode) {
169     if (aNode -> getNodeType () == LDOM_Node::ATTRIBUTE_NODE) {
170       const LDOM_BasicAttribute * anAttr = (const LDOM_BasicAttribute *) aNode;
171       if (!strcmp (aNameStr, anAttr -> GetName()))
172         return * anAttr;
173     }
174     aNode = aNode -> mySibling;
175   }
176 static const LDOM_BasicAttribute aNullAttribute;
177   return aNullAttribute;
178 }
179
180 //=======================================================================
181 //function : GetFirstAttribute
182 //purpose  : private method
183 //=======================================================================
184
185 const LDOM_BasicAttribute * LDOM_BasicElement::GetFirstAttribute
186                                     (const LDOM_BasicNode *&  theLastCh,
187                                      const LDOM_BasicNode **& thePrevNode) const
188 {
189   //  Find the First Attribute as well as the Last Child among siblings
190   const LDOM_BasicNode * aFirstAttr;
191   const LDOM_BasicNode ** aPrevNode;
192   if (theLastCh) {
193     aFirstAttr = theLastCh -> mySibling; 
194     aPrevNode  = (const LDOM_BasicNode **) &(theLastCh -> mySibling);
195     while (aFirstAttr) {
196       if (aFirstAttr -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE) break;
197       aPrevNode = (const LDOM_BasicNode **) & (aFirstAttr -> mySibling);
198       aFirstAttr = aFirstAttr -> mySibling;
199     }
200   } else {
201     aFirstAttr = myFirstChild;
202     aPrevNode  = (const LDOM_BasicNode **) &myFirstChild;
203     while (aFirstAttr) {
204       if (aFirstAttr -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE) break;
205       if (aFirstAttr -> isNull() == Standard_False) theLastCh = aFirstAttr;
206       aPrevNode = (const LDOM_BasicNode **) & (aFirstAttr -> mySibling);
207       aFirstAttr = aFirstAttr -> mySibling;
208     }
209   }
210   thePrevNode = aPrevNode;
211   return (LDOM_BasicAttribute *) aFirstAttr;
212 }
213
214 //=======================================================================
215 //function : AddAttribute
216 //purpose  : Add or replace an attribute
217 //=======================================================================
218
219 const LDOM_BasicNode * LDOM_BasicElement::AddAttribute
220                                   (const LDOMBasicString&         anAttrName,
221                                    const LDOMBasicString&         anAttrValue,
222                                    const Handle(LDOM_MemManager)& aDocument,
223                                    const LDOM_BasicNode           * aLastCh)
224 {
225   //  Create attribute
226   Standard_Integer aHash;
227   LDOM_BasicAttribute& anAttr =
228     LDOM_BasicAttribute::Create (anAttrName, aDocument, aHash);
229   anAttr.myValue = anAttrValue;
230
231   //  Initialize the loop of attribute name search
232   const LDOM_BasicNode ** aPrNode;
233   const LDOM_BasicAttribute * aFirstAttr = GetFirstAttribute (aLastCh, aPrNode);
234   const char * aNameStr = anAttrName.GetString();
235
236   //  Check attribute hash value against the current mask
237   const unsigned int anAttrMaskValue = aHash & (8*sizeof(myAttributeMask) - 1);
238   const unsigned long anAttributeMask = (1 << anAttrMaskValue);
239 #ifdef DEBUG_MASK
240   anAttributeMask = 0xffffffff;
241 #endif
242   if ((myAttributeMask & anAttributeMask) == 0) {
243     // this is new attribute, OK
244     myAttributeMask |= anAttributeMask;
245     * aPrNode = &anAttr;
246     anAttr.SetSibling (aFirstAttr);
247   } else {
248     // this attribute may have already been installed  
249     LDOM_BasicAttribute * aCurrentAttr = (LDOM_BasicAttribute *) aFirstAttr;
250     while (aCurrentAttr) {
251       if (aCurrentAttr -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE)
252         if (LDOM_MemManager::CompareStrings (aNameStr, aHash,
253                                              aCurrentAttr -> GetName())) {
254           aCurrentAttr -> SetValue (anAttrValue, aDocument);
255           break;
256         }
257       aCurrentAttr = (LDOM_BasicAttribute *) aCurrentAttr -> mySibling;
258     }
259     if (aCurrentAttr == NULL) {
260       // this is new attribute, OK
261       * aPrNode = &anAttr;
262       anAttr.SetSibling (aFirstAttr);
263     }
264   }
265   return aLastCh;
266 }
267
268 //=======================================================================
269 //function : RemoveAttribute
270 //purpose  : Find and delete an attribute from list
271 //=======================================================================
272
273 const LDOM_BasicNode * LDOM_BasicElement::RemoveAttribute
274                                         (const LDOMBasicString& aName,
275                                          const LDOM_BasicNode   * aLastCh) const
276 {
277   //  Check attribute hash value against the current mask
278   const char * const aNameStr = aName.GetString();
279   const Standard_Integer aHash =
280     LDOM_MemManager::Hash (aNameStr, (Standard_Integer)strlen(aNameStr));
281   const unsigned int anAttrMaskValue = aHash & (8*sizeof(myAttributeMask) - 1);
282   const unsigned long anAttributeMask = (1 << anAttrMaskValue);
283 #ifdef DEBUG_MASK
284   anAttributeMask = 0xffffffff;
285 #endif
286   if ((myAttributeMask & anAttributeMask) == 0) {
287     ; // maybe cause for exception
288   } else {
289     const LDOM_BasicNode ** aPrevNode;  // dummy
290     const LDOM_BasicAttribute * anAttr = GetFirstAttribute (aLastCh, aPrevNode);
291     while (anAttr) {
292       if (anAttr -> getNodeType () == LDOM_Node::ATTRIBUTE_NODE)
293         if (LDOM_MemManager::CompareStrings(aNameStr,aHash,anAttr->GetName())) {
294           anAttr = NULL;
295           break;
296         }
297       anAttr = (const LDOM_BasicAttribute *) anAttr -> mySibling;
298     }
299   }
300   return aLastCh;
301 }
302
303 //=======================================================================
304 //function : RemoveChild
305 //purpose  : 
306 //=======================================================================
307
308 void LDOM_BasicElement::RemoveChild (const LDOM_BasicNode * aChild) const
309 {
310   const LDOM_BasicNode *  aNode = myFirstChild;
311   const LDOM_BasicNode ** aPrevNode = (const LDOM_BasicNode **) &myFirstChild;
312   while (aNode) {
313     if (aNode -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE)
314       break;
315     if (aNode == aChild) {
316       * aPrevNode = aNode -> GetSibling();
317       * (LDOM_BasicNode *) aChild = NULL;
318       break;
319     }
320     aPrevNode = (const LDOM_BasicNode **) & (aNode -> mySibling);
321     aNode = aNode -> GetSibling();
322   }
323   // here may be the cause to throw an exception
324 }
325
326 //=======================================================================
327 //function : AppendChild
328 //purpose  : 
329 //=======================================================================
330
331 void LDOM_BasicElement::AppendChild (const LDOM_BasicNode *  aChild,
332                                      const LDOM_BasicNode *& aLastChild) const
333 {
334   if (aLastChild) {
335     (const LDOM_BasicNode *&) aChild -> mySibling = aLastChild -> mySibling;
336     (const LDOM_BasicNode *&) aLastChild -> mySibling = aChild;
337   } else {
338     const LDOM_BasicNode * aNode = myFirstChild;
339     const LDOM_BasicNode ** aPrevNode = (const LDOM_BasicNode **) &myFirstChild;
340     while (aNode) {
341       if (aNode -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE) {
342         (const LDOM_BasicNode *&) aChild -> mySibling = aNode;
343         break;
344       }
345       aPrevNode = (const LDOM_BasicNode **) & (aNode -> mySibling);
346       aNode = aNode -> mySibling;
347     }
348     * aPrevNode = aChild;
349   }
350   aLastChild = aChild;
351 }
352
353 //=======================================================================
354 //function : AddElementsByTagName
355 //purpose  : Add to the List all sub-elements with the given name (recursive) 
356 //=======================================================================
357
358 void LDOM_BasicElement::AddElementsByTagName
359                 (LDOM_NodeList& aList, const LDOMBasicString& aTagName) const
360 {
361   const LDOM_BasicNode  * aNode         = myFirstChild;
362   const char            * aTagString    = aTagName.GetString();
363   while (aNode) {
364     if (aNode -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE)
365       break;
366     if (aNode -> getNodeType() == LDOM_Node::ELEMENT_NODE) {
367       LDOM_BasicElement& anElement = * (LDOM_BasicElement *) aNode;
368 //      if (anElement.GetTagName().equals(aTagName))
369       if (strcmp (anElement.GetTagName(), aTagString) == 0)
370         aList.Append (anElement);
371       anElement.AddElementsByTagName (aList, aTagName);
372     }
373     aNode = aNode -> GetSibling();
374   }
375 }
376
377 //=======================================================================
378 //function : AddAttributes
379 //purpose  : 
380 //=======================================================================
381
382 void LDOM_BasicElement::AddAttributes (LDOM_NodeList&       aList,
383                                        const LDOM_BasicNode * aLastChild) const
384 {
385   const LDOM_BasicNode * aBNode;
386   if (aLastChild)
387     aBNode = aLastChild -> GetSibling();
388   else
389     aBNode = GetFirstChild();
390   while (aBNode) {
391     if (aBNode -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE)
392       aList.Append (* aBNode);
393     aBNode = aBNode -> GetSibling();
394   }
395 }
396
397 //=======================================================================
398 //function : ReplaceElement
399 //purpose  : Copy data and children into this node from another one
400 //           The only preserved data is mySibling
401 //=======================================================================
402
403 void LDOM_BasicElement::ReplaceElement
404                                 (const LDOM_BasicElement&       anOtherElem,
405                                  const Handle(LDOM_MemManager)& aDocument)
406 {
407   myTagName          = anOtherElem.GetTagName();
408   myAttributeMask    = anOtherElem.myAttributeMask;
409   myFirstChild       = NULL;
410   const LDOM_BasicNode * aBNode = anOtherElem.GetFirstChild ();
411   const LDOM_BasicNode * aLastChild = NULL;
412
413   // Loop on children (non-attributes)
414   for (; aBNode != NULL; aBNode = aBNode -> GetSibling()) {
415     if (aBNode -> isNull())
416       continue;
417     LDOM_BasicNode * aNewBNode;
418     const LDOM_Node::NodeType aNewNodeType = aBNode -> getNodeType();
419     switch (aNewNodeType) {
420     case LDOM_Node::ELEMENT_NODE:
421       {
422         const LDOM_BasicElement& aBNodeElem = *(const LDOM_BasicElement*)aBNode;
423         const char * aTagString = aBNodeElem.GetTagName();
424         LDOM_BasicElement& aNewBNodeElem =
425           LDOM_BasicElement::Create (aTagString, (Standard_Integer)strlen(aTagString), aDocument);
426         aNewBNodeElem.ReplaceElement (aBNodeElem, aDocument); //reccur
427         aNewBNode = &aNewBNodeElem;
428         break;
429       }
430     case LDOM_Node::ATTRIBUTE_NODE:
431       goto loop_attr;
432     case LDOM_Node::TEXT_NODE:
433     case LDOM_Node::COMMENT_NODE:
434     case LDOM_Node::CDATA_SECTION_NODE:
435       {
436         const LDOM_BasicText& aBNodeText = * (const LDOM_BasicText *) aBNode;
437         aNewBNode = &LDOM_BasicText::Create (aNewNodeType,
438                                              LDOMString(aBNodeText.GetData(),
439                                                         aDocument),
440                                              aDocument);
441         break;
442       }
443     default: continue;
444     }
445     if (GetFirstChild())
446       (const LDOM_BasicNode *&) aLastChild -> mySibling = aNewBNode;
447     else
448       (const LDOM_BasicNode *&) myFirstChild = aNewBNode;
449     (const LDOM_BasicNode *&) aLastChild = aNewBNode;
450   }
451
452   // Loop on attributes (in the end of the list of children)
453 loop_attr:
454   LDOM_BasicNode * aLastAttr = (LDOM_BasicNode *) aLastChild;
455   for (; aBNode != NULL; aBNode = aBNode -> GetSibling()) {
456     Standard_Integer aHash;
457     if (aBNode -> isNull()) continue;
458     const LDOM_BasicAttribute * aBNodeAtt= (const LDOM_BasicAttribute *) aBNode;
459     LDOM_BasicAttribute * aNewAtt =
460       &LDOM_BasicAttribute::Create (aBNodeAtt -> GetName(), aDocument, aHash);
461     aNewAtt -> SetValue (aBNodeAtt->myValue, aDocument);
462     if (aLastAttr)
463       aLastAttr -> SetSibling (aNewAtt);
464     else
465       myFirstChild = aNewAtt;
466     aLastAttr = aNewAtt;
467   }
468 }