icss 0.1.3 → 0.3.2

data/lib/icss/type/named_type.rb

@@ -0,0 +1,184 @@
+module Icss
+  module Meta
+
+    #
+    # Record, Error, Enum and Fixed are named types. Each has a fullname that is
+    # composed of two parts; a name and a namespace. Equality of names is
+    # defined on the fullname.
+    #
+    # The name portion of a fullname, and record field names, must:
+    #
+    # * start with [A-Za-z_]
+    # * subsequently contain only [A-Za-z0-9_]
+    # * A namespace is a dot-separated sequence of such names.
+    #
+    # References to previously defined names are as in the latter two cases above:
+    # if they contain a dot they are a fullname, if they do not contain a dot, the
+    # namespace is the namespace of the enclosing definition.
+    #
+    # Simple type names have no namespace and their names may not be defined in
+    # any namespace. A schema may only contain multiple definitions of a
+    # fullname if the definitions are equivalent.
+    #
+    module NamedType
+      def doc() "" end
+      def doc=(str)
+        singleton_class.class_eval do
+          remove_possible_method(:doc)
+          define_method(:doc){ str }
+        end
+      end
+      #
+      def fullname
+        ::Icss::Meta::Type.fullname_for(self.name)
+      end
+      def basename
+        @basename  ||= fullname.to_s.gsub(/.*[\.]/, "")
+      end
+      def namespace
+        @namespace ||= fullname.to_s.include?('.') ? fullname.to_s.gsub(/\.[^\.]+\z/so, '') : ''
+      end
+      def pathname
+        fullname.to_s.gsub(/\./, '/')
+      end
+      #
+      def to_schema
+        if respond_to?(:_schema) then return _schema.to_hash ; end
+        {
+          :name      => fullname,
+          # :namespace => namespace,
+          :doc       => doc,
+        }.compact_blank
+      end
+      
+      def is_core?
+        respond_to?(:_schema) && _schema.is_core?
+      end
+
+      # ---------------------------------------------------------------------------
+      #
+      # Type Factory methods
+      #
+
+      #
+      # Returns the metamodel -- a module extending the type, on which all the
+      # accessors and receive methods are inscribed. (This allows you to call
+      # +super()+ from within receive_foo)
+      #
+      def metamodel
+        return @metamodel if @metamodel
+        @metamodel = Icss::Meta::NamedType.get_meta_module(self.to_s)
+        self.class_eval{ include(@metamodel) }
+        @metamodel
+      end
+
+      #
+      # Manufactures klass and metamodel
+      #
+      # for type science.astronomy.ufo_sighting, we synthesize
+      # * a module, ::Icss::Meta::Science::Astronomy::UfoSightingType
+      # * a class,  ::Icss::Science::Astronomy::UfoSighting
+      #
+      # If no superklass is given, Icss::Entity is used.
+      def self.make(fullname, superklass)
+        klass    = get_model_klass(fullname, superklass)
+        metamodel = get_meta_module(klass.to_s)
+        klass.class_eval{ extend(::Icss::Meta::NamedType) }
+        klass.class_eval{ include(metamodel) }
+        [klass, metamodel]
+      end
+
+    protected
+
+      def define_metamodel_method(meth_name, visibility=:public, &blk)
+        metamodel.class_eval do
+          define_method(meth_name, &blk) unless method_defined?(meth_name)
+          case visibility
+          when :protected then protected meth_name
+          when :private   then private   meth_name
+          when :public    then public    meth_name
+          else raise ArgumentError, "visibility must be :public, :private or :protected"
+          end
+        end
+      end
+
+      # Returns the klass for the given scope and name, starting with '::Icss'
+      # and creating all necessary parents along the way. Note that if the given
+      # class or its parent scopes already exist, they're trusted to be correct
+      # -- we don't do any error checking as to their type or superclass.
+      #
+      # @example
+      #   Icss::Meta::Type.get_model_klass('this.that.the_other')
+      #   # Icss::This::That::TheOther
+      #
+      # @param scope_names [Array of String]
+      # @param superklass  [Class] - the superclass to use if the class doesn't exist.
+      def self.get_model_klass(fn, superklass)
+        fullname = Icss::Meta::Type.fullname_for(fn)
+        return Class.new(superklass) if fullname.nil?
+        #
+        scope_names   = scope_names_for(fullname)
+        klass_name    = scope_names.pop
+        parent_module = get_nested_module(%w[Icss] + scope_names)
+        
+        # const_defined?(klass, inherit), const_get(klass, inherit)
+        # inherit = false makes these methods be scoped to parent_module instead of universally
+        if parent_module.const_defined?(klass_name, false)
+          klass = parent_module.const_get(klass_name, false)
+          # #{superklass.object_id}: #{klass.ancestors.map{|o| [o, o.object_id] }}
+          unless klass.ancestors.include?(superklass)
+            warn "+++++++++++++++++++++++++++++++ Superclass and is_a? mismatch for #{klass.inspect} (doesn't inherit from #{superklass.inspect})"
+            # p [klass_name, klass, Icss::Thing.object_id, ::Icss::Thing.object_id, Icss.const_get(:Thing).object_id,]
+            # p klass      .ancestors.flatten.map{|t| [t, t.object_id]}
+            # p Icss::Thing.ancestors.flatten.map{|t| [t, t.object_id]}
+          end
+          klass
+        else
+          parent_module.const_set(klass_name, Class.new(superklass))
+        end
+      end
+
+      # Returns the meta-module for the given scope and name, starting with
+      # '::Icss::Meta' and creating all necessary parents along the way.
+      # @example
+      #   Icss::Meta::TypeFactory.get_meta_module(["This", "That"], "TheOther")
+      #   # Icss::Meta::This::That::TheOtherModel
+      def self.get_meta_module(fullname)
+        fullname = Icss::Meta::Type.fullname_for(fullname)
+        return Module.new if fullname.nil?
+        #
+        scope_names      = scope_names_for(fullname)
+        scope_names[-1] += "Model"
+        get_nested_module(%w[Icss Meta] + scope_names)
+      end
+
+      # Turns a dotted namespace.name into camelized rubylike names for a class
+      # @example
+      #   scope_names_for('this.that.the_other')
+      #   # ["This", "That", "TheOther"]
+      def self.scope_names_for(fullname)
+        fullname.split('.').map(&:camelize)
+      end
+
+      # Returns a module for the given scope names, rooted always at Object (so
+      # implicity with '::').
+      # @example
+      #   get_nested_module(["This", "That", "TheOther"])
+      #   # This::That::TheOther
+      def self.get_nested_module(scope_names)
+        scope_names.inject(Object) do |parent_module, module_name|
+          
+          # const_defined?(klass, inherit), const_get(klass, inherit)
+          # inherit = false makes these methods be scoped to parent_module instead of universally
+          if parent_module.const_defined?(module_name, false)
+            parent_module.const_get(module_name, false)
+          else
+            parent_module.const_set(module_name.to_sym, Module.new)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/icss/type/record_field.rb

