kernel/core/tuple.rb

   1 # depends on: class.rb module.rb
   2
   3 ##
   4 # The tuple data type.
   5
   6 class Tuple
   7
   8   include Enumerable
   9
  10   def self.[](*args)
  11     sz = args.size
  12     tup = new(sz)
  13     i = 0
  14     while i < sz
  15       tup.put i, args[i]
  16       i += 1
  17     end
  18
  19     return tup
  20   end
  21
  22   def to_s
  23     "#<Tuple:0x#{object_id.to_s(16)} #{fields} elements>"
  24   end
  25
  26   def each
  27     i = 0
  28     t = fields
  29     while i < t
  30       yield self.at(i)
  31       i += 1
  32     end
  33     self
  34   end
  35
  36   def + o
  37     t = Tuple.new(size + o.size)
  38     each_with_index { |e, i| t[i] = e }
  39     o.each_with_index { |e, i| t[i + size] = e }
  40     t
  41   end
  42
  43   def inspect
  44     str = "#<Tuple"
  45     if fields != 0
  46       str << ": #{join(", ", :inspect)}"
  47     end
  48     str << ">"
  49     return str
  50   end
  51
  52   def join(sep, meth=:to_s)
  53     join_upto(sep, fields, meth)
  54   end
  55
  56   def join_upto(sep, count, meth=:to_s)
  57     str = ""
  58     return str if count == 0 or empty?
  59     count = fields if count >= fields
  60     count -= 1
  61     i = 0
  62     while i < count
  63       str << at(i).__send__(meth)
  64       str << sep.dup
  65       i += 1
  66     end
  67     str << at(count).__send__(meth)
  68     return str
  69   end
  70
  71   def ===(other)
  72     return false unless Tuple === other and fields == other.fields
  73     i = 0
  74     while i < fields
  75       return false unless at(i) === other.at(i)
  76       i += 1
  77     end
  78     true
  79   end
  80
  81   def to_a
  82     ary = []
  83     each do |ent|
  84       ary << ent
  85     end
  86     return ary
  87   end
  88
  89   def shift
  90     return self unless fields > 0
  91     t = Tuple.new(fields-1)
  92     t.copy_from self, 1, 0
  93     return t
  94   end
  95
  96   # Swap elements of the two indexes.
  97   def swap(a, b)
  98     temp = at(a)
  99     put(a, at(b))
 100     put(b, temp)
 101   end
 102
 103   def enlarge(size)
 104     if size > fields()
 105       t = Tuple.new(size)
 106       t.copy_from self, 0, 0
 107       return t
 108     end
 109
 110     return self
 111   end
 112
 113   alias_method :size, :fields
 114   alias_method :length, :fields
 115
 116   def empty?
 117     size == 0
 118   end
 119
 120   def first
 121     at(0)
 122   end
 123
 124   def last
 125     at(fields-1)
 126   end
 127 end