wirispluginengine 3.62.0.1322 → 7.14.0.1422

data/lib/com/wiris/util/type/ByteBuffer.rb

@@ -0,0 +1,69 @@
+module WirisPlugin
+include  Wiris
+    class ByteBuffer
+    include Wiris
+
+        def initialize()
+            super()
+        end
+        def self.bytesTo64bitsFloat(bytes)
+            doubleResult = nil
+            returnedArraySize = (bytes::length()/8)
+            doubleResult = []
+            byteArray = bytes::getData()
+            k = 0
+            for  = 0
+returnedArraySize - 1
+                longResult = 0
+                shift = 0
+                high = 0
+                low = 0
+                shiftAuxiliar = 0
+                for  = 0
+8 - 1
+                    longAuxiliar = 0
+                    longAuxiliarHL = 0
+                    longAuxiliar ||=255&byteArray[k]
+                    longAuxiliar <<=shift
+                    longResult ||=longAuxiliar
+                    longAuxiliarHL ||=(255&byteArray[k])
+                    longAuxiliarHL <<=shiftAuxiliar
+                    if j < 4
+                        low ||=longAuxiliarHL
+                        if j == 3
+                            shiftAuxiliar = -8
+                        end
+                    else 
+                        high ||=longAuxiliarHL
+                    end
+                    shift += 8
+                    shiftAuxiliar += 8
+                    k+=1
+                    j+=1
+                end
+                high32 = Int32::ofInt(high)
+                low32 = Int32::ofInt(low)
+                doubleResult[i] = TypeTools::longBitsToDouble(longResult,high32,low32)
+                i+=1
+            end
+            return doubleResult
+        end
+        def self.bytesTo32bitsFloat(bytes)
+            doubleResult = nil
+            returnedArraySize = (bytes::length()/4)
+            doubleResult = []
+            byteArray = bytes::getData()
+            k = 0
+            for  = 0
+returnedArraySize - 1
+                intResult = ((((byteArray[k + 3]&255) << 24)|((byteArray[k + 2]&255) << 16))|((byteArray[k + 1]&255) << 8))|(byteArray[k]&255)
+                number = TypeTools::intBitsToFloat(intResult)
+                doubleResult[i] = number
+                k += 4
+                i+=1
+            end
+            return doubleResult
+        end
+
+    end
+end

data/lib/com/wiris/util/type/Comparator.rb

@@ -0,0 +1,8 @@
+module WirisPlugin
+include  Wiris
+    module ComparatorInterface
+        def Comparator
+            return true
+        end
+    end
+end

data/lib/com/wiris/util/type/DataUtils.rb

@@ -0,0 +1,24 @@
+module WirisPlugin
+include  Wiris
+    require('com/wiris/util/type/Arrays.rb')
+    class DataUtils
+    include Wiris
+
+        def initialize()
+            super()
+        end
+        def self.makeHashInt(definition)
+            hashItems = Arrays::fromCSV(definition)
+            result = Hash.new()
+hashItems            separatorIndex = itemPair::indexOf(":")
+            if separatorIndex == -1
+                    next
+            end
+            key = itemPair::substring(0,separatorIndex)::trim()
+            value = Std::parseInt(itemPair::substring(separatorIndex + 1)::trim())
+            result::set(key,value)
+            return result
+        end
+
+    end
+end

data/lib/com/wiris/util/type/DoubleTools.rb

@@ -0,0 +1,14 @@
+module WirisPlugin
+include  Wiris
+    class DoubleTools
+    include Wiris
+
+        def initialize()
+            super()
+        end
+        def self.isFinite(x)
+            return (!Double::isNaN(x) && (x != Double::POSITIVE_INFINITY)) && (x != Double::NEGATIVE_INFINITY)
+        end
+
+    end
+end

data/lib/com/wiris/util/type/HashCache.rb

