from collections import namedtuple, OrderedDict
from lib import *
def virtual_container(virtual_container, objects_type):
"""Used to create a virtual object given a the type of container and what it holds.
The object_type needs to only have normal values."""
for name in objects_type:
if name.startswith("__") and name.endswith("__"):
raise ValueError("Arguments should be not start and end with __")
if issubclass(virtual_container,list):
def handle_binding(objects_type):
class my_virtual_container_class:
"""This singleton class represents the container"""
def __init__(self):
"""The attributes for the virtual container"""
#Define the default values
__vals__=OrderedDict([(key,None) for key in objects_type])
#Then function to access them. Note the default parameter for the lambda to
#enforce early binding
d={}
for key in objects_type:
def func_factory(key):
"""Function causes early binding for key"""
def make_attribute(self, items=None):
"""Called on the attr_cl. This function will return the list for the attribute.
As a default, this is [], but a list can also be passed in"""
if items==None:
items=[]
if self.__vals__[key]==None:
self.__vals__[key]=items
else:
raise RuntimeError("This attribute has been already initialised")
return self.__vals__[key]
return make_attribute
#Add the function to this class
d[key]=func_factory(key)
d["__vals__"]=__vals__
#Construct a named tuple from this
self.__attr__=type('attr_cl',(), d)()
#Define the operators
def __iter__(self):
vals=self.__attr__.__vals__
return zip(*vals.values())
def __contains__(self, x):
return x in self.__iter__()
def __delitem__(self, i):
#Handles items and slices
vals=self.__attr__.__vals__
for seq in vals.values():
del seq[i]
def __getitem__(self, i):
#Handles items and slices
vals=self.__attr__.__vals__
#Make it a slice
isslice=isinstance(i, slice)
if not isslice:
i=slice(i, i+1)
ret=[seq[i] for seq in vals.values()]
ret=list(zip(*ret))
if not isslice:
ret=ret[0]
return ret
def __setitem__(self, i, x):
#Handles items and slices
vals=self.__attr__.__vals__
#Split slices
if isinstance(i,slice):
x=zip(*x)
for seq, setTo in zip(vals.values(), x):
seq[i]=setTo
def __add__(self, myList):
return list(self.__iter__())+myList
def __iadd__(self, myList):
vals=self.__attr__.__vals__
for seq, extra in zip(vals.values(), zip(*myList)):
seq+=extra
return self
def __str__(self):
s="Proxy: Names: "+" ".join(self.__attr__.__vals__.keys())
s+=" Vals: "+" ".join(map(str,self.__iter__()))
return s
return my_virtual_container_class()
return handle_binding(objects_type)
#Example code
coordinates_2d=["x","y"]
coordinates=virtual_container(list, coordinates_2d)
x=coordinates.__attr__.x([1,2,3,4])
y=coordinates.__attr__.y([2,3,4,5])
print(coordinates[3])
print(coordinates[3:4])
print(coordinates[2:4])
for m in coordinates:
print(m, end=" ")
print()
print(coordinates+[1,2])
coordinates[1]=(0,0)
print(x,y)
coordinates+=[(9,9)]
print("##",coordinates[:])
del coordinates[1:3]
print(coordinates[:])
coordinates[0:2]=[(0,1),(3,4)]
print(coordinates)
#Testing second group of coordinates
coordinates2=virtual_container(list, coordinates_2d)
x2=coordinates2.__attr__.x([])
y2=coordinates2.__attr__.y([])
print("List is: ", end=" ")
for z in coordinates2:
print(z,end=" ")
print()
print(bool(coordinates2))
print(coordinates[0])
