carray 1.4.0 → 1.5.5

data/lib/carray/{base/serialize.rb → serialize.rb}

@@ -1,12 +1,10 @@
 # ----------------------------------------------------------------------------
 #
-#  carray/base/serialize.rb
+#  carray/serialize.rb
 #
 #  This file is part of Ruby/CArray extension library.
-#  You can redistribute it and/or modify it under the terms of
-#  the Ruby Licence.
 #
-#  Copyright (C) 2005 Hiroki Motoyoshi
+#  Copyright (C) 2005-2020 Hiroki Motoyoshi
 #
 # ----------------------------------------------------------------------------
 #
@@ -33,7 +31,7 @@
 # offset 20 bytes
 #   data_type        : int32  : data type specifier
 #   bytes            : int32  : byte size of each data
-#   rank             : int32  : rank of array
+#   ndim             : int32  : ndim of array
 #   elements         : int32  : number of all elements
 #   has_mask         : int32  : 0 (not masked) or 1 (masked)
 # offset 40 bytes
@@ -41,8 +39,10 @@
 #   has_attribute    : int32  
 #
 # offset 256 bytes
-#   data           : bytes*elements : value data
-#   mask           : int8*elements  : mask data if has_mask == 1
+#   data             : bytes*elements : value data
+#   mask             : int8*elements  : mask data if has_mask == 1
+#   attribute        : object marshal : attribute
+#   data_class_name  : string marshal : data_class_name
 
 require "stringio"
 
@@ -54,11 +54,25 @@ class CArray::Serializer   # :nodoc:
     char_p    :endian,         :bytes=>4
     int32     :data_type
     int64     :bytes
-    int32     :rank
+    int32     :ndim
     int64     :elements
     int32     :has_mask
     array     :dim,            :type => CArray.int64(CA_RANK_MAX)
     int32     :has_attr
+    int32     :has_data_class
+  }
+
+  Header_Legacy = CA.struct(:pack=>1, :size=>256) {
+    char_p    :magic_string,   :bytes=>8
+    char_p    :data_type_name, :bytes=>8
+    char_p    :endian,         :bytes=>4
+    int32     :data_type
+    int32     :bytes
+    int32     :ndim
+    int32     :elements
+    int32     :has_mask
+    array     :dim,            :type => CArray.int32(CA_RANK_MAX)
+    int32     :has_attr
   }
 
   def initialize (io)
@@ -70,7 +84,7 @@ class CArray::Serializer   # :nodoc:
     end
   end
 
-  def save (ca, opt = {})
+  def save (ca, **opt)
     endian = opt[:endian] || CArray.endian
     # ---
     header = Header.new()
@@ -79,18 +93,19 @@ class CArray::Serializer   # :nodoc:
     header[:endian]         = ( endian == CA_LITTLE_ENDIAN ) ? "_LE_" : "_BE_"
     header[:data_type]      = ca.data_type
     header[:bytes]          = ca.bytes
-    header[:rank]           = ca.rank
+    header[:ndim]           = ca.ndim
     header[:elements]       = ca.elements
     header[:has_mask]       = ca.has_mask? ? 1 : 0
-    header[:dim][[0,ca.rank]] = ca.dim
-    attr = nil
+    header[:has_data_class] = ca.has_data_class? ? 1 : 0
+    header[:dim][[0,ca.ndim]] = ca.dim
+    attributes = nil
     if ca.attribute
-      attr = ca.attribute.clone
+      attributes = ca.attribute.clone
     end
     if opt[:attribute]
-      (attr ||= {}).update(opt[:attribute])
+      (attributes ||= {}).update(opt[:attribute])
     end
-    header[:has_attr]       = attr.empty? ? 0 : 1
+    header[:has_attr]       = attributes.empty? ? 0 : 1
     unless CArray.endian == endian
       header.swap_bytes!
     end
@@ -108,14 +123,21 @@ class CArray::Serializer   # :nodoc:
     if ca.has_mask?
       ca.mask.dump_binary(@io)
     end
-    if attr
-      Marshal.dump(attr, @io)
+    if attributes
+      Marshal.dump(attributes, @io)
+    end
+    if ca.has_data_class?
+      Marshal.dump(ca.data_class.to_s, @io)
     end
     return ca
   end
   
-  def load (opt = {})
-    header = Header.decode(@io.read(256))
+  def load (**opt)
+    if opt[:legacy]
+      header = Header_Legacy.decode(@io.read(256))
+    else
+      header = Header.decode(@io.read(256))
+    end
     if header[:magic_string] != "_CARRAY_"
       raise "not a CArray binary data"      
     end
@@ -130,11 +152,12 @@ class CArray::Serializer   # :nodoc:
     end
     data_type = header[:data_type]
     bytes     = header[:bytes]
-    rank      = header[:rank]
+    ndim      = header[:ndim]
     elements  = header[:elements]
     has_mask  = header[:has_mask] != 0 ? true : false
-    dim       = header[:dim][[0, rank]].to_a
-    has_attr  = header[:has_attr]
+    dim       = header[:dim][[0, ndim]].to_a
+    has_attr  = header[:has_attr] != 0 ? true : false
+    has_data_class = header[:has_data_class] != 0 ? true : false
     if data_type == 255
       data_type = header[:data_type_name].strip.to_sym
     end