@@ -0,0 +1,43 @@
+module WirisPlugin
+include  Wiris
+    class HashCache < HashT
+    include Wiris
+
+        attr_accessor :maxSize
+        attr_accessor :sortedKeys
+        def initialize(maxSize)
+            super()
+            self.maxSize = maxSize
+            self.sortedKeys = Array.new()
+        end
+        def getMaxSize()
+            return self.maxSize
+        end
+        def setMaxSize(maxSize)
+            self.maxSize = maxSize
+        end
+        def getSortedKeys()
+            return self.sortedKeys
+        end
+        def remove(key)
+            if self.sortedKeys::remove(key)
+                return super(key)
+            end
+            return false
+        end
+        def keys()
+            return self.sortedKeys::iterator()
+        end
+        def set(key, value)
+            if (self.sortedKeys != nil) && (self.sortedKeys::length() >= self.maxSize)
+                removed = self.sortedKeys::_(0)
+                if self.sortedKeys::remove(removed)
+                    super(removed)
+                end
+            end
+            self.sortedKeys::push(key)
+            super(key,value)
+        end
+
+    end
+end

data/lib/com/wiris/util/type/IntegerTools.rb

@@ -0,0 +1,32 @@
+module WirisPlugin
+include  Wiris
+    class IntegerTools
+    include Wiris
+
+        def initialize()
+            super()
+        end
+        def self.sign(value)
+            return (value >= 0) ? 1 : -1
+        end
+        def self.signBool(value)
+            return value ? 1 : -1
+        end
+        def self.max(x, y)
+            return (x > y) ? x : y
+        end
+        def self.min(x, y)
+            return (x < y) ? x : y
+        end
+        def self.clamp(x, a, b)
+            return IntegerTools.min(IntegerTools.max(a,x),b)
+        end
+        def self.inRange(x, start, _end)
+            return (x >= start) && (x < _end)
+        end
+        def self.isInt(x)
+            return (EReg.new("[\\+\\-]?\\d+",""))::match(x)
+        end
+
+    end
+end

data/lib/com/wiris/util/type/Queue.rb

@@ -0,0 +1,31 @@
+module WirisPlugin
+include  Wiris
+    class Queue
+    include Wiris
+
+        attr_accessor :array
+        attr_accessor :size
+        def initialize()
+            super()
+            self.array = Array.new()
+            self.size = 0
+        end
+        def front()
+            return @array::_(0)
+        end
+        def pop()
+            if @size > 0
+                @size-=1
+                @array::splice(0,1)
+            end
+        end
+        def push(e)
+            @array::push(e)
+            @size+=1
+        end
+        def empty()
+            return @size == 0
+        end
+
+    end
+end

data/lib/com/wiris/util/type/SortArrayByStringLength.rb

@@ -0,0 +1,26 @@
+module WirisPlugin
+include  Wiris
+    require('com/wiris/util/type/Arrays.rb')
+    class SortArrayByStringLength
+    extend Comparator<String>Interface
+
+    include Wiris
+
+        attr_accessor :arrayToSort
+        def initialize(arrayToSort)
+            super()
+            self.arrayToSort = arrayToSort
+            Arrays::sort(self.arrayToSort,self)
+        end
+        def getSorted()
+            return self.arrayToSort
+        end
+        def compare(a, b)
+            if a::length() < b::length()
+                return 1
+            end
+            return -1
+        end
+
+    end
+end

data/lib/com/wiris/util/type/SortStringByLength.rb

@@ -0,0 +1,26 @@
+module WirisPlugin
+include  Wiris
+    require('com/wiris/util/type/Arrays.rb')
+    class SortStringByLength
+    extend Comparator<String>Interface
+
+    include Wiris
+
+        attr_accessor :arrayToSort
+        def initialize(arrayToSort)
+            super()
+            self.arrayToSort = arrayToSort
+            Arrays::sort(self.arrayToSort,self)
+        end
+        def getSorted()
+            return self.arrayToSort
+        end
+        def compare(a, b)
+            if a::length() < b::length()
+                return 1
+            end
+            return -1
+        end
+
+    end
+end

data/lib/com/wiris/util/type/SortedHash.rb

