abstract class $RO_MAP{ITP,TTP} < $RO_MULTIMAP{ITP,TTP} |
---|
**** | An unordered container of tuples of {index:ITP,target:TTP} such that the indices of all tuples are unique. Indices may be used to retrieve targets
_ Definition: A map is a multimap with the additional constraint that the indices of the tuples are unique _ This is a read-only abstraction in which no modifying operations are available. However, subtypes may provide modifying operations For documentation see: ____The_overall_organization_of_container_classes ____The_organization_and_usage_of_maps_and_related_classes |
$RO_MULTIMAP{_,_} | $RO_BAG{_} | $CONTAINER{_} | $STR | $ELT{_} | $ELT |
$MAP{_,_} | MAP{_,_} | $VMAP{_,_} | VMAP{_,_} |
add(k:ITP,e:TTP):$RO_MULTIMAP{ITP,TTP}; |
---|
**** | Shortcut for for add(#TUP{ITP,TTP}(k,e)) |
add(e:TUP{ITP,TTP}):$VMULTIMAP{ITP,TTP}; |
---|
**** | Result is a new multimap containing all the elements of self and 'e' |
aget(k:ITP):TTP; |
---|
**** | Returns the element k is mapped to. Note that this usage is different from the usage in arrays.
_ result is e s.t. self has (k,e). If self has no (k,_) then __________if_E_<_$IS_NIL_return_E::nil_otherwise_return_void_ |
as_array:ARRAY{TUP{ITP,TTP}}; |
---|
**** | Return the elements of the container in an array |
concat(arg:$RO_BAG{TUP{ITP,TTP}}):$RO_MULTIMAP{ITP,TTP}; |
---|
**** | Returns a multimap containing all the elements of self and 'arg'. For elements that occur multiple times, the result contains the sum of the number of occurences in self and 'arg'
_ result=mmap of all e s.t. result.count(e)=self.count(e)+arg.count(e) |
copy: SAME; |
---|
**** | Return a copy of the current container |
count(e:TUP{ITP,TTP}):INT; |
---|
**** | Return the number of occurences of 'e' in self |
delete(k:ITP,e:TTP):$RO_MAP{ITP,TTP}; |
---|
**** | Shortcut for for delete(e:TUP{ITP,TTP}) |
delete(e:TUP{ITP,TTP}):$RO_MAP{ITP,TTP}; |
---|
**** | Result is a new map containing all the elements of self except for an element equal to 'e', if one exists. |
delete_all(e:TUP{ITP,TTP}):$RO_MAP{ITP,TTP}; |
---|
**** | Result is a new map containing all the elements of self except for an element equal to 'e', if one exists. |
delete_ind(k:ITP):$RO_MAP{ITP,TTP}; |
---|
**** | Returns a new map in which any occurences of the tuple (k,_) has been deleted |
diff(arg:$RO_MAP{ITP,TTP}):$RO_MAP{ITP,TTP}; |
---|
**** | Returns a map containing the elements common to self and 'arg'
_ result=map of all e s.t. self.has(e) and ~arg.has(e) |
elt!:TUP{ITP,TTP}; |
---|
**** | Yield all the elements of self. The order is not defined. |
equals(c:$RO_BAG{TUP{ITP,TTP}}):BOOL; |
---|
**** | Return true if both containers contain the same elements with the same number of repetitions, irrespective of the order of the elements |
has(e: TUP{ITP,TTP}): BOOL; |
---|
**** | True if the container contains the element "e" |
has_ind(k:ITP): BOOL; |
---|
**** | Returns true if this map has an index equal to 'k'
_ result is true iff self contains a tuple (k,_) |
ind!:ITP; |
---|
**** | Yields all the indices of self i.e. first elements of every tuple in self, in an unspecified order
_ yield all i s.t. self.has((i,_)) |
insert(k:ITP,e:TTP):$RO_MAP{ITP,TTP}; |
---|
**** | Shortcut for for add(#TUP{ITP,TTP}(k,e)) |
insert(e:TUP{ITP,TTP}):$RO_MAP{ITP,TTP}; |
---|
**** | Insert the element 'e' in the bag. If a tuple (e.t1,_) exists, the replace it with (e.t1,e.t2) |
intersection(arg: $RO_BAG{TUP{ITP,TTP}}):$RO_MULTIMAP{ITP,TTP}; |
---|
**** | Returns a multimap containing the elements common to self and 'arg' For elements that occur multiple times, the result contains the minimum number of occurrences in either self or 'arg'.
_ result=mmap of all e s.t. result.count(e)=min(self.count(e),arg.count(e)) |
intersection(arg: $RO_MAP{ITP,TTP}):$RO_MAP{ITP,TTP}; |
---|
**** | Returns a map containing the elements common to self and 'arg'
_ result=map of all e s.t. self.has(e) and arg.has(e) Overloads method in $RO_MULTIMAP with more specific argument |
is_empty:BOOL; |
---|
**** | Returns true if the size of the container = 0 |
is_subset_of(arg: $RO_BAG{TUP{ITP,TTP}}): BOOL; |
---|
**** | Returns true if 'self' is a subset of 'arg'. |
n_targets(k:ITP): INT; |
---|
**** | Returns the number of targets associated with the index 'k' i.e. 0 or 1 |
n_unique: INT; |
---|
**** | Returns the number of unique elements in the bag |
pair!: TUP{ITP,TTP}; |
---|
**** | Yields all elements of self in an unspecified order. An alias for "elt!" |
size: INT; |
---|
**** | Number of elements contained |
str:STR; |
---|
**** | Yield a string version of self |
sym_diff(arg:$RO_MAP{ITP,TTP}):$RO_MAP{ITP,TTP}; |
---|
**** | Returns a map containing the elements not common to self and 'arg'
_ result=map of all e s.t. self.has(e) xor arg.has(e) |
target!:TTP; |
---|
**** | Yields all the targets in this mapping in an unspecified order
_ yield all t s.t. self has (_,t) |
target!(once k:ITP):TTP; |
---|
**** | Yields all the target associated with index 'k'
_ yield all t s.t. self.has((k,t)) |
union(arg: $RO_BAG{TUP{ITP,TTP}}): $RO_MULTIMAP{ITP,TTP}; |
---|
**** | Returns a multimap containing the union of elements of 'self' and 'arg'. For elements that occur multiple times, the result contains the maximum number of occurences in either self or 'arg'
_ result=mmap of all e s.t. result.count(e)=max(self.count(e),arg.count(e)) |
union(arg: $RO_MAP{ITP,TTP}): $RO_MAP{ITP,TTP}; |
---|
**** | Returns a map containing the elements of 'self' and 'arg'.
_ result=map of all e s.t. self.has(e) or arg.has(e) Overloads method in $RO_MULTIMAP with more specific argument |
unique!:TUP{ITP,TTP}; |
---|
**** | Yield the unique elements of self. Equivalent to self.as_set.elt! |