Changeset 18

Timestamp:

12/31/01 06:38:54 (7 years ago)

Author:

arjanmol

Message:

New Element implementation

Files:

• trunk/gaphor/AUTHORS (modified) (1 diff)
• trunk/gaphor/ChangeLog (modified) (1 diff)
• trunk/gaphor/configure.in (modified) (1 diff)
• trunk/gaphor/gaphor/UML/Element.py (modified) (11 diffs)

trunk/gaphor/AUTHORS

@@ -1 @@
-@xirion
+molenaar@hetnet

trunk/gaphor/ChangeLog

@@ +1 @@
+2001-12-29  Arjan Molenaar  <arjanmolenaar@hetnet.nl>
+
+        * gaphor/UML/Element.py: Reimplemented, now all sorts of relations
+          work properly.
+
-2001-10-26  Arjan Molenaar  <arjanmolenaar@hetnet.nl>
-

trunk/gaphor/configure.in

@@ -40 +40 @@
-    Makefile
-    utils/Makefile
-src
-src/model
-src/g
+gaphor
+gaphor/UML
+gaphor/
-    tests/Makefile
-    doc/Makefile)

trunk/gaphor/gaphor/UML/Element.py

@@ -1 +1 @@
-# vim: sw=4
-#
-# Base class for all UML model objects
-#
-
-import types, copy
-
-# Some default types as defined in the MetaModel.
-class Integer(int): pass
-class UnlimitedInteger(long): pass
-class Boolean(int): pass
-class String(str): pass
-class Name(String): pass
-class Expression(String): pass
-class LocationReference(String): pass
-# Don't know what to do with this one:
-Geometry = types.ListType
-
-FALSE = 0
-TRUE = not FALSE
-
-class Enumeration_:
-    '''The Enumerration class is an abstract class that can be used to create
-    enumerated types. One should inherit from Enumeration and define a variable
-    '_values' at class level, which holds a list of valid values for the class.
-    '''
-    def __init__(self):
-        self.v = self._values[0]
-    def __setattr__(self, key, value):
-        if key == 'v' and value in self._values:
-            self.__dict__['v'] = value
-        else:
-            raise AttributeError, "Value '" + str(value) + "' is an invalid enumeration type."
-
-class Sequence:
-    '''A Sequence class has the following properties:
-    - A sequence is an unordered list of unique elements.
-    - Only accepts object of a certain type (or descendants).
-    - Only keep one reference to the object.
-    - A Sequence might have an owner. In that care the owners
-      sequence_{add|remove}() functions are called to allow
-      bi-directional relations to be added and deleted.'''
-    def __init__(self, owner, type):
-        self.owner = owner
-        self.requested_type = type
-        self.list = []
-
-    def __len__(self):
-        return self.list.__len__()
-
-    def __setitem__(self, key, value):
-        raise Exception, "Sequence: items should not be overwritten."
-
-    def __delitem__(self, key):
-        if self.owner:
-            self.owner.sequence_remove(self, obj)
-        else:
-            self.list.__delitem__(key)
-
-    def __getitem__(self, key):
-        return self.list.__getitem__(key)
-
-    def __getslice__(self, i, j):
-        return self.list.__getslice__(i, j)
-
-    def __setslice__(self, i, j, s):
-        raise Exception, "Sequence: items should not be overwritten."
-
-    def __delslice__(self, i, j):
-        raise Exception, "Sequence: items should not be deleted this way."
-
-    def __contains__(self, obj):
-        return self.list.__contains__(obj)
-
-    def append(self, obj):
-        if isinstance (obj, self.requested_type):
-            if self.list.count(obj) == 0:
-                self.list.append(obj)
-        else:
-            raise ValueError, "Sequence._add(obj): Object is not of type " + \
-                                str(self.requested_type)
-
-    def remove(self, key):
-        self.__delitem__(key)
-
-    def index(self, key):
-        return self.list.index(key)
-    
-
-if __name__ == '__main__':
-    print "\n============== Starting Sequence tests... ============\n"
-
-# End of Sequence tests
-
-#
-# Base class for all UML model objects
@@ -109 +16 @@
-#
-
+
+import types, copy
+
+# Some default types as defined in the MetaModel.
+class Integer(int): pass
+class UnlimitedInteger(long): pass
+class Boolean(int): pass
+class String(str): pass
+class Name(String): pass
+class Expression(String): pass
+class LocationReference(String): pass
+# Don't know what to do with this one:
+Geometry = types.ListType
+
+FALSE = 0
+TRUE = not FALSE
+
+class Enumeration_:
+    '''The Enumerration class is an abstract class that can be used to create
+    enumerated types. One should inherit from Enumeration and define a variable
+    '_values' at class level, which holds a list of valid values for the class.
+    '''
+    def __init__(self):
+        self.v = self._values[0]
+    def __setattr__(self, key, value):
+        if key == 'v' and value in self._values:
+            self.__dict__['v'] = value
+        else:
+            raise AttributeError, "Value '" + str(value) + "' is an invalid enumeration type."
+
+class Sequence:
+    '''A Sequence class has the following properties:
+    - A sequence is an unordered list of unique elements.
+    - Only accepts object of a certain type (or descendants).
+    - Only keep one reference to the object.
+    - A Sequence might have an owner. In that care the owners
+      sequence_{add|remove}() functions are called to allow
+      bi-directional relations to be added and deleted.'''
+    def __init__(self, owner, type):
+        self.owner = owner
+        self.requested_type = type
+        self.list = []
+
+    def __len__(self):
+        return self.list.__len__()
+
+    def __setitem__(self, key, value):
+        raise Exception, "Sequence: items should not be overwritten."
+
+    def __delitem__(self, key):
+        if self.owner:
+            self.owner.sequence_remove(self, key)
+        else:
+            self.list.__delitem__(key)
+
+    def __getitem__(self, key):
+        return self.list.__getitem__(key)
+
+    def __getslice__(self, i, j):
+        return self.list.__getslice__(i, j)
+
+    def __setslice__(self, i, j, s):
+        raise IndexError, "Sequence: items should not be overwritten."
+
+    def __delslice__(self, i, j):
+        raise IndexError, "Sequence: items should not be deleted this way."
+
+    def __contains__(self, obj):
+        return self.list.__contains__(obj)
+
+    def append(self, obj):
+        if isinstance (obj, self.requested_type):
+            if self.list.count(obj) == 0:
+                #print "seq.list:", self.list
+                self.list.append(obj)
+                #print "seq.list:", self.list
+            #else:
+                #print "Sequence.append: Item already in sequence (" + str(obj) + ")"
+        else:
+            raise ValueError, "Sequence._add(obj): Object is not of type " + \
+                                str(self.requested_type)
+
+    def remove(self, key):
+        self.__delitem__(key)
+
+    def index(self, key):
+        return self.list.index(key)
+    
+
-class Element:
-    '''Element is the base class for *all* UML MetaModel classes. The
@@ -141 +137 @@
-            return rec
-
+    def __ensure_seq(self, key, type):
+        if not self.__dict__.has_key(key):
+            self.__dict__[key] = Sequence(self, type)
+        return self.__dict__[key]
+
+    def __del_seq_item(self, seq, val):
+        try:
+            index = seq.list.index(val)
+            del seq.list[index]
+        except ValueError:
+            pass
+
-    def __getattr__(self, key):
-        if key == "id":
@@ -151 +159 @@
-            if rec[0] is Sequence:
-                # We do not have a sequence here... create it and return it.
-
-
+
-            else:
-                # Otherwise, return the default value
@@ -163 +170 @@
-        2. In case of a bi-directional relationship:
-           a. First remove a possible already existing relationship (not that
-
+m
-           b. Set up a new relationship between self-value and value-self.'''
-
-        rec = self.__get_attr_info (key, self.__class__)
+        #print "__setattr__", rec
-        if len(rec) == 2: # Attribute or one-way relation
-
+
+
+
+
-        else:
-            xrec = value.__get_attr_info (rec[2], value.__class__)
-
+
+
+
+
+
-                xself = self.__dict__[key]
-                # Keep the relationship if we have a n:m relationship
-                if rec[0] is not Sequence or xrec[0] is not Sequence:
-                    if rec[0] is Sequence:
-
-
-
+
+
+
+
+
-                    if xrec[0] is Sequence:
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    def sequence_remove(self, seq, obj):
-        '''Remove an entry. Should only be called by Sequence's implementation.
-        This function is used to trap the 'del' function.'''
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-        rec = self.__get_attr_info (key, self.__class__)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-if __name__ == '__main__':
-
-    print "\n============== Starting Element tests... ============\n"
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    class A(Element): _attrdef = { }
@@ -250 +307 @@
-    assert a.seq.list == [ noot ]
-
-
+
+
+
-
-    class A(Element): _attrdef = { }
@@ -263 +322 @@
-
-    a.ref1 = a
+    #print a.ref1
+    #print a.ref2
-    assert a.ref1 is a
-    assert a.ref2 is a
@@ -268 +329 @@
-    del a.ref1
-    assert a.ref1 is None
-
-####
+#
+
-
-    a = A(1)
@@ -284 +345 @@
-    assert a.ref2 is a
-    assert b.ref1 is None
-
-
-
+
+
+
+
+
-
-    class A(Element): _attrdef = { }
@@ -331 +394 @@
-    assert b.seq.list == [ a, b ]
-
+    b.ref = b
+    assert a.ref is b
+    assert a.seq.list == [ ]
+    assert b.ref is b
+    assert b.seq.list == [ a, b ]
+
-    del b.seq[a]
-    assert a.ref is None
@@ -337 +406 @@
-    assert b.seq.list == [ b ]
-
+    del b.ref
+    assert a.ref is None
+    assert a.seq.list == [ ]
+    assert b.ref is None
+    assert b.seq.list == [ ]
+
+    print "\tOK ==="
+
+    print "=== n:m:",
+
+    class A(Element): _attrdef = { }
+
+    A._attrdef['seq1'] = ( Sequence, A, 'seq2' )
+    A._attrdef['seq2'] = ( Sequence, A, 'seq1' )
+
+    a = A(1)
+    assert a.seq1.list == [ ]
+    assert a.seq2.list == [ ]
+
+    b = A(2)
+    assert b.seq1.list == [ ]
+    assert b.seq2.list == [ ]
+
+    a.seq1 = a
+    assert a.seq1.list == [ a ]
+    assert a.seq2.list == [ a ]
+    assert b.seq1.list == [ ]
+    assert b.seq2.list == [ ]
+
+    a.seq2 = a
+    assert a.seq1.list == [ a ]
+    assert a.seq2.list == [ a ]
+    assert b.seq1.list == [ ]
+    assert b.seq2.list == [ ]
+
+    a.seq1 = b
+    assert a.seq1.list == [ a, b ]
+    assert a.seq2.list == [ a ]
+    assert b.seq1.list == [ ]
+    assert b.seq2.list == [ a ]
+
+    del a.seq1[a]
+    assert a.seq1.list == [ b ]
+    assert a.seq2.list == [ ]
+    assert b.seq1.list == [ ]
+    assert b.seq2.list == [ a ]
+
+    b.seq1 = a
+    assert a.seq1.list == [ b ]
+    assert a.seq2.list == [ b ]
+    assert b.seq1.list == [ a ]
+    assert b.seq2.list == [ a ]
+
+    try:
+        del a.seq1
+    except AttributeError:
+        pass
+    except Exception:
+        assert 0
+    assert a.seq1.list == [ b ]
+    assert a.seq2.list == [ b ]
+    assert b.seq1.list == [ a ]
+    assert b.seq2.list == [ a ]
+
+    print "\tOK ==="
+
+    print "\n============== All Element tests passed... ============\n"