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


Ancestors
$RO_MULTIMAP{_,_} $RO_BAG{_} $CONTAINER{_} $STR
$ELT{_} $ELT

Descendants
$VMAP{_,_} VMAP{_,_} $MAP{_,_} MAP{_,_}



Public


Features
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!

The Sather Home Page