Some of the data I deal with involves hundreds of thousands of records
where each is very predictable in the number of attributes.  By going
from a hash based object to an array based object I am able to
substantially decrease memory usage.  However, the array based object
I have made (see below), is really lame for two reasons:

1. It is a pain to make a different array based class
2. When I call 'flatten' on an array of these objects, my objects get
flattened, too (how do I prevent this?)

I realize that I could just use arrays of arrays for all the objects,
but for ease of programming I'd like to be able to access an object's
attributes by name.  Does anyone know of some memory efficient and
fast way of doing this (that's insensitive to 'flatten')?

I've tried several times to create some kind of metaprogramming
version of this but always fail.

This works (as far as what I'm basically after), but it's very ugly:

  ind_keys = {} ; ind_keys_w_eq = {}; @@ind = {}
  ## The method name to index mapping
  ind_keys = {:shape => 0, :intensity => 1, :flare => 2, :alpha =>
3, :id => 4, :xposition => 5, :yposition => 6, :zposition => 7, :color
=> 8, :parent => 9 }

  @@arr_size = ind_keys.size

  ## Make a single class hash that maps getters and setters
  ind_keys.each {|k,v| ind_keys_w_eq["#{k}=".to_sym] = v }
  ind_keys.merge!(ind_keys_w_eq)
  ind_keys.each {|k,v| @@ind[k] = v ; @@ind["#{k}"] = v}

  ## Manually define getters and setters
  def shape ; self[0] end ; def shape=(oth) ; self[0] = oth end
  def intensity ; self[1] end ; def intensity=(oth) ; self[1] = oth
end
  def flare ; self[2] end ; def flare=(oth) ; self[2] = oth end
  def alpha ; self[3] end ; def alpha=(oth) ; self[3] = oth end
  def id ; self[4] end ; def id=(oth) ; self[4] = oth end
  def xposition ; self[5] end ; def xposition=(oth) ; self[5] = oth
end
  def yposition ; self[6] end ; def yposition=(oth) ; self[6] = oth
end
  def zposition ; self[7] end ; def zposition=(oth) ; self[7] = oth
end
  def color ; self[8] end ; def color=(oth) ; self[8] = oth end
  def parent ; self[9] end ; def parent=(oth) ; self[9] = oth end
  # The number of total proteins sharing this color
  def num_tot_proteins ; self[10] end ; def num_tot_proteins=(oth) ;
self[10] = oth end


  ## create an array of the exact object size or set from a hash
  def initialize(args=nil)
    super(@@arr_size.size)
    if args
      if args.is_a? Hash
        args.each do |k,v|
          self[@@ind[k]] = v
        end
      end
    end
  end

Ideas and suggestions are most welcome.  Thanks.