@@ -0,0 +1,45 @@
+module WirisPlugin
+include  Wiris
+    require('com/wiris/util/type/Arrays.rb')
+    class SortedHash < HashT
+    include Wiris
+
+        attr_accessor :sortedKeys
+        def initialize()
+            super()
+            self.sortedKeys = Array.new()
+        end
+        def set(key, value)
+            i = Arrays::indexOfElement(self.sortedKeys,key)
+            if i >= 0
+                self.sortedKeys::_(i,key)
+            else 
+                self.sortedKeys::push(key)
+            end
+            super(key,value)
+        end
+        def remove(key)
+            self.sortedKeys::remove(key)
+            return super(key)
+        end
+        def keys()
+            return self.sortedKeys::iterator()
+        end
+        def getSortedKeys()
+            return self.sortedKeys
+        end
+        def push(key, value, limit)
+            idx = Arrays::indexOfElement(self.sortedKeys,key)
+            if idx >= 0
+                self.sortedKeys::splice(idx,1)
+                self.sortedKeys::push(key)
+            else 
+                if ((limit >= 0) && (self.sortedKeys::length() > 0)) && (self.sortedKeys::length() >= limit)
+                    self.remove(self.sortedKeys::_(0))
+                end
+                self.set(key,value)
+            end
+        end
+
+    end
+end

data/lib/com/wiris/util/type/Stack.rb

@@ -0,0 +1,31 @@
+module WirisPlugin
+include  Wiris
+    class Stack
+    include Wiris
+
+        attr_accessor :array
+        attr_accessor :size
+        def initialize()
+            super()
+            self.array = Array.new()
+            self.size = 0
+        end
+        def top()
+            return @array::_(@size - 1)
+        end
+        def pop()
+            if @size > 0
+                @size-=1
+                @array::pop()
+            end
+        end
+        def push(e)
+            @array::push(e)
+            @size+=1
+        end
+        def empty()
+            return @size == 0
+        end
+
+    end
+end

data/lib/com/wiris/util/type/StringUtils.rb

@@ -0,0 +1,56 @@
+module WirisPlugin
+include  Wiris
+    require('com/wiris/util/type/IntegerTools.rb')
+    require('com/wiris/util/xml/WCharacterBase.rb')
+    class StringUtils
+    include Wiris
+
+        def initialize()
+            super()
+        end
+        def self.stripAccents(s)
+            sb = StringBuf.new()
+            i = Utf8::getIterator(s)
+            while i::hasNext()
+                sb::add(WCharacterBase::stripAccent(i::next()))
+            end
+            return sb::toString()
+        end
+        def self.padLeftZeros(s, length)
+            if (s == nil) || (s::length() >= length)
+                return s
+            end
+            stringBuf = StringBuf.new()
+            for  = s::length()
+length - 1
+                stringBuf::add("0")
+                i+=1
+            end
+            stringBuf::add(s)
+            return stringBuf::toString()
+        end
+        def self.compareIgnoringAccents(a, b)
+            return (StringUtils::stripAccents(a) == StringUtils::stripAccents(b))
+        end
+        def self.slice(s, beginIndex, endIndex)
+            stringLength = s::length()
+            if beginIndex < 0
+                beginIndex = IntegerTools::max(0,stringLength + beginIndex)
+            else 
+                if beginIndex > stringLength
+                    beginIndex = stringLength
+                end
+            end
+            if endIndex < 0
+                endIndex = IntegerTools::max(0,s::length() + endIndex)
+            else 
+                if endIndex > stringLength
+                    endIndex = stringLength
+                end
+            end
+            span = IntegerTools::max(0,endIndex - beginIndex)
+            return Std::substr(s,beginIndex,span)
+        end
+
+    end
+end

data/lib/com/wiris/util/type/Tokenizer.rb

@@ -0,0 +1,40 @@
+module WirisPlugin
+include  Wiris
+    class Tokenizer
+    include Wiris
+
+        attr_accessor :delimiters
+        attr_accessor :takeDelimiters
+        def initialize(delimiters, takeDelimiters)
+            super()
+            self.delimiters = delimiters
+            self.takeDelimiters = takeDelimiters
+        end
+        def getDelimiters()
+            return self.delimiters
+        end
+        def splitTokens(text)
+            tokens = Array.new()
+            it = Utf8::getIterator(text)
+            block = StringBuf.new()
+            while it::hasNext()
+                c = Utf8::uchr(it::next())
+                if self.delimiters::indexOf(c) >= 0
+                    tokens::push(block::toString())
+                    if self.takeDelimiters
+                        tokens::push(c)
+                    end
+                    block = StringBuf.new()
+                else 
+                    block::add(c)
+                end
+            end
+            last = block::toString()
+            if !(last == "")
+                tokens::push(last)
+            end
+            return tokens
+        end
+
+    end
+end