Section Header
  
  
    + name := SET[E];
  
  
    - comment := "Definition of a mathematical set of objects.";
  
 All common operations on mathematical sets are available.
  
 Well knowned implementations are HASHED_SET and AVL_SET.
  
Section Inherit
  
  
    + parent_traversable:TRAVERSABLE[E] := 
  
  
    + parent_safe_equal:SAFE_EQUAL[E] := 
  
Section Public
  
  
 Counting:
  
  
  
    - count:INTEGER <-
  
         Cardinality of the set (i.e. actual `count' of stored elements).
  	
  
    - is_empty:BOOLEAN <- 
  
         Is the set empty?
  
  
  
 Adding and removing:
  
  
  
    - add e:E <-
  
         Add new item `e' to the set. The mathematical definition of adding 
  
         in a set is followed, i.e. the element `e' is added only and only 
  
         if it is not yet present in the set.
  
         As this `add' feature is actually using `is_equal', you may consider 
  
         to use `fast_add' for expanded objects as well while trying to get 
  
         the very best performances.
  
  
    - fast_add e:E <-
  
         Same job as `add', but uses basic `=' for comparison.
  
  
    - remove e:E <-
  
         Remove item `e' from the set: the mathematical definition of
  
         removing from a set is followed.
  
  
    - fast_remove e:E <-
  
         Same job as `remove', but uses basic `=' for comparison.
    
  
    - clear <- 
  
  
    - clear_count <-
  
         Empty the current set (`is_empty' is True after that call). 
  
         If possible, the actual implementation is supposed to keep 
  
         its internal storage area in order to refill `Current' in 
  
         an efficient way.
  
        
  
         See also `clear_count_and_capacity' to select the most appropriate.
  
  
    - clear_count_and_capacity <-
  
         Empty the current set (`is_empty' is True after that call). 
  
         If possible, the actual implementation is supposed to release 
  
         its internal storage area for this memory to be used by other objects.
  
        
  
         See also `clear_count' to select the most appropriate.
    
  
  
 Looking and searching:
  
  
  
    - has e:E :BOOLEAN <-
  
         Is element `e' in the set?
  
         As this query is actually using `is_equal', you may consider to use 
  
         `fast_has' for expanded objects as well while trying to get the very 
  
         best performances.
    
  
    - fast_has e:E :BOOLEAN <-
  
         Is element `e' actually stored in the set?
  
         Warning: this query is using basic `=' for comparison. 
  
        
  
         See also `has' when dealing with reference types.
  
  
    - reference_at e:E :E <-
  
         Non Void when `e' is in the set. In such a situation, `Result' is the 
  
         object which is actually stored in the `Current' set (see ensure assertion).
    
  
  
 To provide iterating facilities:
  
  
  
    - lower:INTEGER := 
  
    - upper:INTEGER <-
  
  
    - item i:INTEGER :E <-
  
         Item at the corresponding index `i'.
  
        
  
         See also `lower', `upper', `valid_index'.
  
        
  
         SETs are intrinsically unordered, so there is no guarantee that 
  
         `item'(i) after performing an `add' or `remove' operation is related 
  
         in any way to `item'(i) before that operation.
  
  
    - first:E <- 
  
         The very `first' item.
  
        
  
         See also `last', `item'.
  
        
  
         SETs are intrinsically unordered, so there is no guarantee that 
  
         `first' after performing an `add' or `remove' operation is related 
  
         in any way to `first' before that operation.
  
    - last:E <- 
  
         The `last' item.
  
        
  
         See also `first', `item'.
  
        
  
         SETs are intrinsically unordered, so there is no guarantee that 
  
         `last' after performing an `add' or `remove' operation is related 
  
         in any way to `last' before that operation.
  
  
  
 Mathematical operations:
  
  
  
    - union other:SELF <-
  
         Make the union of the `Current' set with `other'.
  	
  
    - '+' other:SELF :SELF <-
  
         Return the union of the `Current' set with `other'.
  
  
    - intersection other:SELF <-
  
         Make the intersection of the `Current' set with `other'.
    
  
    - '^' other:SELF :SELF <-
  
         Return the intersection of the `Current' set with `other'.
  
  
    - minus other:SELF <-
  
         Make the set `Current' - `other'.
  
  
    - '-' other:SELF :SELF <-
  
         Return  the set `Current' - `other'.
  
  
  
 Comparison:
  
  
  
    - is_subset_of other:SELF :BOOLEAN <-
  
         Is the `Current' set a subset of `other'?
  
  
    - is_disjoint_from other:SELF :BOOLEAN <-
  
         Is the `Current' set disjoint from `other' ?
    
  
    - '==' other:SELF :BOOLEAN <-
  
         Is the `Current' set equal to `other'?
  
  
  
 Duplication.
  
  
  
    - copy other:SELF <-
  
         Copy 'other' into the current set
  
  
    - from_collection model:COLLECTION[E] <-
  
         Add all items of `model'.
  
  
  
 Agents based features:
  
  
  
    - do_all action:BLOCK <-
  
         Apply `action' to every item of `Self'.
  
        
  
         See also `for_all', `exists'.
  
  
    - for_all predicate:BLOCK :BOOLEAN <-
  
         Do all items satisfy `predicate'?
  
        
  
         See also `do_all', `exists'.
  
  
    - exists predicate:BLOCK :BOOLEAN <-
  
         Does at least one item satisfy `predicate'?
  
        
  
         See also `do_all', `for_all'.
  
  
  
 Creation.
  
  
  
    - create:SELF <- 
    
  
    - make <-
  
         Creation of an empty SET.