From 92fe12a0d1c2d90f067f7a39b84228a6c9840285 Mon Sep 17 00:00:00 2001 From: Torsten Ruger Date: Sun, 25 Oct 2015 19:32:36 +0200 Subject: [PATCH] move methods back to the module easier to read and debug --- lib/parfait/indexed.rb | 242 ++++++++++++++++++++++------------------- lib/parfait/layout.rb | 12 -- lib/parfait/list.rb | 13 --- 3 files changed, 129 insertions(+), 138 deletions(-) diff --git a/lib/parfait/indexed.rb b/lib/parfait/indexed.rb index 310e4131..583d7165 100644 --- a/lib/parfait/indexed.rb +++ b/lib/parfait/indexed.rb @@ -16,64 +16,137 @@ module Parfait base.extend(Methods) end + # include? means non nil index + def include? item + return index_of(item) != nil + end + + # index of item, remeber first item has index 1 + # return nil if no such item + def index_of item + max = self.get_length + counter = 1 + while( counter <= max ) + if( get(counter) == item) + return counter + end + counter = counter + 1 + end + return nil + end + + # push means add to the end + # this automatically grows the List + def push value + set( self.get_length + 1 , value) + end + + def delete value + index = index_of value + return false unless index + delete_at index + end + + def delete_at index + # TODO bounds check + while(index < self.get_length) + set( index , get(index + 1)) + index = index + 1 + end + set_length( self.get_length - 1) + true + end + + def first + return nil if empty? + get(1) + end + + def last + return nil if empty? + get(get_length()) + end + + def empty? + self.get_length == 0 + end + + def equal? other + # this should call parfait get_class, alas that is not implemented yet + return false if other.class != self.class + return false if other.get_length != self.get_length + index = self.get_length + while(index > 0) + return false if other.get(index) != self.get(index) + index = index - 1 + end + return true + end + + # above, correct, implementation causes problems in the machine object space + # because when a second empty (newly created) list is added, it is not actually + # added as it exists already. TODO, but hack with below identity function + def == other + self.object_id == other.object_id + end + + # word length (padded) is the amount of space taken by the object + # For your basic object this means the number of instance variables as determined by layout + # This is off course 0 for a list, unless someone squeezed an instance variable in + # but additionally, the amount of data comes on top. + # unfortuntely we can't just use super because of the Padding + def word_length + padded_words( get_layout().get_length() + get_length() ) + end + + def each + # not sure how to do this with define_method, because of the double block issue. + # probably some clever way around that, but not important + index = 1 + get_offset + while index <= self.get_length + item = get(index) + yield item + index = index + 1 + end + self + end + + def set_length len + was = self.get_length + return if was == len + if(was < len) + grow_to len + else + shrink_to len + end + end + + def inspect + inspect_from 1 + end + + def inspect_from index + ret = "" + while index <= self.get_length + item = get(index) + ret += item.inspect + ret += "," unless index == self.get_length + index = index + 1 + end + ret + end + module Methods def offset( offset ) + define_method :get_offset do + offset + end + define_method :get_length do - internal_object_length - 1 + internal_object_length - 1 - offset end - # index of item, remeber first item has index 1 - # return nil if no such item - define_method :index_of do |item| - max = self.get_length - counter = 1 - while( counter <= max ) - if( get(counter) == item) - return counter - end - counter = counter + 1 - end - return nil - end - - # include? means non nil index - define_method :include? do |item| - return index_of(item) != nil - end - - # push means add to the end - # this automatically grows the List - define_method :push do |value| - set( self.get_length + 1 , value) - end - - define_method :delete do |value| - index = index_of value - return false unless index - delete_at index - end - - define_method :delete_at do |index| - # TODO bounds check - while(index < self.get_length) - set( index , get(index + 1)) - index = index + 1 - end - set_length( self.get_length - 1) - true - end - - - define_method :first do - return nil if empty? - get(1) - end - - define_method :last do - return nil if empty? - get(get_length()) - end # set the value at index. # Lists start from index 1 @@ -83,7 +156,7 @@ module Parfait grow_to(index) end # internally 1 is reserved for the layout - internal_object_set( index + 1, value) + internal_object_set( index + 1 + offset, value) end # set the value at index. @@ -93,21 +166,7 @@ module Parfait if index > self.get_length return nil else - return internal_object_get(index + 1) - end - end - - define_method :empty? do - self.get_length == 0 - end - - define_method :set_length do | len| - was = self.get_length - return if was == len - if(was < len) - grow_to len - else - shrink_to len + return internal_object_get(index + offset + 1) end end @@ -115,57 +174,14 @@ module Parfait raise "Only positive lenths, #{len}" if len < 0 old_length = self.get_length return if old_length >= len - internal_object_grow(len + 1) + internal_object_grow(len + 1 + offset) end define_method :shrink_to do | len| raise "Only positive lenths, #{len}" if len < 0 old_length = self.get_length return if old_length <= len - internal_object_shrink(len + 1) - end - - define_method :equal? do | other| - # this should call parfait get_class, alas that is not implemented yet - return false if other.class != self.class - return false if other.get_length != self.get_length - index = self.get_length - while(index > 0) - return false if other.get(index) != self.get(index) - index = index - 1 - end - return true - end - - # above, correct, implementation causes problems in the machine object space - # because when a second empty (newly created) list is added, it is not actually - # added as it exists already. TODO, but hack with below identity function - define_method :== do | other| - self.object_id == other.object_id - end - - # word length (padded) is the amount of space taken by the object - # For your basic object this means the number of instance variables as determined by layout - # This is off course 0 for a list, unless someone squeezed an instance variable in - # but additionally, the amount of data comes on top. - # unfortuntely we can't just use super because of the Padding - define_method :word_length do - padded_words( get_layout().get_length() + get_length() ) - end - - define_method :inspect do - inspect_from 1 - end - - define_method :inspect_from do |index| - ret = "" - while index <= self.get_length - item = get(index) - ret += item.inspect - ret += "," unless index == self.get_length - index = index + 1 - end - ret + internal_object_shrink(len + 1 + offset) end end diff --git a/lib/parfait/layout.rb b/lib/parfait/layout.rb index 188658fc..014f9e35 100644 --- a/lib/parfait/layout.rb +++ b/lib/parfait/layout.rb @@ -25,18 +25,6 @@ module Parfait include Indexed self.offset(0) - def each - # not sure how to do this with define_method, because of the double block issue. - # probably some clever way around that, but not important - index = 1 - while index <= self.get_length - item = get(index) - yield item - index = index + 1 - end - self - end - attribute :object_class def initialize( object_class ) diff --git a/lib/parfait/list.rb b/lib/parfait/list.rb index c93c78ec..270c2043 100644 --- a/lib/parfait/list.rb +++ b/lib/parfait/list.rb @@ -23,19 +23,6 @@ module Parfait alias :[] :get - - def each - # not sure how to do this with define_method, because of the double block issue. - # probably some clever way around that, but not important - index = 1 - while index <= self.get_length - item = get(index) - yield item - index = index + 1 - end - self - end - #ruby 2.1 list (just for reference, keep at bottom) # :at, :fetch, :first, :last, :concat, :<<, :push, :pop, :shift, :unshift, :insert, :each, :each_index, :reverse_each, # :length, :size, :empty?, :find_index, :index, :rindex, :join, :reverse, :reverse!, :rotate, :rotate!,