wirispluginengine 3.62.0.1322 → 7.14.0.1422

data/lib/com/wiris/util/xml/XmlSerializer.rb

@@ -1,485 +1,531 @@
 module WirisPlugin
 include  Wiris
-require('com/wiris/util/xml/WXmlUtils.rb')
-  class XmlSerializer
-  include Wiris
+    require('com/wiris/util/xml/WXmlUtils.rb')
+    class XmlSerializer
+    include Wiris
 
-  MODE_READ = 0
-  MODE_WRITE = 1
-  MODE_REGISTER = 2
-  MODE_CACHE = 3
-    attr_accessor :mode
-    attr_accessor :element
-    attr_accessor :children
-    attr_accessor :child
-    attr_accessor :elementStack
-    attr_accessor :childrenStack
-    attr_accessor :childStack
-    attr_accessor :tags
-    attr_accessor :rawxmls
-    attr_accessor :currentTag
-    attr_accessor :cache
-    attr_accessor :cacheTagStackCount
-    attr_accessor :ignore
-    attr_accessor :ignoreTagStackCount
-    def initialize()
-      super()
-      @tags = Hash.new()
-      @elementStack = Array.new()
-      @childrenStack = Array.new()
-      @childStack = Array.new()
-      @cacheTagStackCount = 0
-      @ignoreTagStackCount = 0
-    end
-    def getMode()
-      return @mode
-    end
-    def read(xml)
-      document = Xml::parse(xml)
-      setCurrentElement(document)
-      @mode = XmlSerializer::MODE_READ
-      return readNode()
-    end
-    def write(s)
-      @mode = XmlSerializer::MODE_WRITE
-      @element = Xml::createDocument()
-      @rawxmls = Array.new()
-      s::onSerialize(self)
-      res = element::toString()
-        for i in 0..rawxmls::length()-1
-          start = res::indexOf(("<rawXml id=\""+i.to_s)+"\"")
-          if start!=-1
-            _end = res::indexOf(">",start)
-            res = (Std::substr(res,0,start).to_s+rawxmls::_(i).to_s)+Std::substr(res,_end+1).to_s
-          end
-          i+=1
-        end
-      return res
-    end
-    def beginTagIf(tag,current,desired)
-      if @mode==MODE_READ
-        if beginTag(tag)
-          return desired
+    MODE_READ = 0
+    MODE_WRITE = 1
+    MODE_REGISTER = 2
+    MODE_CACHE = 3
+        attr_accessor :mode
+        attr_accessor :element
+        attr_accessor :children
+        attr_accessor :child
+        attr_accessor :elementStack
+        attr_accessor :childrenStack
+        attr_accessor :childStack
+        attr_accessor :tags
+        attr_accessor :rawxmls
+        attr_accessor :currentTag
+        attr_accessor :cache
+        attr_accessor :cacheTagStackCount
+        attr_accessor :ignore
+        attr_accessor :ignoreTagStackCount
+        def initialize()
+            super()
+            @tags = Hash.new()
+            @elementStack = Array.new()
+            @childrenStack = Array.new()
+            @childStack = Array.new()
+            self.cacheTagStackCount = 0
+            self.ignoreTagStackCount = 0
         end
-      else 
-        if current==desired
-          beginTag(tag)
+        def getMode()
+            return self.mode
         end
-      end
-      return current
-    end
-    def beginTagIfBool(tag,current,desired)
-      if @mode==MODE_READ
-        if beginTag(tag)
-          return desired
+        def read(xml)
+            document = Xml::parse(xml)
+            self.setCurrentElement(document)
+            self.mode = XmlSerializer::MODE_READ
+            return readNode()
         end
-      else 
-        if current==desired
-          beginTag(tag)
+        def readXml(xml)
+            self.setCurrentElement(xml)
+            self.mode = XmlSerializer::MODE_READ
+            return readNode()
         end
