Hi!
I want to implement a single/double chained list,
what I've done looks to much complicated (better to do a whole rewrite!)
- so: how would you do that (elegant!)
Where (in which class) to put which methods?
-three classes?? class1: Container for Lists, .new=>List, methods list1+list2, list1==list2
class2: Methods of list (List-Operations), methods: list1.name=...; list1.push el
class3: ListElement +links, methods: Element.new, el1==el2
class2+3 could be in one class, but list.new seems not to be compatible to element.new
(both list.new_element and list.new should be def initialize..., the get a new class-object!!)
classes 1+2 could also be merged into 1 class (class+object-methods)
BUT classes 1,2,3 can't be merged into one class -> whats a nice elegant way to combine that all / how to "classify" it best?
(wanted) RESULT:
list1 = Lists.new(:listA, :double) # Lists: Storage for many lists
# i would prefer: class DList < Lists(type= :double); end; list1 = DList.new(:listA) # how to do that?
list2 = Lists.new(:listB, :double)
list2.details => {type: :double, name: :listB, count: 0 /*Elements*/ }
Lists.count # 2 (Lists)
el1 = list1.new('abc')
el2 = list1.new('def')
el3 = ListA.new('ghi') # metaprogramming... # see below: #{Name}
list1.count # 3 Elements
list1.name # :listA
list1 # ['abc','def','ghi']
list1.map{|el| el } # ['abc','def','ghi']
list1.find('def').previous # 'abc'
list1.delete 'def'
list3 = list(1) + list(2) ## Lists.count+=1, because of list3=... ! ???
list2.destroy # removes Elements and list
Lists.count # 2
thank you!
---- (my try / forget the rest:) ---
class Lists
@@allLists = {}
def initialize(listname) # new list
erg = [] # should be List.new !
@@allLists[listname] = erg
return erg
end
def delete(name)
@@allLists -= @@allList[name]
end
def names
@@allLists.keys
end
def count
@@allLists.count
end
end
class List
def initialize(listname,type=:double) # new list(!)
@name=listname
@erg = [] # for example
@@allLists[listname] << erg
return @erg
end
def type # :no, :single or :double # -chained list (:no=array)
@type
end
def name=newname # Name of List => How can I then use #{Name}.new ?
@name=newname
end
def name
@name
end
def destroy # self
Lists.delete self.name
@erg.map{|el| el.destroy } # free it ??
@erg = nil
self.destroy # free self ??
end
def add_new(obj) # Element!
el = Element.new(obj)
@erg[-1][1][1] = self # set "Pointer" in previous element to this one
if self.type==:double then self[1][0] = @erg[-1] end # set prev ptr
@erg << el # add element to list
end
def push
add_new(obj)
end
def pop
end
def first
@erg[0]
end
def last
@erg[-1]
end
def insert_at
end
def delete_at
end
def next
el.previous # ??? # call next from class Element
end
def previous
el.next # ??? # class Element
end
@list_pos=-1
def each
if @list_pos<@erg.length then
@list_pos+=1
"return" @erg
end
## @erg.each{|el| el ... } # how to return
end
def reset
@list_pos=-1
end
def count # of elements
self.length
end
def remove_element(pos)
@erg[pos].delete # class Element
end
class Element
def initialize(obj) # new element
@erg = [obj,[previousEl,nextEl]]
end
def delete
self=nil # how to destroy the whole instance?
end
def previousEl # of self
@erg[1][0]
end
def nextEl # of self
@erg[1][1]
end
end
