class Struct

Alteration to Struct for support of structural processing:

Public Class Methods

process(the_struct=::Struct.new(nil),&block) click to toggle source

# File lib/gxg/gxg_augmented.rb, line 3162
def self.process(the_struct=::Struct.new(nil),&block)
  new_struct = ::Struct.new(nil)
  if block.respond_to?(:call)
    if the_struct.is_any?(::Array, ::Hash, ::Struct, ::GxG::Database::PersistedHash, ::GxG::Database::PersistedArray)
      new_struct = the_struct.process!(&block)
    else
      raise ArgumentError, "you must pass a Hash, or an Array, or a ByteArray, or a Set, or a Struct"
    end
  end
  new_struct
end

search(the_struct=::Struct.new(nil),&block) click to toggle source

# File lib/gxg/gxg_augmented.rb, line 3174
def self.search(the_struct=::Struct.new(nil),&block)
  new_struct = ::Struct.new(nil)
  if block.respond_to?(:call)
    if the_struct.is_any?(::Array, ::Hash, ::Set, ::Struct, ::GxG::Database::PersistedHash, ::GxG::Database::PersistedArray)
      new_struct = the_struct.search(&block)
    else
      raise ArgumentError, "you must pass a Hash, or an Array, or a ByteArray, or a Set, or a Struct"
    end
  end
  new_struct
end

Public Instance Methods

clone() click to toggle source

# File lib/gxg/gxg_augmented.rb, line 3158
def clone()
  initialize_clone
end

dup()

Alias for: initialize_clone

initialize_clone() click to toggle source

# File lib/gxg/gxg_augmented.rb, line 3149
def initialize_clone
  result = self.class.new
  self.each_pair do |key, value|
    result[(key)] = value.clone
  end
  result
end

Also aliased as: initialize_dup, dup

initialize_dup()

Alias for: initialize_clone

iterative(&block) click to toggle source

def each_pair(&block)

# ok, bizarre : this method is listed in instance_methods but is missing when called.  hrm.
collection = {}
self.members.to_enum.each do |key|
  collection[(key)] = (self[(key)])
end
if block.respond_to?(:call)
  collection.to_enum(:each_pair).each do |key,value|
    block.call(key,value)
  end
else
  collection.to_enum(:each_pair)
end

end

# File lib/gxg/gxg_augmented.rb, line 3201
def iterative(&block)
  result = []
  visit = Proc.new do |the_node=nil, accumulator=[]|
    node_stack = []
    if the_node
      node_stack << ({:parent => nil, :parent_selector => nil, :object => (the_node)})
      while (node_stack.size > 0) do
        a_node = node_stack.shift
        #
        if a_node[:object].is_any?(::Hash, ::Struct, ::GxG::Database::PersistedHash)
          a_node[:object].each_pair do |the_key, the_value|
            node_stack << ({:parent => a_node[:object], :parent_selector => the_key, :object => the_value})
          end
        end
        if a_node[:object].is_any?(::Array, ::GxG::Database::PersistedArray)
          a_node[:object].each_with_index do |the_value, the_index|
            node_stack << ({:parent => a_node[:object], :parent_selector => the_index, :object => the_value})
          end
        end
        #
        accumulator << a_node
      end
    end
    accumulator
  end
  #
  children_of = Proc.new do |the_db=[], the_parent=nil|
    list = []
    the_db.each do |node|
      if node[:parent].object_id == the_parent.object_id
        list << node
      end
    end
    list
  end
  #
  begin
    database = visit.call(self,[])
    link_db = children_of.call(database, self)
    if block.respond_to?(:call)
      while (link_db.size > 0) do
        entry = link_db.shift
        unless entry[:object].object_id == self.object_id
          # calls with parameters: the_value, the_key/the_index (the_selector), the_container
          raw_result = block.call(entry[:object], entry[:parent_selector], entry[:parent])
          if raw_result
            result << raw_result
          end
        end
        if entry[:object].object_id != nil.object_id
          children = children_of.call(database, entry[:object])
          children.each do |child|
            link_db << child
          end
        end
      end
    end
    #
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {}})
  end
  #
  result
end

process(&block) click to toggle source

# File lib/gxg/gxg_augmented.rb, line 3266
def process(&block)
  result = self.clone
  result.iterative(&block)
  result
end

process!(&block) click to toggle source

# File lib/gxg/gxg_augmented.rb, line 3272
def process!(&block)
  self.iterative(&block)
  self
end

search(&block) click to toggle source

# File lib/gxg/gxg_augmented.rb, line 3277
def search(&block)
  results = []
  if block.respond_to?(:call)
    results = self.iterative(&block)
  end
  results
end