@@ -155,9 +178,12 @@ class CArray::Serializer   # :nodoc:
       ca.mask = 0
       ca.mask.load_binary(@io)
     end
-    if has_attr == 1
+    if has_attr
       ca.attribute = Marshal.load(@io)
     end
+    if has_data_class 
+      ca.data_class = Kernel.const_get(Marshal.load(@io))
+    end
     return ca
   end
   
@@ -165,36 +191,36 @@ end
 
 class CArray
 
-  def self.save(ca, output, opt={})
+  def self.save(ca, output, **opt)
     case output
     when String
       open(output, "wb:ASCII-8BIT") { |io|
-        return Serializer.new(io).save(ca, opt)
+        return Serializer.new(io).save(ca, **opt)
       }
     else
-      return Serializer.new(output).save(ca, opt) 
+      return Serializer.new(output).save(ca, **opt) 
     end
   end
 
-  def self.load (input, opt={})
+  def self.load (input, **opt)
     case input
     when String
       if input.length >= 256 and input =~ /\A_CARRAY_.{8}_(LE|BE)_/
         io = StringIO.new(input)
-        return Serializer.new(io).load(opt)
+        return Serializer.new(io).load(**opt)
       else
         open(input, "rb:ASCII-8BIT") { |io|
-          return Serializer.new(io).load(opt)
+          return Serializer.new(io).load(**opt)
         }
       end
     else
-      return Serializer.new(input).load(opt)   
+      return Serializer.new(input).load(**opt)   
     end
   end
 
-  def self.dump (ca, opt={})
+  def self.dump (ca, **opt)
     io = StringIO.new("")
-    Serializer.new(io).save(ca, opt) 
+    Serializer.new(io).save(ca, **opt) 
     return io.string
   end
 
@@ -202,7 +228,8 @@ class CArray
 
   def marshal_dump ()
     if self.class != CArray and self.class != CScalar
-      raise TypeError, "can't dump a virtual or wrapped array."
+      return CArray.dump(self.to_ca)
+#      raise TypeError, "can't dump a virtual or wrapped array."
     end
     return CArray.dump(self)
   end
@@ -213,48 +240,5 @@ class CArray
     initialize_copy(ca)
   end
 
-  ### obsolete methods
-
-  def save_binary (filename, opt={})    # :nodoc: 
-    warn "CArray#save_binary will be obsolete, use CArray.save"
-    open(filename, "w") { |io|
-      return Serializer.new(io).save(self, opt)
-    }
-  end
-
-  def self.load_binary (filename, opt={})     # :nodoc: 
-    warn "CArray.load_binary will be obsolete, use CArray.load"
-    open(filename) { |io|
-      return Serializer.new(io).load(opt)
-    }
-  end
-
-  def save_binary_io (io, opt={})        # :nodoc:
-    warn "CArray#save_binary_io will be obsolete, use CArray.save"
-    return Serializer.new(io).save(self, opt) 
-  end
-
-  def self.load_binary_io (io, opt={})   # :nodoc:
-    warn "CArray#load_binary_io will be obsolete, use CArray.load"
-    return Serializer.new(io).load(opt)   
-  end 
-
-  def to_binary (io="", opt={})          # :nodoc:
-    warn "CArray#to_binary will be obsolete, use CArray.dump"
-    Serializer.new(io).save(self, opt) 
-    return io
-  end
-
-  def self.from_binary (io, opt={})      # :nodoc:
-    warn "CArray.from_binary will be obsolete, use CArray.load"
-    return Serializer.new(io).load(opt)   
-  end 
-
-  # depleted methods
-
-  def self.load_from_file (filename, data_type, dim, opt={}) # :nodoc:
-    raise "Sorry, CArray.load_from_file is depleted"
-  end
-
 end
 

data/lib/carray/{base/string.rb → string.rb}

@@ -1,11 +1,17 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/string.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#
+#  Copyright (C) 2005-2020 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+
 require "date"
 
 class CArray
 
-  def test (&block)
-    return convert(:boolean) {|v| yield(v) ? true : false }
-  end
-
   def str_len ()
     return convert(:int, &:length)
   end
@@ -178,65 +184,5 @@ class CArray
     return convert {|s| regexp.match(s) {|m| m[0].sub(regexp, replace) } || "" }
   end
     
-  def str_to_datetime (template = nil)
-    if template
-      return convert() {|v| DateTime.strptime(v, template) }
-    else
-      return convert() {|v| DateTime.parse(v) }
-    end
-  end
-
-  def str_to_time (template = nil)
-    if template
-      return str_strptime(template)
-    else
-      return convert() {|v| Time.parse(v) }
-    end
-  end
-
-  def time_format (template = nil)
-    if template
-      return str_strftime(template)
-    else
-      return convert(&:to_s)
-    end    
-  end
-
-  def time_year
-    return convert(:int, &:year)
-  end
-
-  def time_month
-    return convert(:int, &:month)
-  end
-
-  def time_day
-    return convert(:int, &:day)
-  end
-
-  def time_hour 
-    return convert(:int, &:hour)
-  end
-
-  def time_minute
-    return convert(:int, &:minute)
-  end
-
-  def time_second
-    return convert(:double) {|d| d.second + d.second_fraction }
-  end
-
-  def time_jd
-    return convert(:int, &:jd)
-  end
-
-  def time_ajd
-    return convert(:double, &:ajd)
-  end
-
-  def time_is_leap
-    return test(&:leap?)
-  end
-
 end
 

