abstract class $VMAP{ITP,TTP} < $RO_MAP{ITP,TTP},$VMULTIMAP{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
_ IMPORTANT: This is a value abstraction and is stricter than the read-only abstraction. Subtypes must not support *any* operations that modify self. The language cannot enforce this restriction. _ For pointers to other documentation please see the class comment in the read-only abstraction |
$VMULTIMAP{_,_} | $VBAG{_} | $HASH | $IS_EQ | $RO_BAG{_} | $CONTAINER{_} | $STR | $ELT{_} | $ELT | $RO_MULTIMAP{_,_} | $RO_MAP{_,_} |
VMAP{_,_} |
add(k:ITP,e:TTP):$VMULTIMAP{ITP,TTP}; |
---|
**** | Shortcut for for add(#TUP{ITP,TTP}(k,e)) |
add(e:TUP{ITP,TTP}):$VMULTIMAP{ITP,TTP}; |
---|
**** | Result is a new multimmap 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 _____the_result_is_undefined |
as_array:ARRAY{TUP{ITP,TTP}}; |
---|
**** | Return the elements of the container in an array |
concat(arg:$ELT{TUP{ITP,TTP}}):$VMULTIMAP{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):$VMAP{ITP,TTP}; |
---|
**** | Shortcut for for delete(e:TUP{ITP,TTP}) |
delete(e:TUP{ITP,TTP}):$VMAP{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}):$VMAP{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):$VMAP{ITP,TTP}; |
---|
**** | Returns a new map in which any occurences of the tuple (k,_) has been deleted |
diff(arg:$RO_MAP{ITP,TTP}):$VMAP{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):$VMAP{ITP,TTP}; |
---|
**** | Shortcut for for add(#TUP{ITP,TTP}(k,e)) |
insert(e:TUP{ITP,TTP}):$VMAP{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}}):$VMULTIMAP{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'. Redefined to strengthen the return type.
_ result=mmap of all e s.t. result.count(e)=min(self.count(e),arg.count(e)) Redefined from $RO_MAP to change the return type from $RO_MULTIMAP |
intersection(arg: $RO_MAP{ITP,TTP}):$VMAP{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) |
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'.
_ result=true iff for all e in self: count(e) <= arg.count(e) |
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}):$VMAP{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}}): $VMULTIMAP{ITP,TTP}; |
---|
**** | Returns a multimap containing the 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}): $VMAP{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) |
unique!:TUP{ITP,TTP}; |
---|
**** | Yield the unique elements of self. Equivalent to self.as_set.elt! |