@@ -0,0 +1,77 @@
+module Icss
+  module Meta
+
+    class RecordField
+      include Icss::Meta::RecordModel
+      include Icss::ReceiverModel::ActsAsHash
+      include Gorillib::Hashlike
+      include Gorillib::Hashlike::Keys
+      include Icss::ReceiverModel
+      include Icss::ReceiverModel::ActiveModelShim
+      remove_possible_method(:type)
+
+      ALLOWED_ORDERS = %w[ascending descending ignore].freeze unless defined?(ALLOWED_ORDERS)
+
+      field :name,       Symbol,                  :required => true
+      field :type,       Icss::Meta::TypeFactory, :required => true
+      field :doc,        String
+      field :default,    Icss::Meta::IdenticalFactory
+      field :replace,    Hash
+      field :required,   Boolean
+      field :aliases,    Array,   :items => Symbol
+      field :order,      String,  :validates => { :inclusion => { :in => ALLOWED_ORDERS } }
+      field :accessor,   Symbol
+      field :receiver,   Symbol
+      field :validates,  Hash
+      rcvr_remaining :_extra_params
+      attr_accessor :parent
+
+      # FIXME: cruft
+      field :indexed_on, Symbol
+      field :identifier, Boolean, :doc => 'indicates the field is suitable for use'
+
+      after_receive(:warnings) do |hsh|
+        warn "Extra params given to field #{self}: #{_extra_params.inspect}" if _extra_params.present?
+        warn "Validation failed for field #{self}: #{errors.inspect}" if respond_to?(:errors) && (not valid?)
+      end
+
+      # track recursion of type references
+      after_receive(:am_i_a_reference) do |hsh|
+        hsh = hsh.symbolize_keys
+        nonreference_klasses = [::Icss::Meta::ArrayType, ::Icss::Meta::HashType, ::Icss::Meta::EnumType, ::Icss::Meta::FixedType]
+        
+        @is_reference = (hsh[:type].is_a?(String) || hsh[:type].is_a?(Symbol) || (hsh[:type].is_a?(Class) && nonreference_klasses.none?{|klass| hsh[:type].is_a?(klass) }))
+      end
+
+      # is the field a reference to a named type (true), or an inline schema (false)?
+      def is_reference?() @is_reference ; end
+
+      def to_hash()
+        hsh = super
+        hsh = hsh.merge({ :type => (is_reference? ? type.fullname : Type.schema_for(type)) })
+        hsh.delete(:_extra_params)
+        hsh
+      end
+      def to_schema
+        to_hash
+      end
+
+      # Hack hack -- makes it so fields go thru the receiver door when merged in RecordType
+      def merge(hsh)
+        dup.receive!(hsh)
+      end
+
+      # Order is defined by the avro spec
+      def order()           @order || 'ascending' ; end
+      def order_direction() case order when 'ascending' then 1 when 'descending' then -1 else 0 ; end ; end
+    end
+
+    module RecordType
+    protected
+      # create new field_schema as a RecordField object, not Hash
+      def make_field_schema
+        RecordField.new
+      end
+    end
+  end
+end

