worked on splitting regions and implemented set_allocator / set_consumer

[sfa.git] / gacks / gackscalendar.py

diff --git a/gacks/gackscalendar.py b/gacks/gackscalendar.py
index 33d3af9..35cbdc8 100644 (file)
--- a/gacks/gackscalendar.py
+++ b/gacks/gackscalendar.py
@@ -1,56 +1,92 @@
+from gacksexcep import *
+from gackshandle import *
+
 class GacksCalendar:
     def __init__(self):
         pass
 
-    def query(self, id, unitStart, unitStop, timeStart, timeStop):
+    def query(self, id=None, unitStart=0, unitStop=INFINITY, timeStart=0, timeStop=INFINITY):
         pass
 
     def insert_record(self, item):
         pass
 
+    def query_handles(self, handles):
+        results = []
+        for handle in handles:
+            items = query(handle.id, handle.unitStart, handle.unitStop, handle.timeStart, handle.timeStop)
+            for item in items:
+                if not item.is_in_list(results):
+                    results.append(item)
+        return results
+
+    def update_record(self, item):
+        remove_record(item)
+        insert_record(item)
+
 class GacksListCalendar(GacksCalendar):
     def __init__(self):
         self.items = []
 
-    def test_id(x, y):
+    def test_id(self, x, y):
         if not x:
             return True
         else:
             return (x == y)
 
-    def test_lesser(x, y):
+    def test_lesser(self, x, y):
         if not x:
             return True
-        else if y==INFINITY:
+        elif y==INFINITY:
             return True
         else:
             return (x<y)
 
-    def test_greater_equal(x, y):
+    def test_greater(self, x, y):
         if not x:
             return True
-        else if x==INFINITY:
+        elif x==INFINITY:
             return True
-        else if y==INFINITY:
+        elif y==INFINITY:
             return False
         else:
-            return (x>=y)
+            return (x>y)
 
-    def query(self, id, unitStart=0, unitStop=INFINITY, timeStart=0, timeStop=INFINITY):
+    def query(self, id=None, unitStart=0, unitStop=INFINITY, timeStart=0, timeStop=INFINITY):
         list = []
         for item in self.items:
-            if test_id(id, item.id) and
-               test_lesser(unitStart, item.unitStop) and
-               test_greater_equal(unitStop, item.unitStart) and
-               test_lesser(timeStart, item.timeStop) and
-               test_greater_equal(timeStop, item.timeStart):
-                 list = list + item
+            if self.test_id(id, item.id) and \
+               self.test_lesser(unitStart, item.unitStop) and \
+               self.test_greater(unitStop, item.unitStart) and \
+               self.test_lesser(timeStart, item.timeStop) and \
+               self.test_greater(timeStop, item.timeStart):
+                 list.append(item)
         return list
 
+    def find_record(self, item_to_delete):
+        list = []
+        for item in self.items:
+            if item.is_same_cell(item_to_delete):
+                list.append(item)
+
+        if not list:
+            return None
+
+        if len(list) > 1:
+            raise GacksMultipleRecordCollision(item_to_delete.as_string())
+
+        return list[0]
+
     def insert_record(self, item):
         conflicts = self.query(item.id, item.unitStart, item.unitStop, item.timeStart, item.timeStop)
-        for conflict in conflicts:
-            self.items.remove(conflict)
+        if conflicts:
+            raise GacksConflictingInsert(item.as_string())
 
         self.items.append(item)
 
+    def remove_record(self, item):
+         existing_record = self.find_record(item)
+         if existing_record:
+             self.items.remove(existing_record)
+
+