hypersonic-plus 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0dea6bc861144541cd3ae9c84478ee31845f3620
+  data.tar.gz: 85f7ee1102ca76e5bf83f8589b792ddb9092a88c
+SHA512:
+  metadata.gz: 38ebea93fae846705eaabf7dab8085707f1b3e5f87075ce5d757beb176cdf4de36cfe32312881968716bc7c71872697377c687eb5451cb27fc560a2c059fbb78
+  data.tar.gz: 6764b69ad9caf5864a7707876408ebf340d27d9f64ad968b1779d1727981c28551cd5c7405d05084a1c416611710a005b0678ff061c73697294a05097b31cc8b

data/lib/hdatastructures/hfieldtable.rb

@@ -0,0 +1,285 @@
+#!/usr/bin/env ruby
+require 'hdatastructures/hlist'
+require 'hmisc/hcolorize'
+
+class HFieldTable < Array
+
+  attr_accessor :tableName, :allRows, :allCols
+
+  def initialize(allRows = false, allCols = false)
+    @tableName = nil
+    @fields = {}
+    @allRows = allRows
+    @allCols = allCols
+  end
+
+  def copyConstructor
+    Marshal.load(Marshal.dump(self))
+  end
+
+  def fields()
+    result = {}
+    @fields.each do |fieldName, fieldValue|
+      result[fieldName] = fieldValue if fieldValue.visible or @allCols
+    end
+    return result
+  end
+  
+  def addFieldName(fieldName, visible = true)
+    record = HRecord.new(fieldName) unless @fields[fieldName]
+    record.set(:visible, visible)
+    @fields[fieldName] = record
+  end
+ 
+  def method_missing(methodName, *args)
+
+    if methodName.to_s =~ /^setField(.+)$/ # example: setFieldCaption(fieldName, fieldCaption)
+      @fields[args[0]].set($1.downcase().to_sym, args[1])
+    else
+      caller_infos = caller.first.split(":")
+      puts "Error: #{caller_infos[0]}:#{caller_infos[1]} - #{methodName} not found".hight_red()  
+    end
+
+  end
+
+  def rowCount()
+    return self.length()
+  end
+
+  def columnCount()
+    return @fields.length()
+  end
+  
+  def columnCountByKey(key = :visible)
+    return self.columnCount if @allCols
+    i = 0
+    @fields.each { |fieldName, fieldValue| i += 1 if fieldValue.value(key) }
+    return i
+  end
+
+  def setData(row, fieldName, data)
+    self[row][fieldName] = data
+  end
+
+  # Inserts a new row filled with data
+  def insertRow(row, data = nil)
+    tmp = @fields.dup
+    self.insert(row, tmp.each { |k, v| tmp[k] = data } )
+  end
+
+  def deleteRow(row)
+    self.delete_at(row)
+  end
+
+  def setDataByFieldName(row, fieldName, data)
+    self.setData(row, fieldName, data) 
+  end
+  
+  def setIntoRecordByFieldName(row, fieldName, data)
+    self.setDataByFieldName(row, fieldName, HRecord.new(data)) 
+  end
+
+  def setCaption
+    self.fields.each do |fieldName, fieldValue|
+      self.setFieldCaption(fieldName, fieldValue.value.hcapitalize())
+    end
+  end
+
+  def [](fieldName)
+    self[fieldName] = {} unless super(fieldName)
+    return super(fieldName)
+  end
+
+  def data(row, fieldName)
+    return self[row][fieldName]
+  end
+  
+  def dataByFieldName(row, fieldName)
+    return self.data(row, fieldName)
+  end
+  
+  def valueByFieldName(row, fieldName)
+    value = self.data(row, fieldName)
+    value = value.value() if (value.class == HRecord)
+    return value
+  end
+  
+  def row(row)
+    #return self[row] if @allCols
+    result = {}
+    @fields.each do |fieldName, fieldValue|
+      result[fieldName] = self.dataByFieldName(row, fieldName) if fieldValue.visible or @allCols
+    end
+    return result
+  end
+
+  def match(row)
+    @fields.each do |fieldName, fieldValue|
+      filter = fieldValue.filter
+      next unless filter
+      data = self.dataByFieldName(row, fieldName)
+      return false unless data
+      data = HRecord.new(data) if data.class != HRecord
+      filter = HRecord.new(filter) if filter.class != HRecord
+      return false if data != filter
+    end
+    return true
+
+  end
+
+  def each()
+    for i in 0...self.rowCount() do
+      row = self.row(i)
+      yield(row, i) if @allRows or self.match(i) 
+    end 
+  end
+
+  def rowWithFieldName(row)
+    result = {}
+    self[row].each do |fieldName, fieldValue|
+      field = @fields[fieldName]
+      result[fieldName] = fieldValue if field.visible or @allCols
+    end
+    return result
+  end
+  
+  def eachWithFieldName()
+    for i in 0...self.rowCount() do
+      row = self.rowWithFieldName(i)
+      yield(row, i) if @allRows or self.match(i) 
+    end 
+  end
+  
+  
+  def sumByFieldName(fieldName)
+
+    total = 0
+    for i in 0...self.rowCount() do
+      total += (self.dataByFieldName(i, fieldName)).to_f
+    end 
+    return total
+  
+  end
+
+  def valueByType(fieldName, fieldValue)
+
+    return nil unless fieldValue  
+    type = @fields[fieldName].value(:type) if @fields[fieldName]
+    value = fieldValue.value 
+    return value unless type
+    return value.to_s if type == "text"
+    return value.to_i if type == "integer"
+    return value.to_f if type == "float"
+    return value.to_date() if type == "date"
+    return value.to_datetime() if type == "datetime"
+    return value.to_s
+
+  end
+
+  # fieldTable.sortBy("price")
+  # fieldTable.sortBy("price", "amount")
+  # fieldTable.sortBy("price", "amount", asc: false)
+  def sortBy(*fieldNames, asc: true)
+    #self.herbertsort!(asc) { |row| fieldNames.map {|fieldName| row[fieldName]} } 
+    self.herbertsort!(asc) { |row| fieldNames.map {|fieldName| self.valueByType(fieldName, row[fieldName])} } 
+  end
+  
+  def showHeader(key = :key)
+    self.fields.each do |fieldName, fieldValue|
+      print $hpformat % fieldValue.value(key) 
+    end
+    puts
+  end
+
+  def showData(data, key = :key)
+
+    if !data
+      print $hpformat % "." unless data
+    elsif data.class == Fixnum or data.class == String
+      print $hpformat % data
+    else
+      data.show(key)
+    end
+  
+  end
+
+  def showTotalizers()
+
+    @fields.each do |fieldName, fieldValue|
+      totalizerName = fieldValue.totalizer
+      if totalizerName 
+        print $hpformat % totalizerName
+        print $hpformat % self.sumByFieldName(fieldName)
+        puts
+      end
+    end
+    puts
+
+  end
+
+
+  def show(key = :key)
+    print "=============>  HFieldTable  <==============\n"
+    self.showHeader(:caption)
+    self.each do |row, i|
+      row.each do |fieldName, fieldValue|    
+        self.showData(fieldValue)
+      end
+      puts
+    end
+    puts
+  end
+  
+
+  def self.test()
+
+    table = HFieldTable.new()
+    table.setData(0, 0, HRecord.new("0x0"))
+    table.setData(10, 1, HRecord.new("10x1"))
+    table.setData(9, 9, HRecord.new("9x9"))
+    table.show()
+  end
+
+  def self.test2()
+
+    fieldTable = HFieldTable.new()
+    fieldTable.addFieldName("quantity")
+    fieldTable.addFieldName("description")
+    fieldTable.addFieldName("price", false)
+    fieldTable.addFieldName("amount")
+
+    fieldTable.setFieldCaption("quantity", "Quantity")
+    fieldTable.setFieldCaption("description", "Description")
+    fieldTable.setFieldCaption("price", "Price")
+    fieldTable.setFieldCaption("amount", "Amount")
+
+    fieldTable.setFieldFilter("price", HRecord.new(10))
+    fieldTable.setFieldFilter("amount", HRecord.new(10))
+
+    for i in 0..30
+      fieldTable.setDataByFieldName(i, "quantity", HRecord.new(i))
+      fieldTable.setDataByFieldName(i, "description", HRecord.new(i))
+      fieldTable.setDataByFieldName(i, "price", HRecord.new(rand(10)))
+      fieldTable.setDataByFieldName(i, "amount", HRecord.new(i))
+    end
+
+    #fieldTable.insertRow(1, HRecord.new("ciao"))
+    #fieldTable.deleteRow(1)
+
+    fieldTable.show()
+    fieldTable.allRows,fieldTable.allCols = true, true
+    fieldTable.show()
+
+    fieldTable.sortBy("price", "amount", asc: false)
+    fieldTable.show()
+
+    return fieldTable
+
+  end
+
+
+end
+
+t1 = Time.now
+HFieldTable.test2()
+p "... msecs. #{((Time.now - t1) * 1000).round(2)}"