-      end
-      return current
-    end
-    def beginTag(tag)
-      if @mode==MODE_READ
-        if ((currentChild()!=nil)&&(currentChild()::nodeType==Xml::Element))&&(tag==currentChild()::nodeName)
-          pushState()
-          setCurrentElement(currentChild())
-        else 
-          return false
-        end
-      else 
-        if @mode==MODE_WRITE
-          if isIgnoreTag(tag)||(@ignoreTagStackCount>0)
-            @ignoreTagStackCount+=1
-          else 
-            child = @element::createElement_(tag)
-            @element::addChild(child)
-            @element = child
-          end
-        else 
-          if (@mode==MODE_REGISTER)&&(@currentTag==nil)
-            @currentTag = tag
-          else 
-            if @mode==MODE_CACHE
-              @cacheTagStackCount+=1
-            end
-          end
-        end
-      end
-      return true
-    end
-    def endTag()
-      if @mode==MODE_READ
-        @element = @element::parent_()
-        popState()
-        nextChild()
-      else 
-        if @mode==MODE_WRITE
-          if @ignoreTagStackCount>0
-            @ignoreTagStackCount-=1
-          else 
-            @element = @element::parent_()
-          end
-        else 
-          if @mode==MODE_CACHE
-            if @cacheTagStackCount>0
-              @cacheTagStackCount-=1
+        def write(s)
+            self.mode = XmlSerializer::MODE_WRITE
+            self.element = Xml::createDocument()
+            self.rawxmls = Array.new()
+            s::onSerialize(self)
+            res = self.element::toString()
+            if StringTools::startsWith(res,"<__document")
+                res = Std::substr(res,res::indexOf(">") + 1)
+            end
+            if StringTools::endsWith(res,"</__document>")
+                res = Std::substr(res,0,res::length() - "</__document>"::length())
+            end
+            for i in 0..self.rawxmls::length() - 1
+                start = res::indexOf(("<rawXml id=\"" + i.to_s) + "\"")
+                if start != -1
+                    _end = res::indexOf(">",start)
+                    res = (Std::substr(res,0,start).to_s + self.rawxmls::_(i).to_s) + Std::substr(res,_end + 1).to_s
+                end
+                i+=1
+            end
+            return res
+        end
+        def beginTagIf(tag, current, desired)
+            if @mode == MODE_READ
+                if beginTag(tag)
+                    return desired
+                end
             else 
-              @mode = MODE_WRITE
-              @element = @element::parent_()
+                if current == desired
+                    beginTag(tag)
+                end
             end
-          end
+            return current
         end
