gnue/geas/doc odmg.txt

[Daniel E. Baumann]

CVSROOT:        /cvsroot/gnue
Module name:    gnue
Changes by:     Daniel E. Baumann <address@hidden>      02/02/17 14:55:31

Modified files:
        geas/doc       : odmg.txt 

Log message:
        Add List, Array, and Dictionary collection class definitions and notes. 
Fix
        various misspellings and typos.

CVSWeb URLs:
http://savannah.gnu.org/cgi-bin/viewcvs/gnue/gnue/geas/doc/odmg.txt.diff?tr1=1.6&tr2=1.7&r1=text&r2=text

Patches:
Index: gnue/geas/doc/odmg.txt
diff -c gnue/geas/doc/odmg.txt:1.6 gnue/geas/doc/odmg.txt:1.7
*** gnue/geas/doc/odmg.txt:1.6  Tue Feb 12 08:02:36 2002
--- gnue/geas/doc/odmg.txt      Sun Feb 17 14:55:31 2002
***************
*** 139,145 ****
      // the extends denotes the EXTENDS relationship
        class EmployeePerson extends Person: Employee
        {
!         attribute Date hireDAte;
          attribute Currency payRate;
          relationship Manager boss inverse manager::subordinates;
        };
--- 139,145 ----
      // the extends denotes the EXTENDS relationship
        class EmployeePerson extends Person: Employee
        {
!         attribute Date hireDate;
          attribute Currency payRate;
          relationship Manager boss inverse manager::subordinates;
        };