data/lib/hdatastructures/hhash.rb

@@ -0,0 +1,9 @@
+class Hash
+
+  def symbolize_keys
+    self.keys.each do |key|
+      self[(key.to_sym rescue key) || key] = self.delete(key)
+    end
+  end
+
+end

data/lib/hdatastructures/hlist.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+require "hdatastructures/hrecord"
+
+class Array
+
+  alias_method :insertFirst, :unshift
+  alias_method :insertLast,  :<<
+  alias_method :deleteFirst, :shift
+  alias_method :deleteLast,  :pop
+  alias_method :deleteAt,    :delete_at
+  alias_method :indexOf,     :index
+
+  def addIfNotPresent(value)
+
+    self << value unless self.include?(value)
+    return value
+
+  end
+
+  def deleteAt(index)
+    self.delete_at(index) if index 
+  end
+
+  def swap(index1, index2)
+    # Parallel Assignment: eg a,b = 1,2
+    self[index1], self[index2] = self[index2], self[index1]
+  end
+
+  def < (array)
+    for i in 0...self.count
+      return true unless self[i]
+      return false unless array[i]
+      return true if self[i] < array[i]
+      return false if self[i] > array[i]
+    end
+    return false
+  end
+  
+  def hpartition
+    return self.select { |value| value if yield(value) }, self.select { |value| value unless yield(value) }
+  end
+  
+  def herbertsort(asc = true, &block)
+
+    #block = lambda { |data| data } unless block
+    block = Proc.new { |data| data } unless block
+
+    return [] if empty?
+    pivot = delete_at(rand(size))
+    left, right = hpartition { |value| block.call(value) < block.call(pivot) } if asc
+    left, right = hpartition { |value| !(block.call(value) < block.call(pivot)) } unless asc 
+    return *left.herbertsort(asc, &block), pivot, *right.herbertsort(asc, &block)
+
+  end
+
+  # [4,2,1,5,3].herbertsort => [1, 2, 3, 4, 5]
+  # [[4,0],[2,0],[1,0],[5,0],[3,0]].herbertsort => [[1, 0], [2, 0], [3, 0], [4, 0], [5, 0]]
+  # [[4,1],[2,0],[1,0],[4,0],[3,0]].herbertsort => [[1, 0], [2, 0], [3, 0], [4, 0], [4, 1]]
+  # Sorting by qty
+  # [{qty:1, price:3}, {qty:2, price:2}, {qty:3, price:1}].herbertsort { |data| data[:qty] } =>
+  #                            [{:qty=>1, :price=>3}, {:qty=>2, :price=>2}, {:qty=>3, :price=>1}]
+  # Sorting by qty and by price                           
+  # [{qty:1, price:3}, {qty:1, price:2}, {qty:1, price:1}].herbertsort { |data| [data[:qty], data[:price]] }
+  def herbertsort!(asc = true, &block)
+    self.herbertsort(asc, &block).each_with_index { |data, i| self[i] = data }
+  end
+
+  def show(key = :key)
+    self.each do |data|
+      if data.class == HRecord
+        data.show(key) 
+      else
+        puts data.to_s
+      end
+    end
+  end
+
+  def self.test()
+    list = []
+    #(20).downto(1) { |i|
+    for i in 0..9
+      list.insertLast(HRecord.new(i))
+    end
+    list.deleteFirst()
+    list.deleteLast()
+    list.deleteAt(2)
+    list.insert(0, HRecord.new(0))
+    list.insert(3, "ciao")
+    list.insertLast(HRecord.new(9))
+    list[15] = 20
+    list[16] = :end
+    list.swap(15, 16)
+    list.show()
+    p list.indexOf(HRecord.new(9))
+    p [1,6,5,4,3,23,2].herbertsort
+  end
+
+end
+
+#Array.test()