-      end
-    end
-    def attributeString(name,value,def_)
-      if @mode==XmlSerializer::MODE_READ
-        value = WXmlUtils::getAttribute(@element,name)
-        if value==nil
-          value = def_
-        end
-      else 
-        if @mode==XmlSerializer::MODE_WRITE
-          if ((value!=nil)&&!((value==def_)))&&(@ignoreTagStackCount==0)
-            WXmlUtils::setAttribute(@element,name,value)
-          end
-        end
-      end
-      return value
-    end
-    def cacheAttribute(name,value,def_)
-      if @mode==XmlSerializer::MODE_WRITE
-        if @cache
-          value = attributeString(name,value,def_)
-          @mode = XmlSerializer::MODE_CACHE
-          @cacheTagStackCount = 0
-        end
-      else 
-        value = attributeString(name,value,def_)
-      end
-      return value
-    end
-    def attributeBoolean(name,value,def_)
-      return XmlSerializer::parseBoolean(attributeString(name,XmlSerializer::booleanToString(value),XmlSerializer::booleanToString(def_)))
-    end
-    def attributeInt(name,value,def_)
-      return Std::parseInt(attributeString(name,""+value.to_s,""+def_.to_s))
-    end
-    def attributeIntArray(name,value,def_)
-      return stringToArray(attributeString(name,arrayToString(value),arrayToString(def_)))
-    end
-    def arrayToString(a)
-      if a==nil
-        return nil
-      end
-      sb = StringBuf.new()
-        for i in 0..a::length-1
-          if i!=0
-            sb::add(",")
-          end
-          sb::add(a[i].to_s+"")
-          i+=1
-        end
-      return sb::toString()
-    end
-    def stringToArray(s)
-      if s==nil
-        return nil
-      end
-      ss = s::split(",")
-      a = []
-        for i in 0..ss::length-1
-          a[i] = Std::parseInt(ss[i])
-          i+=1
-        end
-      return a
-    end
-    def attributeFloat(name,value,def_)
-      return Std::parseFloat(attributeString(name,""+value.to_s,""+def_.to_s))
-    end
-    def textContent(content)
-      if @mode==MODE_READ
-        content = XmlSerializer::getXmlTextContent(@element)
-      else 
-        if ((@mode==MODE_WRITE)&&(content!=nil))&&(@ignoreTagStackCount==0)
-          if (content::length()>100)||(StringTools::startsWith(content,"<")&&StringTools::endsWith(content,">"))
-            textNode = @element::createCData_(content)
-          else 
-            textNode = WXmlUtils::createPCData(@element,content)
-          end
-          element::addChild(textNode)
-        end
-      end
-      return content
-    end
-    def base64Content(data)
-      b64 = BaseCode.new(Bytes::ofString("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"))
-      if @mode==MODE_READ
-        content = textContent(nil)
-        data = b64::decodeBytes(Bytes::ofString(content))
-      else 
-        if @mode==MODE_WRITE
-          textContent(b64::encodeBytes(data)::toString())
-        end
-      end
-      return data
-    end
-    def rawXml(xml)
-      if @mode==MODE_READ
-        raise Exception,"Should not use rawXml() function on read operation!"
-      else 
-        if @mode==MODE_WRITE
-          raw = @element::createElement_("rawXml")
-          raw::set("id",""+rawxmls::length().to_s)
-          rawxmls::push(xml)
-          element::addChild(raw)
-        else 
-          if @mode==MODE_REGISTER
-            @currentTag = getMainTag(xml)
-          end
-        end
-      end
-      return xml
-    end
-    def booleanContent(content)
-      return XmlSerializer::parseBoolean(textContent(XmlSerializer::booleanToString(content)))
-    end
-    def floatContent(d)
-      return Std::parseFloat(textContent(d.to_s+""))
-    end
-    def self.getXmlTextContent(element)
-      if (element::nodeType==Xml::CData)||(element::nodeType==Xml::PCData)
-        return WXmlUtils::getNodeValue(element)
-      else 
-        if (element::nodeType==Xml::Document)||(element::nodeType==Xml::Element)
-          sb = StringBuf.new()
-          children = element::iterator()
-          while children::hasNext()
-            sb::add(getXmlTextContent(children::next()))
-          end
-          return sb::toString()
-        else 
-          return ""
-        end
-      end
-    end
-    def serializeChild(s)
-      if @mode==XmlSerializer::MODE_READ
-        child = currentChild()
-        if child!=nil
-          s = (readNode())
-        else 
-          s = nil
-        end
-      else 
-        if (@mode==XmlSerializer::MODE_WRITE)&&(s!=nil)
-          (s)::onSerialize(self)
-        end
-      end
-      return s
-    end
-    def serializeArray(array,tagName)
-      if @mode==XmlSerializer::MODE_READ
-        array = Array.new()
-        child = currentChild()
-        while (child!=nil)&&((tagName==nil)||(tagName==child::nodeName))
-          elem = (readNode())
-          array::push(elem)
-          child = currentChild()
-        end
-      else 
-        if ((@mode==XmlSerializer::MODE_WRITE)&&(array!=nil))&&(array::length()>0)
-          items = array::iterator()
-          while items::hasNext()
-            (items::next())::onSerialize(self)
-          end
-        end
-      end
-      return array
-    end
-    def serializeChildName(s,tagName)
-      if @mode==MODE_READ
-        child = currentChild()
-        if (child!=nil)&&(child::nodeName==tagName)
-          s = serializeChild(s)
-        end
-      else 
-        if @mode==MODE_WRITE
-          s = serializeChild(s)
-        end
-      end
-      return s
-    end
-    def serializeArrayName(array,tagName)
-      if @mode==MODE_READ
-        if beginTag(tagName)
-          array = serializeArray(array,nil)
-          endTag()
-        end
-      else 
-        if ((@mode==MODE_WRITE)&&(array!=nil))&&(array::length()>0)
-          element = @element
-          @element = element::createElement_(tagName)
-          element::addChild(@element)
-          array = serializeArray(array,nil)
-          @element = element
-        else 
-          if @mode==MODE_REGISTER
-            beginTag(tagName)
-          end
-        end
-      end
-      return array
-    end
-    def register(elem)
-      tags::set(getTagName(elem),elem)
-    end
-    def getTagName(elem)
-      mode = @mode
-      @mode = XmlSerializer::MODE_REGISTER
-      @currentTag = nil
-      elem::onSerialize(self)
-      @mode = mode
-      return @currentTag
-    end
-    def readNode()
-      if !tags::exists(currentChild()::nodeName)
-        raise Exception,("Tag "+currentChild()::nodeName.to_s)+" not registered."
-      end
-      model = tags::get(currentChild()::nodeName)
-      return readNodeModel(model)
-    end
-    def readNodeModel(model)
-      node = model::newInstance()
-      node::onSerialize(self)
-      return node
-    end
-    def setCurrentElement(element)
-      @element = element
-      @children = element::elements()
-      @child = nil
-    end
-    def nextChild()
-      if @children::hasNext()
-        @child = @children::next()
-      else 
-        @child = nil
-      end
-      return @child
-    end
-    def currentChild()
-      if (@child==nil)&&@children::hasNext()
-        @child = @children::next()
-      end
-      return @child
-    end
-    def pushState()
-      elementStack::push(@element)
-      childrenStack::push(@children)
-      childStack::push(@child)
-    end
-    def popState()
-      @element = elementStack::pop()
-      @children = childrenStack::pop()
-      @child = childStack::pop()
-    end
-    def self.parseBoolean(s)
-      return (s::toLowerCase()=="true")||(s=="1")
-    end
-    def self.booleanToString(b)
-      return b ? "true" : "false"
-    end
-    def childString(name,value,def_)
-      if !((@mode==MODE_WRITE)&&(((value==nil)&&(def_==nil))||((value!=nil)&&(value==def_))))
-        if beginTag(name)
-          value = textContent(value)
-          endTag()
-        end
-      end
-      return value
-    end
-    def childInt(name,value,def_)
-      return Std::parseInt(childString(name,""+value.to_s,""+def_.to_s))
-    end
-    def setCached(cache)
-      @cache = cache
-    end
-    def beginCache()
-      if @cache&&(@mode==XmlSerializer::MODE_WRITE)
-        @mode = XmlSerializer::MODE_CACHE
-      end
-    end
-    def endCache()
-      if @mode==XmlSerializer::MODE_CACHE
-        @mode = XmlSerializer::MODE_WRITE
-      end
-    end
-    def getMainTag(xml)
-      i = 0
-      loop do
-        i = xml::indexOf("<",i)
-        i+=1
-        c = Std::charCodeAt(xml,i)
-      break if not (c!=33)&&(c!=63)
-      end
-      _end = [">", " ", "/"]
-      min = 0
-        for j in 0.._end::length-1
-          n = xml::indexOf(_end[j])
-          if (n!=-1)&&(n<min)
-            n = min
-          end
-          j+=1
-        end
-      return Std::substr(xml,i,min)
-    end
-    def serializeXml(tag,elem)
-      if @mode==MODE_READ
-        if (tag==nil)||((currentChild()!=nil)&&(currentChild()::nodeName==tag))
-          elem = currentChild()
-          nextChild()
-        end
-      else 
-        if @mode==MODE_WRITE
-          if (elem!=nil)&&(@ignoreTagStackCount==0)
-            imported = WXmlUtils::importXml(elem,@element)
-            element::addChild(imported)
-          end
-        else 
-          if @mode==MODE_REGISTER
-            beginTag(tag)
-          end
-        end
-      end
-      return elem
-    end
-    def setIgnoreTags(ignore)
-      @ignore = ignore
-    end
-    def isIgnoreTag(s)
-      if @ignore!=nil
-        i = ignore::iterator()
-        while i::hasNext()
-          if (i::next()==s)
+        def beginTagIfBool(tag, current, desired)
+            if @mode == MODE_READ
+                if beginTag(tag)
+                    return desired
+                end
+            else 
+                if current == desired
+                    beginTag(tag)
+                end
+            end
+            return current
+        end
+        def beginTag(tag)
+            if @mode == MODE_READ
+                if ((self.currentChild() != nil) && (self.currentChild()::nodeType == Xml::Element)) && (tag == self.currentChild()::nodeName)
+                    self.pushState()
+                    self.setCurrentElement(self.currentChild())
+                else 
+                    return false
+                end
+            else 
+                if @mode == MODE_WRITE
+                    if self.isIgnoreTag(tag) || (self.ignoreTagStackCount > 0)
+                        self.ignoreTagStackCount+=1
+                    else 
+                        child = @element::createElement_(tag)
+                        @element::addChild(child)
+                        @element = child
+                    end
+                else 
+                    if (@mode == MODE_REGISTER) && (self.currentTag == nil)
+                        self.currentTag = tag
+                    else 
+                        if @mode == MODE_CACHE
+                            self.cacheTagStackCount+=1
+                        end
+                    end
+                end
+            end
             return true
