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

// Created on: 2001-06-26
// Created by: Alexander GRIGORIEV
// Copyright (c) 2001-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.

//AGV 140202: Replace(const char *) for (LDOMBasicString)=>myTagName

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

//=======================================================================
//function : Create
//purpose  : construction in the Document's data pool
//=======================================================================

LDOM_BasicElement& LDOM_BasicElement::Create
                                        (const char                     * aName,
                                         const Standard_Integer         aLen,
                                         const Handle(LDOM_MemManager)& aDoc)
{
  if (aName == NULL) {
    static LDOM_BasicElement aVoidElement;
    aVoidElement = LDOM_BasicElement();
    return aVoidElement;
  }
  void * aMem = aDoc -> Allocate (sizeof(LDOM_BasicElement));
  LDOM_BasicElement * aNewElem = new (aMem) LDOM_BasicElement;

  Standard_Integer aHash;
//  aDoc -> HashedAllocate (aString, strlen(aString), aNewElem -> myTagName);
  aNewElem -> myTagName =  aDoc -> HashedAllocate (aName, aLen, aHash);

  aNewElem -> myNodeType = LDOM_Node::ELEMENT_NODE;
  return * aNewElem;
}

//=======================================================================
//function : RemoveNodes
//purpose  : 
//=======================================================================

void LDOM_BasicElement::RemoveNodes ()
{
  const LDOM_BasicNode * aNode = (const LDOM_BasicNode *) myFirstChild;
  while (aNode) {
    const LDOM_BasicNode * aNext = aNode -> GetSibling();
    switch (aNode -> getNodeType ()) {
    case LDOM_Node::ELEMENT_NODE:
      {
        LDOM_BasicElement& anElement = * (LDOM_BasicElement *) aNode;
        anElement = NULL;
        break;
      }
    case LDOM_Node::ATTRIBUTE_NODE:
      {
        LDOM_BasicAttribute& anAttr = * (LDOM_BasicAttribute *) aNode;
        anAttr = NULL;
        break;
      }
    case LDOM_Node::TEXT_NODE:
    case LDOM_Node::COMMENT_NODE:
    case LDOM_Node::CDATA_SECTION_NODE:
      {
        LDOM_BasicText& aTxt = * (LDOM_BasicText *) aNode;
        aTxt = NULL;
        break;
      }
    default: ;
    }
    aNode = aNext;
  }
  myFirstChild = NULL;
}

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

LDOM_BasicElement& LDOM_BasicElement:: operator = (const LDOM_NullPtr * aNull)
{
  myTagName = NULL;
  RemoveNodes ();
  LDOM_BasicNode::operator= (aNull);
  return * this;
}

//=======================================================================
//function : LDOM_BasicElement
//purpose  : Constructor
//=======================================================================
/*
LDOM_BasicElement::LDOM_BasicElement (const LDOM_Element& anElement)
     : LDOM_BasicNode   (LDOM_Node::ELEMENT_NODE),
       myAttributeMask  (0),
       myFirstChild     (NULL)
{
//  LDOMString aNewTagName (anElement.getTagName(), anElement.myDocument);
//  myTagName = aNewTagName;
  const LDOM_BasicElement& anOther =
    (const LDOM_BasicElement&) anElement.Origin();
  myTagName = anOther.GetTagName();
}
*/
//=======================================================================
//function : ~LDOM_BasicElement
//purpose  : Destructor
//=======================================================================

LDOM_BasicElement::~LDOM_BasicElement ()
{
  myTagName = NULL;
  RemoveNodes ();
}

//=======================================================================
//function : GetLastChild
//purpose  : 
//=======================================================================

const LDOM_BasicNode * LDOM_BasicElement::GetLastChild () const
{
  const LDOM_BasicNode * aNode = myFirstChild;
  if (aNode) {
    if (aNode -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE)
      aNode = NULL;
    else
      while (aNode -> mySibling) {
        if (aNode -> mySibling -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE)
          break;
        aNode = aNode -> mySibling;
      }
  }
  return aNode;
}

//=======================================================================
//function : GetAttribute
//purpose  : 
//=======================================================================

