abstract class $BAG{ETP} < $RO_BAG{ETP}, $VAR
****
An unordered container in which the elements are not unique.
_
This is a reference abstraction and supports operations that modify self. Instances of subtypes may be viewed as variables with a value of $VBAG{ETP}
_
For pointers to other documentation please see the class comment in the read-only abstraction $RO_BAG
_


Ancestors
$VAR $RO_BAG{_} $CONTAINER{_} $STR
$ELT{_} $ELT

Descendants
BAG{_}



Public


Features
add(e:ETP);
**** Add the element 'e' to self self <- initial(self).add(e)
add(e:ETP):$BAG{ETP};
**** Result is a new bag containing all the elements of self and 'e'
as_array:ARRAY{ETP};
**** Return the elements of the container in an array
as_value:$VBAG{ETP};
**** Return the current value associated with self
clear;
**** Delete all elements of self. post result.size = 0
concat(arg:$ELT{ETP}): $RO_BAG{ETP};
**** Returns a bag 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=bag of all e s.t. result.count(e)=self.count(e)+arg.count(e) > 0
copy: SAME;
**** Return a copy of the current container
count(e:ETP):INT;
**** Return the number of occurences of 'e' in self
delete(e:ETP);
**** Delete at most one occurance of 'e' from self self <- initial(self).delete(e)
delete(e:ETP):$BAG{ETP};
**** Result is a new bag containing all the elements of self except for an element equal to 'e', if one exists. If more than one element is equal to 'e', delete only one of them
delete_all(e:ETP);
**** Delete all occurences of 'e' from self self <- initial(self).delete(e)
delete_all(e:ETP):$BAG{ETP};
**** Result is a new bag containing all the elements of self except for any elements equal to 'e'
elt!:ETP;
**** Yield all the elements of self. The order is not defined.
equals(c:$RO_BAG{ETP}):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: ETP): BOOL;
**** True if the container contains the element "e"
intersection(arg: $RO_BAG{ETP}):$RO_BAG{ETP};
**** Returns a bag 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=bag of all e s.t.
__________result.count(e)=min(self.count(e),arg.count(e))_>_0
is_empty:BOOL;
**** Returns true if the size of the container = 0
is_subset_of(arg: $RO_BAG{ETP}): BOOL;
**** Returns true if 'self' is a subset of 'arg'. For elements that occur multiple times, the number of occurences of the element in 'arg' must be greater than or equal to the number of occurences in self
_
result=true iff for all e in self: count(e) <= arg.count(e)
n_unique: INT;
**** Returns the number of unique elements in the bag
_
result = number of unique elements
size: INT;
**** Number of elements contained
str:STR;
**** Yield a string version of self
to_concat(arg:$RO_BAG{ETP});
**** Concatenate the elemetns of 'arg' to this bag self <- initial(self).add_bag(arg)
to_intersection(arg:$RO_BAG{ETP});
**** Turn this bag into the intersection of self and 'arg' self <- initial(self).intersection(arg)
to_union(arg: $RO_BAG{ETP});
**** Turn this bag into the union of self and 'arg' self <- initial(self).union(arg)
union(arg: $RO_BAG{ETP}): $RO_BAG{ETP};
**** Returns a bag 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' This definition permits the union of sets to be consistent with the union of bags.
_
result=bag of all e s.t.
_________result.count(e)=max(self.count(e),arg.count(e))_>_0
unique!:ETP;
**** Yield the unique elements of self. Equivalent to self.as_set.elt!

The Sather Home Page