LIST better implementation

tpaviot · tpaviot · commit 50b9032d3202 · 2012-02-22T17:57:22.000+01:00
diff --git a/src/fedex_python/python/SCL/AggregationDataTypes.py b/src/fedex_python/python/SCL/AggregationDataTypes.py
@@ -126,16 +126,64 @@ def __setitem__(self, index, value):
                     raise AssertionError("UNIQUE keyword prevent inserting this instance.")
             self._container[index-self._bound_1] = value
 
-class LIST(list, BaseAggregate):
+class LIST(object):
     """A list data type has as its domain sequences of like elements. The optional lower and upper
     bounds, which are integer-valued expressions, define the minimum and maximum number of
     elements that can be held in the collection defined by a list data type.
     A list data type
     definition may optionally specify that a list value cannot contain duplicate elements.
     """
-    def __init__( self ,  bound1 , bound2 , base_type ):
-         BaseAggregate.__init__( self ,  bound1 , bound2 , base_type )
+    def __init__( self ,  bound_1 , bound_2 , base_type , UNIQUE = False):
+        if not type(bound_1)==int:
+            raise TypeError("LIST lower bound must be an integer")
+        # bound_2 can be set to None
+        if not type(bound_2)==int:
+            raise TypeError("LIST upper bound must be an integer")
+        if not bound_1>=0:
+            raise AssertionError("LIST lower bound must be greater of equal to 0")
+        if not (bound_1 <= bound_2):
+            raise AssertionError("ARRAY lower bound must be less than or equal to upper bound")
+        # set up class attributes
+        self._bound_1 = bound_1
+        self._bound_2 = bound_2
+        self._base_type = base_type
+        self._unique = UNIQUE
+        self._optional = OPTIONAL
+        # preallocate list elements
+        list_size = bound_2 - bound_1 + 1
+        self._container = list_size*[None]
     
+    def bound_1(self):
+        return self._bound_1
+
+    def bound_2(self):
+        return self._bound_2
+
+    def __getitem__(self, index):
+        if index<self._bound_1:
+            raise IndexError("ARRAY index out of bound (lower bound is %i, passed %i)"%(self._bound_1,index))
+        elif(index>self._bound_2):
+            raise IndexError("ARRAY index out of bound (upper bound is %i, passed %i)"%(self._bound_2,index))
+        else:
+            value = self._container[index-self._bound_1]
+            if not self._optional and value==None:
+                raise AssertionError("Not OPTIONAL prevent the value with index %i from being None (default). Please set the value first."%index)
+            return value
+ 
+    def __setitem__(self, index, value):
+        if index<self._bound_1:
+            raise IndexError("ARRAY index out of bound (lower bound is %i, passed %i)"%(self._bound_1,index))
+        elif(index>self._bound_2):
+            raise IndexError("ARRAY index out of bound (upper bound is %i, passed %i)"%(self._bound_2,index))
+        else:
+            # first check the type of the value
+            check_type(value,self._base_type)
+            # then check if the value is already in the array
+            if self._unique:
+                if value in self._container:
+                    raise AssertionError("UNIQUE keyword prevent inserting this instance.")
+            self._container[index-self._bound_1] = value
+
 class BAG(tuple, BaseAggregate):
     """A bag data type has as its domain unordered collections of like elements. The optional lower
     and upper bounds, which are integer-valued expressions, dene the minimum and maximum
diff --git a/src/fedex_python/python/SCL/SimpleDataTypes.pyc b/src/fedex_python/python/SCL/SimpleDataTypes.pyc
diff --git a/src/fedex_python/python/SCL/TypeChecker.py b/src/fedex_python/python/SCL/TypeChecker.py
@@ -33,13 +33,14 @@
 
 RAISE_EXCEPTION_IF_TYPE_DOES_NOT_MATCH = False
 
-def cast_python_list_to_aggregate(lst, aggregate):
-    """ This function casts a python list to an aggregate type. For instance:
+def cast_python_object_to_aggregate(obj, aggregate):
+    """ This function casts a python object to an aggregate type. For instance:
     [1.,2.,3.]-> ARRAY(1,3,REAL)"""
     aggregate_lower_bound = aggregate.bound_1()
     aggregate_upper_bound = aggregate.bound_2()
-    for idx in range(aggregate_lower_bound,aggregate_upper_bound+1):
-        aggregate[idx] = lst[idx-aggregate_lower_bound]
+    if type(obj)==list:
+        for idx in range(aggregate_lower_bound,aggregate_upper_bound+1):
+            aggregate[idx] = obj[idx-aggregate_lower_bound]
     return aggregate
     
 def check_type(instance, expected_type):