const LDOM_BasicAttribute& LDOM_BasicElement::GetAttribute
                                     (const LDOMBasicString& aName,
                                      const LDOM_BasicNode   * aLastCh) const
{
  const LDOM_BasicNode * aNode;
  if (aLastCh)
    aNode = aLastCh -> GetSibling (); 
  else
    aNode = myFirstChild;
  const char * aNameStr = aName.GetString();
  while (aNode) {
    if (aNode -> getNodeType () == LDOM_Node::ATTRIBUTE_NODE) {
      const LDOM_BasicAttribute * anAttr = (const LDOM_BasicAttribute *) aNode;
      if (!strcmp (aNameStr, anAttr -> GetName()))
        return * anAttr;
    }
    aNode = aNode -> mySibling;
  }
static const LDOM_BasicAttribute aNullAttribute;
  return aNullAttribute;
}

//=======================================================================
//function : GetFirstAttribute
//purpose  : private method
//=======================================================================

const LDOM_BasicAttribute * LDOM_BasicElement::GetFirstAttribute
                                    (const LDOM_BasicNode *&  theLastCh,
                                     const LDOM_BasicNode **& thePrevNode) const
{
  //  Find the First Attribute as well as the Last Child among siblings
  const LDOM_BasicNode * aFirstAttr;
  const LDOM_BasicNode ** aPrevNode;
  if (theLastCh) {
    aFirstAttr = theLastCh -> mySibling; 
    aPrevNode  = (const LDOM_BasicNode **) &(theLastCh -> mySibling);
    while (aFirstAttr) {
      if (aFirstAttr -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE) break;
      aPrevNode = (const LDOM_BasicNode **) & (aFirstAttr -> mySibling);
      aFirstAttr = aFirstAttr -> mySibling;
    }
  } else {
    aFirstAttr = myFirstChild;
    aPrevNode  = (const LDOM_BasicNode **) &myFirstChild;
    while (aFirstAttr) {
      if (aFirstAttr -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE) break;
      if (aFirstAttr -> isNull() == Standard_False) theLastCh = aFirstAttr;
      aPrevNode = (const LDOM_BasicNode **) & (aFirstAttr -> mySibling);
      aFirstAttr = aFirstAttr -> mySibling;
    }
  }
  thePrevNode = aPrevNode;
  return (LDOM_BasicAttribute *) aFirstAttr;
}

//=======================================================================
//function : AddAttribute
//purpose  : Add or replace an attribute
//=======================================================================

const LDOM_BasicNode * LDOM_BasicElement::AddAttribute
                                  (const LDOMBasicString&         anAttrName,
                                   const LDOMBasicString&         anAttrValue,
                                   const Handle(LDOM_MemManager)& aDocument,
                                   const LDOM_BasicNode           * aLastCh)
{
  //  Create attribute
  Standard_Integer aHash;
  LDOM_BasicAttribute& anAttr =
    LDOM_BasicAttribute::Create (anAttrName, aDocument, aHash);
  anAttr.myValue = anAttrValue;

  //  Initialize the loop of attribute name search
  const LDOM_BasicNode ** aPrNode;
  const LDOM_BasicAttribute * aFirstAttr = GetFirstAttribute (aLastCh, aPrNode);
  const char * aNameStr = anAttrName.GetString();

  //  Check attribute hash value against the current mask
  const unsigned int anAttrMaskValue = aHash & (8*sizeof(myAttributeMask) - 1);
  const unsigned long anAttributeMask = (1 << anAttrMaskValue);
#ifdef DEBUG_MASK
  anAttributeMask = 0xffffffff;
#endif
  if ((myAttributeMask & anAttributeMask) == 0) {
    // this is new attribute, OK
    myAttributeMask |= anAttributeMask;
    * aPrNode = &anAttr;
    anAttr.SetSibling (aFirstAttr);
  } else {
    // this attribute may have already been installed  
    LDOM_BasicAttribute * aCurrentAttr = (LDOM_BasicAttribute *) aFirstAttr;
    while (aCurrentAttr) {
      if (aCurrentAttr -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE)
        if (LDOM_MemManager::CompareStrings (aNameStr, aHash,
                                             aCurrentAttr -> GetName())) {
          aCurrentAttr -> SetValue (anAttrValue, aDocument);
          break;
        }
      aCurrentAttr = (LDOM_BasicAttribute *) aCurrentAttr -> mySibling;
    }
    if (aCurrentAttr == NULL) {
      // this is new attribute, OK
      * aPrNode = &anAttr;
      anAttr.SetSibling (aFirstAttr);
    }
  }
  return aLastCh;
}