-          end
         end
-      end
-      return false
-    end
-    def self.compareStrings(a,b)
-      an = a::length()
-      bn = b::length()
-      n = (an>bn) ? bn : an
-        for i in 0..n-1
-          c = Std::charCodeAt(a,i)-Std::charCodeAt(b,i)
-          if c!=0
-            return c
-          end
-          i+=1
-        end
-      return a::length()-b::length()
+        def endTag()
+            if self.mode == MODE_READ
+                self.element = @element::parent_()
+                self.popState()
+                self.nextChild()
+            else 
+                if self.mode == MODE_WRITE
+                    if self.ignoreTagStackCount > 0
+                        self.ignoreTagStackCount-=1
+                    else 
+                        self.element = @element::parent_()
+                    end
+                else 
+                    if self.mode == MODE_CACHE
+                        if self.cacheTagStackCount > 0
+                            self.cacheTagStackCount-=1
+                        else 
+                            self.mode = MODE_WRITE
+                            self.element = @element::parent_()
+                        end
+                    end
+                end
+            end
+        end
+        def attributeString(name, value, def_)
+            if self.mode == XmlSerializer::MODE_READ
+                value = WXmlUtils::getAttribute(self.element,name)
+                if value == nil
+                    value = def_
+                end
+            else 
+                if self.mode == XmlSerializer::MODE_WRITE
+                    if ((value != nil) && !((value == def_))) && (self.ignoreTagStackCount == 0)
+                        WXmlUtils::setAttribute(self.element,name,value)
+                    end
+                end
+            end
+            return value
+        end
+        def cacheAttribute(name, value, def_)
+            if self.mode == XmlSerializer::MODE_WRITE
+                if self.cache
+                    value = attributeString(name,value,def_)
+                    self.mode = XmlSerializer::MODE_CACHE
+                    self.cacheTagStackCount = 0
+                end
+            else 
+                value = attributeString(name,value,def_)
+            end
+            return value
+        end
+        def attributeBoolean(name, value, def_)
+            return XmlSerializer::parseBoolean(attributeString(name,XmlSerializer::booleanToString(value),XmlSerializer::booleanToString(def_)))
+        end
+        def attributeInt(name, value, def_)
+            return Std::parseInt(attributeString(name,"" + value.to_s,"" + def_.to_s))
+        end
+        def attributeIntArray(name, value, def_)
+            return stringToArray(attributeString(name,arrayToString(value),arrayToString(def_)))
+        end
+        def attributeStringArray(name, value, def_)
+            return stringToArrayString(attributeString(name,stringArrayToString(value),stringArrayToString(def_)))
+        end
+        def arrayToString(a)
+            if a == nil
+                return nil
+            end
+            sb = StringBuf.new()
+            for i in 0..a::length - 1
+                if i != 0
+                    sb::add(",")
+                end
+                sb::add(a[i].to_s + "")
+                i+=1
+            end
+            return sb::toString()
+        end
+        def stringArrayToString(a)
+            if a == nil
+                return nil
+            end
+            sb = StringBuf.new()
+            for i in 0..a::length - 1
+                if i != 0
+                    sb::add(",")
+                end
+                sb::add(a[i])
+                i+=1
+            end
+            return sb::toString()
+        end
+        def stringToArrayString(s)
+            if s == nil
+                return nil
+            end
+            return s::split(",")
+        end
+        def stringToArray(s)
+            if s == nil
+                return nil
+            end
+            ss = s::split(",")
+            a = []
+            for i in 0..ss::length - 1
+                a[i] = Std::parseInt(ss[i])
+                i+=1
+            end
+            return a
+        end
+        def attributeFloat(name, value, def_)
+            return Std::parseFloat(attributeString(name,"" + value.to_s,"" + def_.to_s))
+        end
+        def textContent(content)
+            if self.mode == MODE_READ
+                content = XmlSerializer::getXmlTextContent(self.element)
+            else 
+                if ((self.mode == MODE_WRITE) && (content != nil)) && (self.ignoreTagStackCount == 0)
+                    if (content::length() > 100) || (StringTools::startsWith(content,"<") && StringTools::endsWith(content,">"))
+                        k = content::indexOf("]]>")
+                        i = 0
+                        while k > -1
+                            subcontent = Std::substr(content,i,(k - i) + 2)
+                            textNode = @element::createCData_(subcontent)
+                            self.element::addChild(textNode)
+                            i = k + 2
+                            k = content::indexOf("]]>",i)
+                        end
+                        str = Std::substr(content,i)
+                        textNode = @element::createCData_(str)
+                        self.element::addChild(textNode)
+                    else 
+                        textNode = WXmlUtils::createPCData(@element,content)
+                        self.element::addChild(textNode)
+                    end
+                end
+            end
+            return content
+        end
+        def base64Content(data)
+            b64 = BaseCode.new(Bytes::ofString("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"))
+            if @mode == MODE_READ
+                content = textContent(nil)
+                data = b64::decodeBytes(Bytes::ofString(content))
+            else 
+                if @mode == MODE_WRITE
+                    textContent(b64::encodeBytes(data)::toString())
+                end
+            end
+            return data
+        end
+        def rawXml(xml)
+            if self.mode == MODE_READ
+                raise Exception,"Should not use rawXml() function on read operation!"
+            else 
+                if self.mode == MODE_WRITE
+                    raw = @element::createElement_("rawXml")
+                    raw::set("id","" + self.rawxmls::length().to_s)
+                    self.rawxmls::push(xml)
+                    self.element::addChild(raw)
+                else 
+                    if self.mode == MODE_REGISTER
+                        self.currentTag = self.getMainTag(xml)
+                    end
+                end
+            end
+            return xml
+        end
+        def booleanContent(content)
+            return XmlSerializer::parseBoolean(textContent(XmlSerializer::booleanToString(content)))
+        end
+        def floatContent(d)
+            return Std::parseFloat(textContent(d.to_s + ""))
+        end
+        def self.getXmlTextContent(element)
+            if (element::nodeType == Xml::CData) || (element::nodeType == Xml::PCData)
+                return WXmlUtils::getNodeValue(element)
+            else 
+                if (element::nodeType == Xml::Document) || (element::nodeType == Xml::Element)
+                    sb = StringBuf.new()
+                    children = element::iterator()
+                    while children::hasNext()
+                        sb::add(XmlSerializer.getXmlTextContent(children::next()))
+                    end
+                    return sb::toString()
+                else 
+                    return ""
+                end
+            end
+        end
+        def serializeChild(s)
+            if self.mode == XmlSerializer::MODE_READ
+                child = self.currentChild()
+                if child != nil
+                    s = (self.readNode())
+                else 
+                    s = nil
+                end
+            else 
+                if (self.mode == XmlSerializer::MODE_WRITE) && (s != nil)
+                    (s)::onSerialize(self)
+                end
+            end
+            return s
+        end
+        def serializeArray(array, tagName)
+            if self.mode == XmlSerializer::MODE_READ
+                array = Array.new()
+                child = self.currentChild()
+                while (child != nil) && ((tagName == nil) || (tagName == child::nodeName))
+                    elem = (self.readNode())
+                    array::push(elem)
+                    child = self.currentChild()
+                end
+            else 
+                if ((self.mode == XmlSerializer::MODE_WRITE) && (array != nil)) && (array::length() > 0)
+                    items = array::iterator()
+                    while items::hasNext()
+                        (items::next())::onSerialize(self)
+                    end
+                end
+            end
+            return array
+        end
+        def serializeChildName(s, tagName)
+            if self.mode == MODE_READ
+                child = self.currentChild()
+                if (child != nil) && (child::nodeName == tagName)
+                    s = self.serializeChild(s)
+                end
+            else 
+                if self.mode == MODE_WRITE
+                    s = self.serializeChild(s)
+                end
+            end
+            return s
+        end
+        def serializeArrayName(array, tagName)
+            if self.mode == MODE_READ
+                if beginTag(tagName)
+                    array = serializeArray(array,nil)
+                    endTag()
+                end
+            else 
+                if ((self.mode == MODE_WRITE) && (array != nil)) && (array::length() > 0)
+                    element = self.element
+                    self.element = element::createElement_(tagName)
+                    element::addChild(self.element)
+                    array = self.serializeArray(array,nil)
+                    self.element = element
+                else 
+                    if self.mode == MODE_REGISTER
+                        self.beginTag(tagName)
+                    end
+                end
+            end
+            return array
+        end
+        def register(elem)
+            self.tags::set(self.getTagName(elem),elem)
+        end
+        def getTagName(elem)
+            mode = self.mode
+            self.mode = XmlSerializer::MODE_REGISTER
+            self.currentTag = nil
+            elem::onSerialize(self)
+            self.mode = mode
+            return self.currentTag
+        end
+        def readNode()
+            if !self.tags::exists(self.currentChild()::nodeName)
+                raise Exception,("Tag " + self.currentChild()::nodeName.to_s) + " not registered."
+            end
+            model = self.tags::get(self.currentChild()::nodeName)
+            return readNodeModel(model)
+        end
+        def readNodeModel(model)
+            node = model::newInstance()
+            node::onSerialize(self)
+            return node
+        end
+        def setCurrentElement(element)
+            self.element = element
+            self.children = self.element::elements()
+            self.child = nil
+        end
+        def nextChild()
+            if @children::hasNext()
+                self.child = @children::next()
+            else 
+                self.child = nil
+            end
+            return self.child
+        end
+        def currentChild()
+            if (self.child == nil) && @children::hasNext()
+                self.child = @children::next()
+            end
+            return self.child
+        end
+        def pushState()
+            self.elementStack::push(self.element)
+            self.childrenStack::push(self.children)
+            self.childStack::push(self.child)
+        end
+        def popState()
+            self.element = self.elementStack::pop()
+            self.children = self.childrenStack::pop()
+            self.child = self.childStack::pop()
+        end
+        def self.parseBoolean(s)
+            return (s::toLowerCase() == "true") || (s == "1")
+        end
+        def self.booleanToString(b)
+            return b ? "true" : "false"
+        end
+        def childString(name, value, def_)
+            if !((@mode == MODE_WRITE) && (((value == nil) && (def_ == nil)) || ((value != nil) && (value == def_))))
+                if self.beginTag(name)
+                    value = textContent(value)
+                    self.endTag()
+                end
+            end
+            return value
+        end
+        def childInt(name, value, def_)
+            return Std::parseInt(childString(name,"" + value.to_s,"" + def_.to_s))
+        end
+        def setCached(cache)
+            self.cache = cache
+        end
+        def beginCache()
+            if self.cache && (self.mode == XmlSerializer::MODE_WRITE)
+                self.mode = XmlSerializer::MODE_CACHE
+            end
+        end
+        def endCache()
+            if self.mode == XmlSerializer::MODE_CACHE
+                self.mode = XmlSerializer::MODE_WRITE
+            end
+        end
+        def getMainTag(xml)
+            i = 0
+            loop do
+                i = xml::indexOf("<",i)
+                i+=1
+                c = Std::charCodeAt(xml,i)
+            break if not (c != 33) && (c != 63)
+            end
+            _end = [">", " ", "/"]
+            min = 0
+            for j in 0.._end::length - 1
+                n = xml::indexOf(_end[j])
+                if (n != -1) && (n < min)
+                    n = min
+                end
+                j+=1
+            end
+            return Std::substr(xml,i,min)
+        end
+        def serializeXml(tag, elem)
+            if self.mode == MODE_READ
+                if (tag == nil) || ((self.currentChild() != nil) && (self.currentChild()::nodeName == tag))
+                    elem = self.currentChild()
+                    self.nextChild()
+                end
+            else 
+                if self.mode == MODE_WRITE
+                    if (elem != nil) && (self.ignoreTagStackCount == 0)
+                        imported = WXmlUtils::importXml(elem,self.element)
+                        self.element::addChild(imported)
+                    end
+                else 
+                    if self.mode == MODE_REGISTER
+                        self.beginTag(tag)
+                    end
+                end
+            end
+            return elem
+        end
+        def setIgnoreTags(ignore)
+            self.ignore = ignore
+        end
+        def isIgnoreTag(s)
+            if self.ignore != nil
+                i = self.ignore::iterator()
+                while i::hasNext()
+                    if (i::next() == s)
+                        return true
+                    end
+                end
+            end
+            return false
+        end
+        def self.compareStrings(a, b)
+            an = a::length()
+            bn = b::length()
+            n = (an > bn) ? bn : an
+            for i in 0..n - 1
+                c = Std::charCodeAt(a,i) - Std::charCodeAt(b,i)
+                if c != 0
+                    return c
+                end
+                i+=1
+            end
+            return a::length() - b::length()
+        end
+
     end
-  end
 end