***************
*** 199,205 ****
      {
        exception DatabaseClosed{};
        exception TransactionInProgress{};
!       exception TransactionsNotInProgress{};
        exception IntegrityError{};
        exception LockNotGranted{};
    
--- 199,205 ----
      {
        exception DatabaseClosed{};
        exception TransactionInProgress{};
!       exception TransactionNotInProgress{};
        exception IntegrityError{};
        exception LockNotGranted{};
    
***************
*** 252,258 ****
  
      - default ODMG locking policy is implicit, all ODMG object support
        explicit locking operations
!     - IntergrityError exception is raised by operations on
        relationships and signifies that referential integrity has
        been violated
      -  access, creation, modification, and deletion of persistent
--- 252,258 ----
  
      - default ODMG locking policy is implicit, all ODMG object support
        explicit locking operations
!     - IntegrityError exception is raised by operations on
        relationships and signifies that referential integrity has
        been violated
      -  access, creation, modification, and deletion of persistent
***************
*** 262,268 ****
      - it is assumed that all operations defined on persistent objects
        have the ability to raise the TransactionNotInProgress exception
  
!     Object Indentifiers
      ===================
      - all objects have identifiers, and object can always be
      distinguished form all other objects within its *storage domain*
--- 262,268 ----
      - it is assumed that all operations defined on persistent objects
        have the ability to raise the TransactionNotInProgress exception
  
!     Object Identifiers
      ===================
      - all objects have identifiers, and object can always be
      distinguished form all other objects within its *storage domain*
***************
*** 274,280 ****
      - value of an object's identifier will never change
      - object remains the same object even if its attribute values or
      relationships change
!     - an oid is commonly used as a means for one object to reference
      another
      - literals do not have their own identifiers and cannot stand
      alone as objects; they are embedded in objects can cannot be
--- 274,280 ----
      - value of an object's identifier will never change
      - object remains the same object even if its attribute values or
      relationships change
!     - an OID is commonly used as a means for one object to reference
      another
      - literals do not have their own identifiers and cannot stand
      alone as objects; they are embedded in objects can cannot be
***************
*** 293,300 ****
      - an object may be given one or two names that are meaningful to
      the programmer or end user
      - ODMS provides a function to map an object name to an object
!     - application can refer at its convience to an object by name;
!     ODMS applies the mapping function to determine the oid that
      locates the desired object
      - ODMS expects names to be commonly used by applications to refer
      to "root" objects, which provide entry points into the ODMS
--- 293,300 ----
      - an object may be given one or two names that are meaningful to
      the programmer or end user
      - ODMS provides a function to map an object name to an object
!     - application can refer at its convenience to an object by name;
!     ODMS applies the mapping function to determine the OID that
      locates the desired object
      - ODMS expects names to be commonly used by applications to refer
      to "root" objects, which provide entry points into the ODMS
***************
*** 450,456 ****
          Set      new_of_size(in long size);
        };
  
!       interface Set: Collection
        {
          attribute set<t> value;
  
--- 450,456 ----
          Set      new_of_size(in long size);
        };
  
!       class Set: Collection
        {
          attribute set<t> value;
  
***************
*** 479,484 ****
--- 479,488 ----
  
        interface BagFactory: ObjectFactory
        {
+         Bag           new_of_size(in long size);
+ 
+       class Bag: Collection
+       {
          attribute     bag<t> value;
  
          // Calculates the number of times a specific element occurs in
***************
*** 498,501 ****
        argument , if the element is already a member of the bag, it is
        inserted another time increasing the multiplicity in the
        bag. 'remove_element' operation removes one occurrence of the
!       specified element from the bag.
\ No newline at end of file
--- 502,669 ----
        argument , if the element is already a member of the bag, it is
        inserted another time increasing the multiplicity in the
        bag. 'remove_element' operation removes one occurrence of the
!       specified element from the bag.
! 
!     List Objects
!     ============
!     - List object is ordered collection of elements
!     - the operations defined in the List interface are positional in
!     nature
!     - indexing of a List object starts at 0
! 
!     interface ListFactory: ObjectFactory
!     {
!       List       new_of_size(in long size);
!     };
! 
!     class List: Collection
!     {
!       exception  InvalidIndex{unsigned long index; };
! 
!       attribute  list<t> value;
!  
!       void       remove_element_at(in unsigned long index)
!                                    raises(InvalidIndex);
!     
!       Object     retrieve_element_at(in unsigned long index)
!                                      raises(InvalidIndex);
!  
!       void       replace_element_at(in Object element, in unsigned long index)
!                                     raises(InvalidIndex);
! 
!       void       insert_element_after(in Object element, 
!                                       in unsigned long index)
!                                       raises(InvalidIndex);
! 
!       void        insert_element_before(in Object element, 
!                                        in unsigned long index)
!                                        raises(InvalidIndex);
! 
!       void        insert_element_first(in Object element);
! 
!       void        insert_element_last(in Object element);
!   
!       void        remove_first_element() raises(ElementNotFound);
! 
!       void        remove_last_element() raises(ElementNotFound);
! 
!       Object      retrieve_first_element() raises(ElementNotFound);
! 
!       Object      retrieve_last_element() raises(ElementNotFound);
! 
!       // Returns a new List object that contains other_list appended to
!       // the this list, both this and other_list remain unchanged
!       List        concat(in List other_list);
! 
!       // Modifies this list by appending other_list
!       void        append(in List other_list);
!     }; 
! 
!     - List refines semantics of 'insert_element' and 'remove_element'
!       operation inherited from Collection supertype. 'insert_element'
!       operation inserts the specified object at the end of the list,
!       semantics of this operation are equivalent to
!       'insert_element_last', 'remove_element' operation removes the
!       first occurrence of the specified object form the list
! 
!     Array Objects
!     =============
!     - Array object is a dynamically sized, ordered collection of
!     elements that can be located by position
! 
!       interface ArrayFactory: ObjectFactory
!       {
!         Array     new_of_size(in long size);
!       };
! 
!       class Array: Collection
!       {
!         exception InvalidIndex{unsigned long index; };
! 
!         exception InvalidSize{unsigned long size; };
!        
!         attribute array<t> value;
! 
!         void      replace_element_at(in unsigned long index, 
!                                      in Object element)
!                                      raises(InvalidIndex);
!    
!         // Replaces any current element contained in the cell of the
!         // Array object identified by index with an undefined value,
!         // it does not remove the cell or change the size of the array
!         void      remove_element_at(in unsigned long index)
!                                     raises(InvalidIndex);
! 
!         Object    retrieve_element_at(in unsigned long index)
!                                       raises(InvalidIndex);
! 
!         // Enables an Array object to change the maximum number of
!         // elements it can contain. The exception InvalidSize is
!         // raised, if the value of the new_size parameter is smaller
!         // than the actual number of elements currently contained in the array
!         void      resize(in unsigned long new_size)
!                          raises(InvalidSize);
!       };
! 
!     - Array refines semantics of 'insert_element' and 'remove_element'
!       operation inherited from Collection supertype. 'insert_element'
!       increases the size of the array by one and inserts the
!       specified object in the new position, 'remove_element' replaces
!       the first occurrence of the specified object in the array with an
!       undefined value
! 
!     Dictionary Objects
!     ==================
!     - Dictionary object is an unordered sequence of key-value
!     pairs with no duplicate keys
!     - Each key-value pair is constructed as an instance of the
!     following structure:
!       struct Association {Object key; Object value; };
! 
!     - iterating over a Dictionary object will result in the iteration
!       over a sequence of Associations, each 'get_element' operation
!       executed on an 'Iterator' object returns a struct of type
!       Association
!     
!       interface DictionaryFactory: ObjectFactory
!       { 
!         Dictionary new_of_size(in long size);
!       };
! 
!       class Dictionary: Collection
!       {
!         exception  DuplicateName{string key; };
! 
!         exception  KeyNotFound{Object key; };
! 
!         attribute  dictionary<t,v> value;
! 
!         // These methods handle inserting, deleting, and selecting
!         // entries in a Dictionary object, respectively.
!         void       bind(in Object key, in Object value)
!                         raises(DuplicateName);
!         void       unbind(in Object key) raises(KeyNotFound);
!         Object     lookup(in Object key) raises(KeyNotFound);
! 
!         // Tests for the existence of a specific key in the Dictionary object
!         boolean    contains_key(in Object key);
!       
!       };
! 
!     - Dictionary refines semantics of 'insert_element',
!       'remove_element', and 'contains_element' operations inherited
!       from its Collection supertype. All of these operations are valid
!       for Dictionary types when an Association is specified as the
!       argument. 'insert_element' inserts an entry into the Dictionary
!       that reflects the key-value pair contained in the Association
!       parameter. If the key already resides in the Dictionary, the
!       existing entry is replaced. 'remove_element' removes the entry
!       from the Dictionary that matches the key-value pair contained in
!       the Association passed as the argument. If a matching key-value
!       pair entry is not found in the Dictionary, the ElementNotFound
!       exception is raised. 'contain_element' operation also uses both
!       the key and the value contained in the Association argument to
!       locate a particular entry in the Dictionary object. A boolean is
!       returned specifying whether the key-value pair exists in the
!       Dictionary.
!       
\ No newline at end of file