data/lib/icss/type/record_model.rb

@@ -0,0 +1,49 @@
+module Icss
+  module Meta
+
+    module RecordModel
+      def self.included(base)
+        base.extend(Icss::Meta::RecordType)
+        base.metamodel
+      end
+
+      #
+      # modify object in place with new typecast values.
+      #
+      def receive!(hsh={})
+        raise ArgumentError, "Can't receive (it isn't hashlike): {#{hsh.inspect}}" unless hsh.respond_to?(:[]) && hsh.respond_to?(:has_key?)
+        self.class.send(:_rcvr_methods).each do |attr, meth|
+          if    hsh.has_key?(attr)      then val = hsh[attr]
+          elsif hsh.has_key?(attr.to_s) then val = hsh[attr.to_s]
+          else next ; end
+          self.send(meth, val)
+        end
+        run_after_receivers(hsh)
+        self
+      end
+
+      # true if the attr is a receiver variable and it has been set
+      def attr_set?(attr)
+        self.class.has_field?(attr) && self.instance_variable_defined?("@#{attr}")
+      end
+
+      def unset!(attr)
+        self.send(:remove_instance_variable, "@#{attr}") if self.instance_variable_defined?("@#{attr}")
+      end
+      protected :unset!
+
+    protected
+
+      def run_after_receivers(hsh)
+        self.class.after_receivers.each do |after_hook_name, after_hook|
+          self.instance_exec(hsh, &after_hook)
+        end
+      end
+
+      def _set_field_val(field_name, val)
+        self.instance_variable_set("@#{field_name}", val)
+      end
+
+    end
+  end
+end

data/lib/icss/type/record_schema.rb

@@ -0,0 +1,54 @@
+module Icss
+  module Meta
+
+    class RecordSchema < SimpleSchema
+      include Icss::Meta::RecordModel
+      include Icss::ReceiverModel::ActsAsHash
+      include Gorillib::Hashlike
+      include Gorillib::Hashlike::Keys
+      #
+      field :_domain_id_field, String,  :default => 'name'
+      field :_doc_hints,       Hash,    :default => {}
+      field :fields,           Array,   :default => []
+      #
+      
+      def type() :record ; end
+
+      def to_hash
+        {
+          :name      => basename,
+          :namespace => namespace,
+          :type      => type,
+          :is_a      => (respond_to?(:is_a) ? is_a : []),
+          :doc       => doc,
+          :fields    => fields.map(&:to_schema),
+         }.compact_blank
+      end
+
+      def model_klass
+        return @model_klass if @model_klass
+        super
+        @model_klass.class_eval{ include(::Icss::Meta::RecordModel)}
+        self.fields.each do |field_schema|
+          @model_klass.field(field_schema[:name], field_schema[:type], field_schema)
+        end
+        @model_klass
+      end
+
+      def receive_fields(flds)
+        super(flds.map(&:symbolize_keys!))
+      end
+
+      def attrs_to_inscribe
+        [ :doc, :fullname, :is_a, :_domain_id_field, :_doc_hints ]
+      end
+    end
+
+    class ErrorSchema
+      include Icss::Meta::RecordType
+    end
+    module ErrorModel
+    end
+
+  end
+end