data/lib/carray/{base/struct.rb → struct.rb}

@@ -1,28 +1,26 @@
 # ----------------------------------------------------------------------------
 #
-#  carray/base/struct.rb
+#  carray/struct.rb
 #
 #  This file is part of Ruby/CArray extension library.
-#  You can redistribute it and/or modify it under the terms of
-#  the Ruby Licence.
 #
-#  Copyright (C) 2005 Hiroki Motoyoshi
+#  Copyright (C) 2005-2020 Hiroki Motoyoshi
 #
 # ----------------------------------------------------------------------------
 #
 # The data class for fixed length carray are required to satisfy only
-# four conditions.
+# five conditions.
 #
 #   * constant data_class::DATA_SIZE    -> integer
-#   * constant data_class::MEMBERS      -> array of string
 #   * constant data_class::MEMBER_TABLE -> hash
+#   * constant data_class::MEMBERS      -> array (MEMBER_TABLE.keys as usual)
 #   * method   data_class.decode(data)  -> new data_class object
 #   * method   data_class#encode()      -> string 
 #
 # The implementation of other properties (cf. initialization, instance,
 # methods ...) are left free.
 #
-# CA::Struct and CA::Union are examples of such data class.
+# CAStruct and CAUnion are examples of such data class.
 #
 # option = {
 #   :pack => 1,   # nil for alignment, int for pack(n)
@@ -90,7 +88,7 @@ class CArray
 
 end
 
-class CA::Struct
+class CAStruct
 
   include Enumerable
 
@@ -264,7 +262,7 @@ class CA::Struct
 
 end
 
-class CA::Union < CA::Struct
+class CAUnion < CAStruct
   class << self
     def inspect
       return name.nil? ? "AnonUnion" : name
@@ -275,11 +273,11 @@ end
 module CA
 
   def self.struct (opt={}, &block)
-    return Struct::Builder.new(:struct, opt).define(&block)
+    return CAStruct::Builder.new(:struct, opt).define(&block)
   end
 
   def self.union (opt={}, &block)
-    return Struct::Builder.new(:union, opt).define(&block)
+    return CAStruct::Builder.new(:union, opt).define(&block)
   end
 
 end
@@ -290,7 +288,7 @@ end
 #
 # ---------------------------------------------------------------------
 
-class CA::Struct::Builder  # :nodoc:
+class CAStruct::Builder  # :nodoc:
 
   class Member # :nodoc:
 
@@ -358,9 +356,9 @@ class CA::Struct::Builder  # :nodoc:
     # ---
     case @type
     when :struct
-      klass = Class.new(CA::Struct)
+      klass = Class.new(CAStruct)
     when :union
-      klass = Class.new(CA::Union)
+      klass = Class.new(CAUnion)
     end
     # ---
     if @align.nil?
@@ -477,7 +475,7 @@ class CA::Struct::Builder  # :nodoc:
     if block
       opt = {:pack => @align}.update(opt)
       st = self.class.new(:struct, opt).define(&block)
-    elsif opt[:type] and opt[:type] <= CA::Struct
+    elsif opt[:type] and opt[:type] <= CAStruct
       st = opt[:type]
     else
       raise "type is not given for struct member of struct"
@@ -494,7 +492,7 @@ class CA::Struct::Builder  # :nodoc:
     if block
       opt = {:pack => @align}.update(opt)
       st = self.class.new(:union, opt).define(&block)
-    elsif opt[:type] and opt[:type] <= CA::Struct
+    elsif opt[:type] and opt[:type] <= CAStruct
       st = opt[:type]
     else
       raise "type is not given for union member of struct"
@@ -556,14 +554,14 @@ end
 
 
 
-class CA::Struct
+class CAStruct
 
   def self.spec
     output = ""
     table  = self::MEMBER_TABLE
     stlist = []
     if self.name.nil?
-      if self <= CA::Union
+      if self <= CAUnion
         prefix = "union"
       else
         prefix = "struct"
@@ -573,7 +571,7 @@ class CA::Struct
     else
       output << sprintf("%s = ", self.name)
     end
-    if self < CA::Union
+    if self < CAUnion
       output << sprintf("CA.union(:size=>%i) {\n", self::DATA_SIZE)
     else
       output << sprintf("CA.struct(:size=>%i) {\n", self::DATA_SIZE)
@@ -582,10 +580,10 @@ class CA::Struct
       offset, type, option = *table[member]
       case type
       when Class
-        if type < CA::Struct
+        if type < CAStruct
           stlist << type
           if type.name.nil?
-            if type <= CA::Union
+            if type <= CAUnion
               prefix = "union"
             else
               prefix = "struct"