//=======================================================================
//function : RemoveAttribute
//purpose  : Find and delete an attribute from list
//=======================================================================

const LDOM_BasicNode * LDOM_BasicElement::RemoveAttribute
                                        (const LDOMBasicString& aName,
                                         const LDOM_BasicNode   * aLastCh) const
{
  //  Check attribute hash value against the current mask
  const char * const aNameStr = aName.GetString();
  const Standard_Integer aHash =
    LDOM_MemManager::Hash (aNameStr, strlen(aNameStr));
  const unsigned int anAttrMaskValue = aHash & (8*sizeof(myAttributeMask) - 1);
  const unsigned long anAttributeMask = (1 << anAttrMaskValue);
#ifdef DEBUG_MASK
  anAttributeMask = 0xffffffff;
#endif
  if ((myAttributeMask & anAttributeMask) == 0) {
    ; // maybe cause for exception
  } else {
    const LDOM_BasicNode ** aPrevNode;  // dummy
    const LDOM_BasicAttribute * anAttr = GetFirstAttribute (aLastCh, aPrevNode);
    while (anAttr) {
      if (anAttr -> getNodeType () == LDOM_Node::ATTRIBUTE_NODE)
        if (LDOM_MemManager::CompareStrings(aNameStr,aHash,anAttr->GetName())) {
          anAttr = NULL;
          break;
        }
      anAttr = (const LDOM_BasicAttribute *) anAttr -> mySibling;
    }
  }
  return aLastCh;
}

//=======================================================================
//function : RemoveChild
//purpose  : 
//=======================================================================

void LDOM_BasicElement::RemoveChild (const LDOM_BasicNode * aChild) const
{
  const LDOM_BasicNode *  aNode = myFirstChild;
  const LDOM_BasicNode ** aPrevNode = (const LDOM_BasicNode **) &myFirstChild;
  while (aNode) {
    if (aNode -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE)
      break;
    if (aNode == aChild) {
      * aPrevNode = aNode -> GetSibling();
      * (LDOM_BasicNode *) aChild = NULL;
      break;
    }
    aPrevNode = (const LDOM_BasicNode **) & (aNode -> mySibling);
    aNode = aNode -> GetSibling();
  }
  // here may be the cause to throw an exception
}

//=======================================================================
//function : AppendChild
//purpose  : 
//=======================================================================

void LDOM_BasicElement::AppendChild (const LDOM_BasicNode *  aChild,
                                     const LDOM_BasicNode *& aLastChild) const
{
  if (aLastChild) {
    (const LDOM_BasicNode *&) aChild -> mySibling = aLastChild -> mySibling;
    (const LDOM_BasicNode *&) aLastChild -> mySibling = aChild;
  } else {
    const LDOM_BasicNode * aNode = myFirstChild;
    const LDOM_BasicNode ** aPrevNode = (const LDOM_BasicNode **) &myFirstChild;
    while (aNode) {
      if (aNode -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE) {
        (const LDOM_BasicNode *&) aChild -> mySibling = aNode;
        break;
      }
      aPrevNode = (const LDOM_BasicNode **) & (aNode -> mySibling);
      aNode = aNode -> mySibling;
    }
    * aPrevNode = aChild;
  }
  aLastChild = aChild;
}

//=======================================================================
//function : AddElementsByTagName
//purpose  : Add to the List all sub-elements with the given name (recursive) 
//=======================================================================

void LDOM_BasicElement::AddElementsByTagName
                (LDOM_NodeList& aList, const LDOMBasicString& aTagName) const
{
  const LDOM_BasicNode  * aNode         = myFirstChild;
  const char            * aTagString    = aTagName.GetString();
  while (aNode) {
    if (aNode -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE)
      break;
    if (aNode -> getNodeType() == LDOM_Node::ELEMENT_NODE) {
      LDOM_BasicElement& anElement = * (LDOM_BasicElement *) aNode;
//      if (anElement.GetTagName().equals(aTagName))
      if (strcmp (anElement.GetTagName(), aTagString) == 0)
        aList.Append (anElement);
      anElement.AddElementsByTagName (aList, aTagName);
    }
    aNode = aNode -> GetSibling();
  }
}