data/lib/icss/type/record_type.rb

@@ -0,0 +1,325 @@
+require 'icss/type/type_factory'
+
+module Icss
+  module Meta
+
+    #
+    # RecordType -- class methods for a RecordModel
+    #
+    # Endows the model class with
+    # * klass.field  -- adds a field
+    # * klass.fields -- list of record_fields
+    #
+    # * klass.after_receive(&blk) -- blocks to execute after .receive is called
+    # * klass.after_receivers     -- list of after_receivers
+    # * klass.metamodel           -- overlay module that actually carries the model's instance methods
+    # * klass.to_schema           --
+    module RecordType
+      include Icss::Meta::NamedType
+
+      #
+      # Returns a new instance with the given hash used to set all rcvrs.
+      #
+      # All args up to the last one are passed to the initializer.
+      # The last arg must be a hash -- its attributes are set on the newly-created object
+      #
+      # @param hsh [Hash] attr-value pairs to set on the newly created object.
+      # @param *args [Array] arguments to pass to the constructor
+      # @return [Object] a new instance
+      def receive *args
+        hsh = args.pop
+        raise ArgumentError, "#{self} can't receive '#{hsh.inspect}' (it isn't hashlike)" unless hsh.respond_to?(:[]) && hsh.respond_to?(:has_key?)
+        obj = self.new(*args)
+        obj.receive!(hsh)
+      end
+
+      #
+      # Describes a field in a Record object.
+      #
+      # Each field has the following attributes:
+      #
+      # @param [Symbol] name -- a string providing the name of the field
+      #   (required)
+      #
+      # @param [Class, Icss::Meta::Type] type a schema, or a string or symbol
+      #   naming a record definition (required)
+      #
+      #     avro type     json type   ruby type   kind        example
+      #     ---------     ---------   ----------  --------    ---------
+      #     null          null        NilClass    simple   nil
+      #     boolean       boolean     Boolean     simple   true
+      #     int,long      integer     Integer     simple   1
+      #     float,double  number      Float       simple   1.1
+      #     bytes         string      String      simple   "\u00FF"
+      #     string        string      String      simple   "foo"
+      #     record        object      RecordModel  named       {"a": 1}
+      #     enum          string      Enum        named       "FOO"
+      #     array         array       Array       container  [1]
+      #     map           object      Hash        container  { "a": 1 }
+      #     fixed         string      String      container  "\u00ff"
+      #     union         object      XxxFactory  union
+      #     time          string      Time        simple      "2011-01-02T03:04:05Z"
+      #
+      # @option schema [String] :doc -- description of field for users (optional)
+      #
+      # @option schema [Object] :default -- a default value for this field, used
+      #   when reading instances that lack this field (optional).
+      #   Permitted values depend on the field's schema type, according to the
+      #   table below. Default values for union fields correspond to the first
+      #   schema in the union. Default values for bytes and fixed fields are
+      #   JSON strings, where Unicode code points 0-255 are mapped to unsigned
+      #   8-bit byte values 0-255.
+      #
+      # @option schema [String] :order -- specifies how this field impacts sort
+      #   ordering of this record (optional).
+      #   Valid values are "ascending" (the default), "descending", or
+      #   "ignore". For more details on how this is used, see the the sort
+      #   order section below.
+      #
+      # @option schema [Boolean] :required -- same as :validates => :presence
+      #
+      # @option schema [Hash] :validates -- sends the validation on to
+      #   Icss::Type::Validations. Uses syntax parallel to ActiveModel's:
+      #
+      # @option schema [Symbol] :accessor -- with +:none+, no accessor is
+      #   created. With +:protected+, +:private+, or +:public+, applies
+      #   corresponding access rule.
+      #
+      #      :presence     => true
+      #      :uniqueness   => true
+      #      :numericality => true
+      #      :length       => { :minimum => 0, maximum => 2000 }
+      #      :format       => { :with => /.*/ }
+      #      :inclusion    => { :in => [1,2,3] }
+      #      :exclusion    => { :in => [1,2,3] }
+      #
+      def field(field_name, type, schema={})
+        field_name = field_name.to_sym
+        #
+        schema = add_field_schema(field_name, type, schema)
+        add_field_accessor(field_name, schema)
+        rcvr(field_name, schema)
+        add_validator(field_name) if respond_to?(:add_validator)
+      end
+
+      def field_names
+        all_f = []
+        call_ancestor_chain(:field_names){|anc_f| all_f = all_f | anc_f }
+        all_f
+      end
+
+      def fields
+        field_schemas.values # _at(*field_names)
+      end
+
+      def field_named(fn)
+        fn = fn.to_sym
+        ancestors.each{|anc| hsh = anc.instance_variable_get('@field_schemas') or next ; return(hsh[fn]) if hsh[fn] }
+        nil
+      end
+
+      def has_field?(fn)
+        !! field_schemas.has_key?(fn.to_sym)
+      end
+
+      #
+      # define a receiver attribute.
+      #
+      # @param  [Symbol]  field_name - name of the receiver property
+      # @param  [Class]   type - a
+      #
+      # @option [Object]  :default  - After any receive! operation, attribute is set to this value unless attr_set? is true
+      # @option [Class]   :items       - For collections (Array, Hash, etc), the type of the collection's items
+      #
+      def rcvr(field_name, schema={})
+        return if schema[:receiver] == :none
+        klass = schema[:type]
+        define_metamodel_method("receive_#{field_name}") do |val|
+          _set_field_val(field_name, klass.receive(val))
+        end
+        _register_rcvr_for(field_name, "receive_#{field_name}")
+        add_after_receivers(field_name)
+      end
+
+      def rcvr_alias(fake_attr, field_name)
+        _register_rcvr_for(fake_attr, "receive_#{field_name}")
+      end
+
+      #
+      def to_schema
+        {
+          :name      => fullname,
+          :namespace => namespace,
+          :type      => :record,
+          :is_a      => (respond_to?(:is_a) ? is_a : []),
+          :doc       => doc,
+          :fields    => fields.map(&:to_hash),
+         }.compact_blank
+      end
+
+      #
+      # Defines a receiver for attributes sent to receive! that are
+      # * not defined as receivers
+      # * field's name does not start with '_'
+      #
+      # @example
+      #     class Foo ; include RecordModel
+      #       field  :bob, String
+      #       rcvr_remaining :other_params
+      #     end
+      #     foo_obj = Foo.receive(:bob => 'hi, bob", :joe => 'hi, joe')
+      #     # => <Foo @bob='hi, bob' @other_params={ :joe => 'hi, joe' }>
+      def rcvr_remaining(field_name, schema={})
+        schema[:values] ||= Object
+        field(field_name, Hash, schema)
+        after_receive(:rcvr_remaining) do |hsh|
+          remaining_vals_hsh = hsh.reject{|k,v| (self.class.has_field?(k)) || (k.to_s =~ /^_/) }
+          self.send("receive_#{field_name}", remaining_vals_hsh)
+        end
+        add_after_receivers(field_name)
+      end
+
+      # make a block to run after each time  .receive! is invoked
+      def after_receive(after_hook_name, &after_hook)
+        @after_receivers ||= {}
+        @after_receivers[after_hook_name] = after_hook
+      end
+
+      # after_receive blocks for self and all ancestors
+      def after_receivers
+        all_f = {} # @after_receivers || {}
+        call_ancestor_chain(:after_receivers){|anc_f| all_f.merge!(anc_f) }
+        all_f
+      end
+
+    protected
+
+      #
+      # yield, in turn, the given instance variable from each ancestor having
+      # that variable. Ancestors are called from parent to great-grandparent
+      #
+      # So you're asking yourself "Self, why not just call .super?
+      #
+      # Consider:
+      #
+      #   class Base
+      #     extend(Icss::Meta::RecordType)
+      #     field :smurfiness, Integer
+      #   end
+      #   class Poppa < Base
+      #     field :height, Integer
+      #   end
+      #
+      # Poppa.field_names calls Icss::Meta::RecordType --
+      # it's the first member of its inheritance chain to define the method.
+      # We want it to do so for each ancestor that has added fields.
+      def call_ancestor_chain(attr)
+        # if caller.length > 200
+        #   puts "\n\n********\n#{self}\n#{attr}\n#{ancestors.inspect}"
+        #   puts caller.grep(%r{lib/icss})
+        # end
+        ivar = "@#{attr}"
+        self.ancestors.reverse.each do |ancestor|
+          yield(ancestor.instance_variable_get(ivar)) if ancestor.instance_variable_defined?(ivar)
+        end
+      end
+
+      def make_field_schema
+        Hash.new
+      end
+
+      def field_schemas
+        all_f = {}
+        call_ancestor_chain(:field_schemas){|anc_f| all_f.merge!(anc_f) }
+        all_f
+      end
+
+      # register the field schema internally.
+      # To preserve field order for 1.8.7, we track field names as an array
+      def add_field_schema(name, type, schema)
+        @field_names ||= [] ; @field_schemas ||= {}
+        @field_names = @field_names | [name]
+        schema = schema.symbolize_keys.merge({ :name => name })
+        #
+        # FIXME: this is terrible, especially given what's in TypeFactory anyway.
+        #
+        schema[:type] =
+        case
+        when type == Hash  && schema.has_key?(:values) then Icss::Meta::TypeFactory.receive({ :type => :hash,  :values => schema.delete(:values)})
+        when type == Array && schema.has_key?(:items)  then Icss::Meta::TypeFactory.receive({ :type => :array, :items  => schema.delete(:items) })
+        when type == Hash  then IdenticalHashFactory
+        when type == Array then IdenticalArrayFactory
+        else
+          Icss::Meta::TypeFactory.receive(type)
+        end
+        fld = (field_schemas[name] || make_field_schema).merge(schema)
+        fld[:parent] = self
+        @field_schemas[name] = fld
+      end
+
+      def add_field_accessor(field_name, schema)
+        visibility = schema[:accessor] || :public
+        reader_meth = field_name ; writer_meth = "#{field_name}=" ; attr_name = "@#{field_name}"
+        unless (visibility == :none)
+          define_metamodel_method(reader_meth, visibility){    instance_variable_get(attr_name)    }
+          define_metamodel_method(writer_meth, visibility){|v| instance_variable_set(attr_name, v) }
+        end
+      end
+
+      def _rcvr_methods
+        all_f = {}
+        call_ancestor_chain(:_rcvr_methods){|anc_f| all_f.merge!(anc_f) }
+        all_f
+      end
+
+      def _register_rcvr_for(attr_name, rcvr_meth)
+        @_rcvr_methods ||= {}
+        @_rcvr_methods[attr_name.to_sym] = rcvr_meth.to_sym
+      end
+
+      # Adds after_receivers to implement some of the options to .field
+      #
+      # @option schema [Object] :default -- if field is unset by time of
+      #   after_receive, the field will be set to a copy of this value
+      #
+      # @option schema [Hash] :replace -- if value is in the hash
+      #   class Foo < Icss::Thing
+      #     field :temperature, Integer, :replace => { 9999 => nil }
+      #   end
+      #   f = Foo.receive({:temperature => 9999})
+      #   # #<Foo:0x10156c820 @temperature=nil>
+      #
+      def add_after_receivers(field_name)
+        schema = field_named(field_name)
+        set_field_default(field_name, schema[:default]) if schema.has_key?(:default)
+        if schema.has_key?(:replace)
+          repl = schema[:replace]
+          after_receive(:"replace_#{field_name}") do
+            val = self.send(field_name)
+            if repl.has_key?(val)
+              self._set_field_val(field_name, repl[val])
+            end
+          end
+        end
+        # super(field_name) if defined?(super)
+      end
+      
+
+      def set_field_default(field_name, default_val=nil, &blk)
+        blk = default_val if default_val.is_a?(Proc)
+        if blk
+          after_receive(:"default_#{field_name}") do
+            val = instance_exec(&blk)
+            self._set_field_val(field_name, val) unless attr_set?(field_name)
+          end
+        else
+          after_receive(:"default_#{field_name}") do
+            val = default_val.try_dup
+            self._set_field_val(field_name, val) unless attr_set?(field_name)
+          end
+        end
+      end
+
+    end # RecordType
+  end
+end