class WirisPlugin::XmlSerializer

Constants

MODE_CACHE
MODE_READ
MODE_REGISTER
MODE_WRITE

Attributes

cache[RW]
cacheTagStackCount[RW]
child[RW]
childStack[RW]
children[RW]
childrenStack[RW]
currentTag[RW]
element[RW]
elementStack[RW]
ignore[RW]
ignoreTagStackCount[RW]
mode[RW]
rawxmls[RW]
tags[RW]

Public Class Methods

booleanToString(b) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 435
def self.booleanToString(b)
    return b ? "true" : "false"
end
compareStrings(a, b) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 516
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
getXmlTextContent(element) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 296
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
new() click to toggle source
Calls superclass method
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 25
def initialize()
    super()
    @tags = Hash.new()
    @elementStack = Array.new()
    @childrenStack = Array.new()
    @childStack = Array.new()
    self.cacheTagStackCount = 0
    self.ignoreTagStackCount = 0
end
parseBoolean(s) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 432
def self.parseBoolean(s)
    return (s::toLowerCase() == "true") || (s == "1")
end

Public Instance Methods

arrayToString(a) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 186
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
attributeBoolean(name, value, def_) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 174
def attributeBoolean(name, value, def_)
    return XmlSerializer::parseBoolean(attributeString(name,XmlSerializer::booleanToString(value),XmlSerializer::booleanToString(def_)))
end
attributeFloat(name, value, def_) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 232
def attributeFloat(name, value, def_)
    return Std::parseFloat(attributeString(name,"" + value.to_s,"" + def_.to_s))
end
attributeInt(name, value, def_) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 177
def attributeInt(name, value, def_)
    return Std::parseInt(attributeString(name,"" + value.to_s,"" + def_.to_s))
end
attributeIntArray(name, value, def_) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 180
def attributeIntArray(name, value, def_)
    return stringToArray(attributeString(name,arrayToString(value),arrayToString(def_)))
end
attributeString(name, value, def_) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 147
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
attributeStringArray(name, value, def_) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 183
def attributeStringArray(name, value, def_)
    return stringToArrayString(attributeString(name,stringArrayToString(value),stringArrayToString(def_)))
end
base64Content(data) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 261
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
beginCache() click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 453
def beginCache()
    if self.cache && (self.mode == XmlSerializer::MODE_WRITE)
        self.mode = XmlSerializer::MODE_CACHE
    end
end
beginTag(tag) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 94
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
beginTagIf(tag, current, desired) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 70
def beginTagIf(tag, current, desired)
    if @mode == MODE_READ
        if beginTag(tag)
            return desired
        end
    else 
        if current == desired
            beginTag(tag)
        end
    end
    return current
end
beginTagIfBool(tag, current, desired) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 82
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
booleanContent(content) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 290
def booleanContent(content)
    return XmlSerializer::parseBoolean(textContent(XmlSerializer::booleanToString(content)))
end
cacheAttribute(name, value, def_) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 162
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
childInt(name, value, def_) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 447
def childInt(name, value, def_)
    return Std::parseInt(childString(name,"" + value.to_s,"" + def_.to_s))
end
childString(name, value, def_) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 438
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
currentChild() click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 416
def currentChild()
    if (self.child == nil) && @children::hasNext()
        self.child = @children::next()
    end
    return self.child
end
endCache() click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 458
def endCache()
    if self.mode == XmlSerializer::MODE_CACHE
        self.mode = XmlSerializer::MODE_WRITE
    end
end
endTag() click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 123
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
floatContent(d) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 293
def floatContent(d)
    return Std::parseFloat(textContent(d.to_s + ""))
end
getMainTag(xml) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 463
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
getMode() click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 34
def getMode()
    return self.mode
end
getTagName(elem) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 383
def getTagName(elem)
    mode = self.mode
    self.mode = XmlSerializer::MODE_REGISTER
    self.currentTag = nil
    elem::onSerialize(self)
    self.mode = mode
    return self.currentTag
end
isIgnoreTag(s) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 505
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
nextChild() click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 408
def nextChild()
    if @children::hasNext()
        self.child = @children::next()
    else 
        self.child = nil
    end
    return self.child
end
popState() click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 427
def popState()
    self.element = self.elementStack::pop()
    self.children = self.childrenStack::pop()
    self.child = self.childStack::pop()
end
pushState() click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 422
def pushState()
    self.elementStack::push(self.element)
    self.childrenStack::push(self.children)
    self.childStack::push(self.child)
end
rawXml(xml) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 273
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
read(xml) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 37
def read(xml)
    document = Xml::parse(xml)
    self.setCurrentElement(document)
    self.mode = XmlSerializer::MODE_READ
    return readNode()
end
readNode() click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 391
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
readNodeModel(model) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 398
def readNodeModel(model)
    node = model::newInstance()
    node::onSerialize(self)
    return node
end
readXml(xml) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 43
def readXml(xml)
    self.setCurrentElement(xml)
    self.mode = XmlSerializer::MODE_READ
    return readNode()
end
register(elem) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 380
def register(elem)
    self.tags::set(self.getTagName(elem),elem)
end
serializeArray(array, tagName) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 327
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
serializeArrayName(array, tagName) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 359
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
serializeChild(s) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 312
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
serializeChildName(s, tagName) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 346
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
serializeXml(tag, elem) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 482
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
setCached(cache) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 450
def setCached(cache)
    self.cache = cache
end
setCurrentElement(element) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 403
def setCurrentElement(element)
    self.element = element
    self.children = self.element::elements()
    self.child = nil
end
setIgnoreTags(ignore) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 502
def setIgnoreTags(ignore)
    self.ignore = ignore
end
stringArrayToString(a) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 200
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
stringToArray(s) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 220
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
stringToArrayString(s) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 214
def stringToArrayString(s)
    if s == nil
        return nil
    end
    return s::split(",")
end
textContent(content) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 235
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
write(s) click to toggle source
# File lib/com/wiris/util/xml/XmlSerializer.rb, line 48
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