//=======================================================================
//function : AddAttributes
//purpose  : 
//=======================================================================

void LDOM_BasicElement::AddAttributes (LDOM_NodeList&       aList,
                                       const LDOM_BasicNode * aLastChild) const
{
  const LDOM_BasicNode * aBNode;
  if (aLastChild)
    aBNode = aLastChild -> GetSibling();
  else
    aBNode = GetFirstChild();
  while (aBNode) {
    if (aBNode -> getNodeType() == LDOM_Node::ATTRIBUTE_NODE)
      aList.Append (* aBNode);
    aBNode = aBNode -> GetSibling();
  }
}

//=======================================================================
//function : ReplaceElement
//purpose  : Copy data and children into this node from another one
//           The only preserved data is mySibling
//=======================================================================

void LDOM_BasicElement::ReplaceElement
                                (const LDOM_BasicElement&       anOtherElem,
                                 const Handle(LDOM_MemManager)& aDocument)
{
  myTagName          = anOtherElem.GetTagName();
  myAttributeMask    = anOtherElem.myAttributeMask;
  myFirstChild       = NULL;
  const LDOM_BasicNode * aBNode = anOtherElem.GetFirstChild ();
  const LDOM_BasicNode * aLastChild = NULL;

  // Loop on children (non-attributes)
  for (; aBNode != NULL; aBNode = aBNode -> GetSibling()) {
    if (aBNode -> isNull())
      continue;
    LDOM_BasicNode * aNewBNode;
    const LDOM_Node::NodeType aNewNodeType = aBNode -> getNodeType();
    switch (aNewNodeType) {
    case LDOM_Node::ELEMENT_NODE:
      {
        const LDOM_BasicElement& aBNodeElem = *(const LDOM_BasicElement*)aBNode;
        const char * aTagString = aBNodeElem.GetTagName();
        LDOM_BasicElement& aNewBNodeElem =
          LDOM_BasicElement::Create (aTagString, strlen(aTagString), aDocument);
        aNewBNodeElem.ReplaceElement (aBNodeElem, aDocument); //reccur
        aNewBNode = &aNewBNodeElem;
        break;
      }
    case LDOM_Node::ATTRIBUTE_NODE:
      goto loop_attr;
    case LDOM_Node::TEXT_NODE:
    case LDOM_Node::COMMENT_NODE:
    case LDOM_Node::CDATA_SECTION_NODE:
      {
        const LDOM_BasicText& aBNodeText = * (const LDOM_BasicText *) aBNode;
        aNewBNode = &LDOM_BasicText::Create (aNewNodeType,
                                             LDOMString(aBNodeText.GetData(),
                                                        aDocument),
                                             aDocument);
        break;
      }
    default: continue;
    }
    if (GetFirstChild())
      (const LDOM_BasicNode *&) aLastChild -> mySibling = aNewBNode;
    else
      (const LDOM_BasicNode *&) myFirstChild = aNewBNode;
    (const LDOM_BasicNode *&) aLastChild = aNewBNode;
  }

  // Loop on attributes (in the end of the list of children)
loop_attr:
  LDOM_BasicNode * aLastAttr = (LDOM_BasicNode *) aLastChild;
  for (; aBNode != NULL; aBNode = aBNode -> GetSibling()) {
    Standard_Integer aHash;
    if (aBNode -> isNull()) continue;
    const LDOM_BasicAttribute * aBNodeAtt= (const LDOM_BasicAttribute *) aBNode;
    LDOM_BasicAttribute * aNewAtt =
      &LDOM_BasicAttribute::Create (aBNodeAtt -> GetName(), aDocument, aHash);
    aNewAtt -> SetValue (aBNodeAtt->myValue, aDocument);
    if (aLastAttr)
      aLastAttr -> SetSibling (aNewAtt);
    else
      myFirstChild = aNewAtt;
    aLastAttr = aNewAtt;
  }
}
Commit	Line	Data
b311480e	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
7fd59977	21
	22	#include <LDOM_BasicElement.hxx>
	23	#include <LDOM_BasicAttribute.hxx>
	24	#include <LDOM_BasicText.hxx>
	25	#include <LDOM_MemManager.hxx>
	26
7fd59977	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, 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, 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	}