data/lib/hdatastructures/hrecord.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+$hpformat = '%-11.10s'
+
+class HRecord < Hash
+  include Comparable
+  
+  def method_missing(var, *args)
+    if var =~ /^(\w+)=$/
+      if self.include?($1.to_s)
+        self.set($1.to_s, args[0])
+      else
+        self.set($1.to_sym, args[0])
+      end
+      return self
+    else
+      return self.value(var.to_sym) || self.value(var.to_s)
+    end
+  end
+
+  def initialize(fieldValue, fieldName = :key)
+    self.setValue(fieldValue, fieldName)
+  end
+
+  def setValue(fieldValue, fieldName = :key)
+    self[fieldName] = fieldValue
+    return self
+  end
+
+  def set(fieldName, fieldValue)
+    self.setValue(fieldValue, fieldName)
+    return self
+  end
+
+  def value(fieldName = :key)
+    puts "hrecord::value: it's exist #{fieldName} symbol and string - #{self}".red if self[fieldName.to_sym] and  self[fieldName.to_s]
+    return self[fieldName.to_sym] || self[fieldName.to_s]
+  end
+
+  def <=>(record)
+     self[:key] <=> record[:key]
+  end  
+
+  def to_f(fieldName = :key)
+    return self[fieldName].to_f()
+  end  
+  
+  def show(key = :key)
+
+    color = self.include?(:color) ? self[:color] : "white"
+    value = $hpformat % self.value().to_s()
+    eval("print value.#{color}")
+
+  end
+
+  def showAll(key = :key)
+
+    self.each do |key, value|
+      puts "#{key}: #{value}"
+    end
+    puts "=" * 20
+
+  end
+
+  def self.test()
+    rec = HRecord.new("a")
+    rec.setValue("0", "index-0")
+    rec.set("index-1", "1")
+    rec.show() 
+    puts rec == rec
+  end
+
+end
+
+#HRecord.test