Uses of Class
org.omg.CosCollection.ElementInvalid

Packages that use ElementInvalid
org.omg.CosCollection   
 

Uses of ElementInvalid in org.omg.CosCollection
 

Fields in org.omg.CosCollection declared as ElementInvalid
 ElementInvalid ElementInvalidHolder.value
           
 

Methods in org.omg.CosCollection that return ElementInvalid
static ElementInvalid ElementInvalidHelper.extract(Any any)
           
static ElementInvalid ElementInvalidHelper.read(InputStream in)
           
 

Methods in org.omg.CosCollection with parameters of type ElementInvalid
static void ElementInvalidHelper.insert(Any any, ElementInvalid s)
           
static void ElementInvalidHelper.write(OutputStream out, ElementInvalid s)
           
 

Methods in org.omg.CosCollection that throw ElementInvalid
 boolean SortedBagPOATie.locate_next_element(Any element, Iterator where)
           
 boolean SortedBagPOATie.contains_element(Any element)
           
 boolean SortedBagPOATie.locate_previous_element(Any element, Iterator where)
           
 boolean SortedBagPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean SortedBagPOATie.locate_or_add_element(Any element)
           
 int SortedBagPOATie.remove_all_occurrences(Any element)
           
 boolean SortedBagPOATie.remove_element(Any element)
           
 boolean SortedBagPOATie.locate_element(Any element, Iterator where)
           
 boolean SortedBagPOATie.add_element(Any element)
           
 void SortedBagPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SortedBagPOATie.locate_first_element(Any element, Iterator where)
           
 boolean SortedBagPOATie.contains_all_from(Collection collector)
           
 void SortedBagPOATie.add_all_from(Collection collector)
           
 int SortedBagPOATie.number_of_occurrences(Any element)
           
 boolean SortedBagPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean SortedBagPOATie.locate_last_element(Any element, Iterator where)
           
 boolean SortedSetPOATie.locate_next_element(Any element, Iterator where)
           
 boolean SortedSetPOATie.contains_element(Any element)
           
 boolean SortedSetPOATie.locate_previous_element(Any element, Iterator where)
           
 boolean SortedSetPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean SortedSetPOATie.locate_or_add_element(Any element)
           
 int SortedSetPOATie.remove_all_occurrences(Any element)
           
 boolean SortedSetPOATie.remove_element(Any element)
           
 boolean SortedSetPOATie.locate_element(Any element, Iterator where)
           
 boolean SortedSetPOATie.add_element(Any element)
           
 void SortedSetPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SortedSetPOATie.locate_first_element(Any element, Iterator where)
           
 boolean SortedSetPOATie.contains_all_from(Collection collector)
           
 void SortedSetPOATie.add_all_from(Collection collector)
           
 int SortedSetPOATie.number_of_occurrences(Any element)
           
 boolean SortedSetPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean SortedSetPOATie.locate_last_element(Any element, Iterator where)
           
 boolean SortedMapPOATie.locate_next_element(Any element, Iterator where)
           
 boolean SortedMapPOATie.contains_element(Any element)
           
 boolean SortedMapPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean SortedMapPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean SortedMapPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean SortedMapPOATie.locate_or_add_element(Any element)
           
 int SortedMapPOATie.remove_all_occurrences(Any element)
           
 boolean SortedMapPOATie.locate_or_add_element_with_key(Any element)
           
 boolean SortedMapPOATie.remove_element(Any element)
           
 boolean SortedMapPOATie.locate_element(Any element, Iterator where)
           
 boolean SortedMapPOATie.add_element(Any element)
           
 void SortedMapPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SortedMapPOATie.add_or_replace_element_with_key(Any element)
           
 boolean SortedMapPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void SortedMapPOATie.keys(Any[] elements, AnySequenceHolder keys)
           
 boolean SortedMapPOATie.contains_all_from(Collection collector)
           
 void SortedMapPOATie.add_all_from(Collection collector)
           
 int SortedMapPOATie.number_of_occurrences(Any element)
           
 boolean SortedMapPOATie.replace_element_with_key(Any element)
           
 boolean SortedMapPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void SortedMapPOATie.key(Any element, AnyHolder key)
           
 boolean KeySortedBagPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedBagPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedBagPOATie.locate_or_add_element_with_key(Any element)
           
 boolean KeySortedBagPOATie.add_element(Any element)
           
 void KeySortedBagPOATie.replace_element_at(Iterator where, Any element)
           
 boolean KeySortedBagPOATie.add_or_replace_element_with_key(Any element)
           
 boolean KeySortedBagPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void KeySortedBagPOATie.keys(Any[] elements, AnySequenceHolder keys)
           
 void KeySortedBagPOATie.add_all_from(Collection collector)
           
 boolean KeySortedBagPOATie.replace_element_with_key(Any element)
           
 boolean KeySortedBagPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void KeySortedBagPOATie.key(Any element, AnyHolder key)
           
 boolean KeySortedSetPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedSetPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedSetPOATie.locate_or_add_element_with_key(Any element)
           
 boolean KeySortedSetPOATie.add_element(Any element)
           
 void KeySortedSetPOATie.replace_element_at(Iterator where, Any element)
           
 boolean KeySortedSetPOATie.add_or_replace_element_with_key(Any element)
           
 boolean KeySortedSetPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void KeySortedSetPOATie.keys(Any[] elements, AnySequenceHolder keys)
           
 void KeySortedSetPOATie.add_all_from(Collection collector)
           
 boolean KeySortedSetPOATie.replace_element_with_key(Any element)
           
 boolean KeySortedSetPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void KeySortedSetPOATie.key(Any element, AnyHolder key)
           
 boolean BagPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean BagPOATie.locate_element(Any element, Iterator where)
           
 boolean BagPOATie.remove_element(Any element)
           
 boolean BagPOATie.contains_element(Any element)
           
 boolean BagPOATie.add_element(Any element)
           
 boolean BagPOATie.locate_next_element(Any element, Iterator where)
           
 boolean BagPOATie.contains_all_from(Collection collector)
           
 boolean BagPOATie.locate_or_add_element(Any element)
           
 int BagPOATie.number_of_occurrences(Any element)
           
 boolean BagPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void BagPOATie.add_all_from(Collection collector)
           
 void BagPOATie.replace_element_at(Iterator where, Any element)
           
 int BagPOATie.remove_all_occurrences(Any element)
           
 boolean SetPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean SetPOATie.locate_element(Any element, Iterator where)
           
 boolean SetPOATie.remove_element(Any element)
           
 boolean SetPOATie.contains_element(Any element)
           
 boolean SetPOATie.add_element(Any element)
           
 boolean SetPOATie.locate_next_element(Any element, Iterator where)
           
 boolean SetPOATie.contains_all_from(Collection collector)
           
 boolean SetPOATie.locate_or_add_element(Any element)
           
 int SetPOATie.number_of_occurrences(Any element)
           
 boolean SetPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void SetPOATie.add_all_from(Collection collector)
           
 void SetPOATie.replace_element_at(Iterator where, Any element)
           
 int SetPOATie.remove_all_occurrences(Any element)
           
 boolean MapPOATie.locate_next_element(Any element, Iterator where)
           
 boolean MapPOATie.contains_element(Any element)
           
 boolean MapPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean MapPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 void MapPOATie.add_intersection(Map collector1, Map collector2)
           
 boolean MapPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean MapPOATie.locate_or_add_element(Any element)
           
 int MapPOATie.remove_all_occurrences(Any element)
           
 boolean MapPOATie.locate_or_add_element_with_key(Any element)
           
 boolean MapPOATie.remove_element(Any element)
           
 boolean MapPOATie.locate_element(Any element, Iterator where)
           
 boolean MapPOATie.add_element(Any element)
           
 void MapPOATie.replace_element_at(Iterator where, Any element)
           
 boolean MapPOATie.add_or_replace_element_with_key(Any element)
           
 void MapPOATie.difference_with(Map collector)
           
 void MapPOATie.keys(Any[] elements, AnySequenceHolder keys)
           
 boolean MapPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean MapPOATie.contains_all_from(Collection collector)
           
 void MapPOATie.add_all_from(Collection collector)
           
 void MapPOATie.intersection_with(Map collector)
           
 void MapPOATie.union_with(Map collector)
           
 int MapPOATie.number_of_occurrences(Any element)
           
 boolean MapPOATie.equal(Map collector)
           
 void MapPOATie.add_union(Map collector1, Map collector2)
           
 boolean MapPOATie.replace_element_with_key(Any element)
           
 boolean MapPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void MapPOATie.add_difference(Map collector1, Map collector2)
           
 boolean MapPOATie.not_equal(Map collector)
           
 void MapPOATie.key(Any element, AnyHolder key)
           
 boolean KeyBagPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyBagPOATie.replace_element_with_key(Any element)
           
 boolean KeyBagPOATie.add_or_replace_element_with_key(Any element)
           
 void KeyBagPOATie.keys(Any[] elements, AnySequenceHolder keys)
           
 void KeyBagPOATie.key(Any element, AnyHolder key)
           
 boolean KeyBagPOATie.add_element(Any element)
           
 boolean KeyBagPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyBagPOATie.locate_or_add_element_with_key(Any element)
           
 boolean KeyBagPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyBagPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void KeyBagPOATie.add_all_from(Collection collector)
           
 void KeyBagPOATie.replace_element_at(Iterator where, Any element)
           
 boolean KeySetPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySetPOATie.replace_element_with_key(Any element)
           
 boolean KeySetPOATie.add_or_replace_element_with_key(Any element)
           
 void KeySetPOATie.keys(Any[] elements, AnySequenceHolder keys)
           
 void KeySetPOATie.key(Any element, AnyHolder key)
           
 boolean KeySetPOATie.add_element(Any element)
           
 boolean KeySetPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySetPOATie.locate_or_add_element_with_key(Any element)
           
 boolean KeySetPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySetPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void KeySetPOATie.add_all_from(Collection collector)
           
 void KeySetPOATie.replace_element_at(Iterator where, Any element)
           
 boolean EqualityKeySortedCollectionPOATie.locate_next_element(Any element, Iterator where)
           
 boolean EqualityKeySortedCollectionPOATie.contains_element(Any element)
           
 boolean EqualityKeySortedCollectionPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean EqualityKeySortedCollectionPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean EqualityKeySortedCollectionPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean EqualityKeySortedCollectionPOATie.locate_or_add_element(Any element)
           
 int EqualityKeySortedCollectionPOATie.remove_all_occurrences(Any element)
           
 boolean EqualityKeySortedCollectionPOATie.locate_or_add_element_with_key(Any element)
           
 boolean EqualityKeySortedCollectionPOATie.remove_element(Any element)
           
 boolean EqualityKeySortedCollectionPOATie.locate_element(Any element, Iterator where)
           
 boolean EqualityKeySortedCollectionPOATie.add_element(Any element)
           
 void EqualityKeySortedCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean EqualityKeySortedCollectionPOATie.add_or_replace_element_with_key(Any element)
           
 boolean EqualityKeySortedCollectionPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void EqualityKeySortedCollectionPOATie.keys(Any[] elements, AnySequenceHolder keys)
           
 boolean EqualityKeySortedCollectionPOATie.contains_all_from(Collection collector)
           
 void EqualityKeySortedCollectionPOATie.add_all_from(Collection collector)
           
 int EqualityKeySortedCollectionPOATie.number_of_occurrences(Any element)
           
 boolean EqualityKeySortedCollectionPOATie.replace_element_with_key(Any element)
           
 boolean EqualityKeySortedCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void EqualityKeySortedCollectionPOATie.key(Any element, AnyHolder key)
           
 boolean _EqualityKeySortedCollectionStub.locate_next_element(Any element, Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.contains_element(Any element)
           
 boolean _EqualityKeySortedCollectionStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.locate_or_add_element(Any element)
           
 int _EqualityKeySortedCollectionStub.remove_all_occurrences(Any element)
           
 boolean _EqualityKeySortedCollectionStub.locate_or_add_element_with_key(Any element)
           
 boolean _EqualityKeySortedCollectionStub.remove_element(Any element)
           
 boolean _EqualityKeySortedCollectionStub.locate_element(Any element, Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.add_element(Any element)
           
 void _EqualityKeySortedCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _EqualityKeySortedCollectionStub.add_or_replace_element_with_key(Any element)
           
 boolean _EqualityKeySortedCollectionStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void _EqualityKeySortedCollectionStub.keys(Any[] elements, AnySequenceHolder keys)
           
 boolean _EqualityKeySortedCollectionStub.contains_all_from(Collection collector)
           
 void _EqualityKeySortedCollectionStub.add_all_from(Collection collector)
           
 int _EqualityKeySortedCollectionStub.number_of_occurrences(Any element)
           
 boolean _EqualityKeySortedCollectionStub.replace_element_with_key(Any element)
           
 boolean _EqualityKeySortedCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _EqualityKeySortedCollectionStub.key(Any element, AnyHolder key)
           
 boolean KeySortedCollectionPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedCollectionPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedCollectionPOATie.locate_or_add_element_with_key(Any element)
           
 boolean KeySortedCollectionPOATie.add_element(Any element)
           
 void KeySortedCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean KeySortedCollectionPOATie.add_or_replace_element_with_key(Any element)
           
 boolean KeySortedCollectionPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void KeySortedCollectionPOATie.keys(Any[] elements, AnySequenceHolder keys)
           
 void KeySortedCollectionPOATie.add_all_from(Collection collector)
           
 boolean KeySortedCollectionPOATie.replace_element_with_key(Any element)
           
 boolean KeySortedCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void KeySortedCollectionPOATie.key(Any element, AnyHolder key)
           
 boolean _KeySortedCollectionStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedCollectionStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedCollectionStub.locate_or_add_element_with_key(Any element)
           
 boolean _KeySortedCollectionStub.add_element(Any element)
           
 void _KeySortedCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _KeySortedCollectionStub.add_or_replace_element_with_key(Any element)
           
 boolean _KeySortedCollectionStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void _KeySortedCollectionStub.keys(Any[] elements, AnySequenceHolder keys)
           
 void _KeySortedCollectionStub.add_all_from(Collection collector)
           
 boolean _KeySortedCollectionStub.replace_element_with_key(Any element)
           
 boolean _KeySortedCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _KeySortedCollectionStub.key(Any element, AnyHolder key)
           
 boolean EqualityKeyCollectionPOATie.locate_next_element(Any element, Iterator where)
           
 boolean EqualityKeyCollectionPOATie.contains_element(Any element)
           
 boolean EqualityKeyCollectionPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean EqualityKeyCollectionPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean EqualityKeyCollectionPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean EqualityKeyCollectionPOATie.locate_or_add_element(Any element)
           
 int EqualityKeyCollectionPOATie.remove_all_occurrences(Any element)
           
 boolean EqualityKeyCollectionPOATie.locate_or_add_element_with_key(Any element)
           
 boolean EqualityKeyCollectionPOATie.remove_element(Any element)
           
 boolean EqualityKeyCollectionPOATie.locate_element(Any element, Iterator where)
           
 boolean EqualityKeyCollectionPOATie.add_element(Any element)
           
 void EqualityKeyCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean EqualityKeyCollectionPOATie.add_or_replace_element_with_key(Any element)
           
 boolean EqualityKeyCollectionPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void EqualityKeyCollectionPOATie.keys(Any[] elements, AnySequenceHolder keys)
           
 boolean EqualityKeyCollectionPOATie.contains_all_from(Collection collector)
           
 void EqualityKeyCollectionPOATie.add_all_from(Collection collector)
           
 int EqualityKeyCollectionPOATie.number_of_occurrences(Any element)
           
 boolean EqualityKeyCollectionPOATie.replace_element_with_key(Any element)
           
 boolean EqualityKeyCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void EqualityKeyCollectionPOATie.key(Any element, AnyHolder key)
           
 boolean _EqualityKeyCollectionStub.locate_next_element(Any element, Iterator where)
           
 boolean _EqualityKeyCollectionStub.contains_element(Any element)
           
 boolean _EqualityKeyCollectionStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _EqualityKeyCollectionStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _EqualityKeyCollectionStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _EqualityKeyCollectionStub.locate_or_add_element(Any element)
           
 int _EqualityKeyCollectionStub.remove_all_occurrences(Any element)
           
 boolean _EqualityKeyCollectionStub.locate_or_add_element_with_key(Any element)
           
 boolean _EqualityKeyCollectionStub.remove_element(Any element)
           
 boolean _EqualityKeyCollectionStub.locate_element(Any element, Iterator where)
           
 boolean _EqualityKeyCollectionStub.add_element(Any element)
           
 void _EqualityKeyCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _EqualityKeyCollectionStub.add_or_replace_element_with_key(Any element)
           
 boolean _EqualityKeyCollectionStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void _EqualityKeyCollectionStub.keys(Any[] elements, AnySequenceHolder keys)
           
 boolean _EqualityKeyCollectionStub.contains_all_from(Collection collector)
           
 void _EqualityKeyCollectionStub.add_all_from(Collection collector)
           
 int _EqualityKeyCollectionStub.number_of_occurrences(Any element)
           
 boolean _EqualityKeyCollectionStub.replace_element_with_key(Any element)
           
 boolean _EqualityKeyCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _EqualityKeyCollectionStub.key(Any element, AnyHolder key)
           
 boolean KeyCollectionPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyCollectionPOATie.replace_element_with_key(Any element)
           
 boolean KeyCollectionPOATie.add_or_replace_element_with_key(Any element)
           
 void KeyCollectionPOATie.keys(Any[] elements, AnySequenceHolder keys)
           
 void KeyCollectionPOATie.key(Any element, AnyHolder key)
           
 boolean KeyCollectionPOATie.add_element(Any element)
           
 boolean KeyCollectionPOATie.locate_or_add_element_with_key(Any element)
           
 boolean KeyCollectionPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyCollectionPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void KeyCollectionPOATie.add_all_from(Collection collector)
           
 void KeyCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean EqualitySequentialIteratorPOATie.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 void EqualitySequentialIteratorPOATie.add_n_elements_as_next_set_iterator(Any[] elements)
           
 boolean EqualitySequentialIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean EqualitySequentialIteratorPOATie.set_to_first_element_with_value(Any element)
           
 boolean EqualitySequentialIteratorPOATie.add_element_as_previous_set_iterator(Any element)
           
 void EqualitySequentialIteratorPOATie.replace_element(Any element)
           
 void EqualitySequentialIteratorPOATie.add_n_elements_as_previous_set_iterator(Any[] elements)
           
 boolean EqualitySequentialIteratorPOATie.set_to_last_element_with_value(Any element)
           
 boolean EqualitySequentialIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualitySequentialIteratorPOATie.add_element_as_next_set_iterator(Any element)
           
 boolean EqualitySequentialIteratorPOATie.set_to_previous_element_with_value(Any element)
           
 boolean EqualitySequentialIteratorPOATie.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean EqualitySequentialIteratorPOATie.set_to_next_element_with_value(Any element)
           
 boolean EqualitySequentialIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean EqualitySequentialIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean EqualitySequentialIteratorPOATie.set_to_element_with_value(Any element)
           
 boolean EqualitySequentialIteratorPOATie.add_element_set_iterator(Any element)
           
 boolean EqualitySequentialIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualitySequentialIteratorStub.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 void _EqualitySequentialIteratorStub.add_n_elements_as_next_set_iterator(Any[] elements)
           
 boolean _EqualitySequentialIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _EqualitySequentialIteratorStub.set_to_first_element_with_value(Any element)
           
 boolean _EqualitySequentialIteratorStub.add_element_as_previous_set_iterator(Any element)
           
 void _EqualitySequentialIteratorStub.replace_element(Any element)
           
 void _EqualitySequentialIteratorStub.add_n_elements_as_previous_set_iterator(Any[] elements)
           
 boolean _EqualitySequentialIteratorStub.set_to_last_element_with_value(Any element)
           
 boolean _EqualitySequentialIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualitySequentialIteratorStub.add_element_as_next_set_iterator(Any element)
           
 boolean _EqualitySequentialIteratorStub.set_to_previous_element_with_value(Any element)
           
 boolean _EqualitySequentialIteratorStub.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean _EqualitySequentialIteratorStub.set_to_next_element_with_value(Any element)
           
 boolean _EqualitySequentialIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _EqualitySequentialIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _EqualitySequentialIteratorStub.set_to_element_with_value(Any element)
           
 boolean _EqualitySequentialIteratorStub.add_element_set_iterator(Any element)
           
 boolean _EqualitySequentialIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualitySequentialIteratorOperations.set_to_first_element_with_value(Any element)
           
 boolean EqualitySequentialIteratorOperations.set_to_last_element_with_value(Any element)
           
 boolean EqualitySequentialIteratorOperations.set_to_previous_element_with_value(Any element)
           
 boolean EqualityKeySortedIteratorPOATie.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 boolean EqualityKeySortedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_last_element_with_value(Any element, UpperBoundStyle style)
           
 void EqualityKeySortedIteratorPOATie.replace_element(Any element)
           
 boolean EqualityKeySortedIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_previous_element_with_value(Any elementally)
           
 boolean EqualityKeySortedIteratorPOATie.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_next_element_with_value(Any element)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_first_element_with_value(Any element, LowerBoundStyle style)
           
 boolean EqualityKeySortedIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean EqualityKeySortedIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_element_with_value(Any element)
           
 boolean EqualityKeySortedIteratorPOATie.add_element_set_iterator(Any element)
           
 boolean EqualityKeySortedIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualityKeySortedIteratorStub.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 boolean _EqualityKeySortedIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _EqualityKeySortedIteratorStub.set_to_last_element_with_value(Any element, UpperBoundStyle style)
           
 void _EqualityKeySortedIteratorStub.replace_element(Any element)
           
 boolean _EqualityKeySortedIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualityKeySortedIteratorStub.set_to_previous_element_with_value(Any elementally)
           
 boolean _EqualityKeySortedIteratorStub.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean _EqualityKeySortedIteratorStub.set_to_next_element_with_value(Any element)
           
 boolean _EqualityKeySortedIteratorStub.set_to_first_element_with_value(Any element, LowerBoundStyle style)
           
 boolean _EqualityKeySortedIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _EqualityKeySortedIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _EqualityKeySortedIteratorStub.set_to_element_with_value(Any element)
           
 boolean _EqualityKeySortedIteratorStub.add_element_set_iterator(Any element)
           
 boolean _EqualityKeySortedIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualitySortedIteratorPOATie.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 boolean EqualitySortedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean EqualitySortedIteratorPOATie.set_to_last_element_with_value(Any element, UpperBoundStyle style)
           
 void EqualitySortedIteratorPOATie.replace_element(Any element)
           
 boolean EqualitySortedIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualitySortedIteratorPOATie.set_to_previous_element_with_value(Any elementally)
           
 boolean EqualitySortedIteratorPOATie.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean EqualitySortedIteratorPOATie.set_to_next_element_with_value(Any element)
           
 boolean EqualitySortedIteratorPOATie.set_to_first_element_with_value(Any element, LowerBoundStyle style)
           
 boolean EqualitySortedIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean EqualitySortedIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean EqualitySortedIteratorPOATie.set_to_element_with_value(Any element)
           
 boolean EqualitySortedIteratorPOATie.add_element_set_iterator(Any element)
           
 boolean EqualitySortedIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualitySortedIteratorStub.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 boolean _EqualitySortedIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _EqualitySortedIteratorStub.set_to_last_element_with_value(Any element, UpperBoundStyle style)
           
 void _EqualitySortedIteratorStub.replace_element(Any element)
           
 boolean _EqualitySortedIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualitySortedIteratorStub.set_to_previous_element_with_value(Any elementally)
           
 boolean _EqualitySortedIteratorStub.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean _EqualitySortedIteratorStub.set_to_next_element_with_value(Any element)
           
 boolean _EqualitySortedIteratorStub.set_to_first_element_with_value(Any element, LowerBoundStyle style)
           
 boolean _EqualitySortedIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _EqualitySortedIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _EqualitySortedIteratorStub.set_to_element_with_value(Any element)
           
 boolean _EqualitySortedIteratorStub.add_element_set_iterator(Any element)
           
 boolean _EqualitySortedIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean KeySortedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean KeySortedIteratorPOATie.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 void KeySortedIteratorPOATie.replace_element(Any element)
           
 boolean KeySortedIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean KeySortedIteratorPOATie.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean KeySortedIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean KeySortedIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean KeySortedIteratorPOATie.add_element_set_iterator(Any element)
           
 boolean KeySortedIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _KeySortedIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _KeySortedIteratorStub.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 void _KeySortedIteratorStub.replace_element(Any element)
           
 boolean _KeySortedIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _KeySortedIteratorStub.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean _KeySortedIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _KeySortedIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _KeySortedIteratorStub.add_element_set_iterator(Any element)
           
 boolean _KeySortedIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean SortedIteratorPOATie.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 boolean SortedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 void SortedIteratorPOATie.replace_element(Any element)
           
 boolean SortedIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean SortedIteratorPOATie.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean SortedIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean SortedIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean SortedIteratorPOATie.add_element_set_iterator(Any element)
           
 boolean SortedIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _SortedIteratorStub.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 boolean _SortedIteratorStub.replace_element_set_to_previous(Any element)
           
 void _SortedIteratorStub.replace_element(Any element)
           
 boolean _SortedIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _SortedIteratorStub.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean _SortedIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _SortedIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _SortedIteratorStub.add_element_set_iterator(Any element)
           
 boolean _SortedIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 void EqualityKeyIteratorPOATie.replace_element(Any element)
           
 boolean EqualityKeyIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualityKeyIteratorPOATie.set_to_element_with_value(Any element)
           
 boolean EqualityKeyIteratorPOATie.set_to_next_element_with_value(Any element)
           
 boolean EqualityKeyIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean EqualityKeyIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean EqualityKeyIteratorPOATie.add_element_set_iterator(Any element)
           
 boolean EqualityKeyIteratorPOATie.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 void _EqualityKeyIteratorStub.replace_element(Any element)
           
 boolean _EqualityKeyIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualityKeyIteratorStub.set_to_element_with_value(Any element)
           
 boolean _EqualityKeyIteratorStub.set_to_next_element_with_value(Any element)
           
 boolean _EqualityKeyIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _EqualityKeyIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _EqualityKeyIteratorStub.add_element_set_iterator(Any element)
           
 boolean _EqualityKeyIteratorStub.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 void EqualityIteratorPOATie.replace_element(Any element)
           
 boolean EqualityIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualityIteratorPOATie.set_to_element_with_value(Any element)
           
 boolean EqualityIteratorPOATie.set_to_next_element_with_value(Any element)
           
 boolean EqualityIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean EqualityIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean EqualityIteratorPOATie.add_element_set_iterator(Any element)
           
 boolean EqualityIteratorPOATie.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 void _EqualityIteratorStub.replace_element(Any element)
           
 boolean _EqualityIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualityIteratorStub.set_to_element_with_value(Any element)
           
 boolean _EqualityIteratorStub.set_to_next_element_with_value(Any element)
           
 boolean _EqualityIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _EqualityIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _EqualityIteratorStub.add_element_set_iterator(Any element)
           
 boolean _EqualityIteratorStub.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 void KeyIteratorPOATie.replace_element(Any element)
           
 boolean KeyIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean KeyIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean KeyIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean KeyIteratorPOATie.add_element_set_iterator(Any element)
           
 boolean KeyIteratorPOATie.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 void _KeyIteratorStub.replace_element(Any element)
           
 boolean _KeyIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _KeyIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _KeyIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _KeyIteratorStub.add_element_set_iterator(Any element)
           
 boolean _KeyIteratorStub.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 boolean SequentialIteratorPOATie.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 void SequentialIteratorPOATie.add_n_elements_as_next_set_iterator(Any[] elements)
           
 boolean SequentialIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean SequentialIteratorPOATie.add_element_as_previous_set_iterator(Any element)
           
 void SequentialIteratorPOATie.replace_element(Any element)
           
 void SequentialIteratorPOATie.add_n_elements_as_previous_set_iterator(Any[] elements)
           
 boolean SequentialIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean SequentialIteratorPOATie.add_element_as_next_set_iterator(Any element)
           
 boolean SequentialIteratorPOATie.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean SequentialIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean SequentialIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean SequentialIteratorPOATie.add_element_set_iterator(Any element)
           
 boolean SequentialIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _SequentialIteratorStub.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 void _SequentialIteratorStub.add_n_elements_as_next_set_iterator(Any[] elements)
           
 boolean _SequentialIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _SequentialIteratorStub.add_element_as_previous_set_iterator(Any element)
           
 void _SequentialIteratorStub.replace_element(Any element)
           
 void _SequentialIteratorStub.add_n_elements_as_previous_set_iterator(Any[] elements)
           
 boolean _SequentialIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _SequentialIteratorStub.add_element_as_next_set_iterator(Any element)
           
 boolean _SequentialIteratorStub.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean _SequentialIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _SequentialIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _SequentialIteratorStub.add_element_set_iterator(Any element)
           
 boolean _SequentialIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean OrderedIteratorPOATie.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 boolean OrderedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 void OrderedIteratorPOATie.replace_element(Any element)
           
 boolean OrderedIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean OrderedIteratorPOATie.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean OrderedIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean OrderedIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean OrderedIteratorPOATie.add_element_set_iterator(Any element)
           
 boolean OrderedIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 void _StackStub.push(Any element)
           
 boolean _SortedSetStub.locate_next_element(Any element, Iterator where)
           
 boolean _SortedSetStub.contains_element(Any element)
           
 boolean _SortedSetStub.locate_previous_element(Any element, Iterator where)
           
 boolean _SortedSetStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _SortedSetStub.locate_or_add_element(Any element)
           
 int _SortedSetStub.remove_all_occurrences(Any element)
           
 boolean _SortedSetStub.remove_element(Any element)
           
 boolean _SortedSetStub.locate_element(Any element, Iterator where)
           
 boolean _SortedSetStub.add_element(Any element)
           
 void _SortedSetStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedSetStub.locate_first_element(Any element, Iterator where)
           
 boolean _SortedSetStub.contains_all_from(Collection collector)
           
 void _SortedSetStub.add_all_from(Collection collector)
           
 int _SortedSetStub.number_of_occurrences(Any element)
           
 boolean _SortedSetStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _SortedSetStub.locate_last_element(Any element, Iterator where)
           
 boolean _SortedRelationStub.locate_next_element(Any element, Iterator where)
           
 boolean _SortedRelationStub.contains_element(Any element)
           
 boolean _SortedRelationStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _SortedRelationStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _SortedRelationStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _SortedRelationStub.locate_or_add_element(Any element)
           
 int _SortedRelationStub.remove_all_occurrences(Any element)
           
 boolean _SortedRelationStub.locate_or_add_element_with_key(Any element)
           
 boolean _SortedRelationStub.remove_element(Any element)
           
 boolean _SortedRelationStub.locate_element(Any element, Iterator where)
           
 boolean _SortedRelationStub.add_element(Any element)
           
 void _SortedRelationStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedRelationStub.add_or_replace_element_with_key(Any element)
           
 boolean _SortedRelationStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void _SortedRelationStub.keys(Any[] elements, AnySequenceHolder keys)
           
 boolean _SortedRelationStub.contains_all_from(Collection collector)
           
 void _SortedRelationStub.add_all_from(Collection collector)
           
 int _SortedRelationStub.number_of_occurrences(Any element)
           
 boolean _SortedRelationStub.replace_element_with_key(Any element)
           
 boolean _SortedRelationStub.add_element_set_iterator(Any element, Iterator where)
           
 void _SortedRelationStub.key(Any element, AnyHolder key)
           
 boolean _SortedMapStub.locate_next_element(Any element, Iterator where)
           
 boolean _SortedMapStub.contains_element(Any element)
           
 boolean _SortedMapStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _SortedMapStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _SortedMapStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _SortedMapStub.locate_or_add_element(Any element)
           
 int _SortedMapStub.remove_all_occurrences(Any element)
           
 boolean _SortedMapStub.locate_or_add_element_with_key(Any element)
           
 boolean _SortedMapStub.remove_element(Any element)
           
 boolean _SortedMapStub.locate_element(Any element, Iterator where)
           
 boolean _SortedMapStub.add_element(Any element)
           
 void _SortedMapStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedMapStub.add_or_replace_element_with_key(Any element)
           
 boolean _SortedMapStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void _SortedMapStub.keys(Any[] elements, AnySequenceHolder keys)
           
 boolean _SortedMapStub.contains_all_from(Collection collector)
           
 void _SortedMapStub.add_all_from(Collection collector)
           
 int _SortedMapStub.number_of_occurrences(Any element)
           
 boolean _SortedMapStub.replace_element_with_key(Any element)
           
 boolean _SortedMapStub.add_element_set_iterator(Any element, Iterator where)
           
 void _SortedMapStub.key(Any element, AnyHolder key)
           
 boolean _SortedCollectionStub.add_element(Any element)
           
 boolean _SortedCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _SortedCollectionStub.add_all_from(Collection collector)
           
 void _SortedCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedBagStub.locate_next_element(Any element, Iterator where)
           
 boolean _SortedBagStub.contains_element(Any element)
           
 boolean _SortedBagStub.locate_previous_element(Any element, Iterator where)
           
 boolean _SortedBagStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _SortedBagStub.locate_or_add_element(Any element)
           
 int _SortedBagStub.remove_all_occurrences(Any element)
           
 boolean _SortedBagStub.remove_element(Any element)
           
 boolean _SortedBagStub.locate_element(Any element, Iterator where)
           
 boolean _SortedBagStub.add_element(Any element)
           
 void _SortedBagStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedBagStub.locate_first_element(Any element, Iterator where)
           
 boolean _SortedBagStub.contains_all_from(Collection collector)
           
 void _SortedBagStub.add_all_from(Collection collector)
           
 int _SortedBagStub.number_of_occurrences(Any element)
           
 boolean _SortedBagStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _SortedBagStub.locate_last_element(Any element, Iterator where)
           
 boolean _SetStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _SetStub.locate_element(Any element, Iterator where)
           
 boolean _SetStub.remove_element(Any element)
           
 boolean _SetStub.contains_element(Any element)
           
 boolean _SetStub.add_element(Any element)
           
 boolean _SetStub.locate_next_element(Any element, Iterator where)
           
 boolean _SetStub.contains_all_from(Collection collector)
           
 boolean _SetStub.locate_or_add_element(Any element)
           
 int _SetStub.number_of_occurrences(Any element)
           
 boolean _SetStub.add_element_set_iterator(Any element, Iterator where)
           
 void _SetStub.add_all_from(Collection collector)
           
 void _SetStub.replace_element_at(Iterator where, Any element)
           
 int _SetStub.remove_all_occurrences(Any element)
           
 void _SequentialCollectionStub.add_element_as_last(Any element)
           
 void _SequentialCollectionStub.add_element_as_first(Any element)
           
 void _SequentialCollectionStub.add_element_at_position(int position, Any element)
           
 void _SequentialCollectionStub.add_element_as_next(Any element, Iterator where)
           
 void _SequentialCollectionStub.replace_element_at_position(int position, Any element)
           
 void _SequentialCollectionStub.replace_last_element(Any element)
           
 boolean _SequentialCollectionStub.add_element(Any element)
           
 void _SequentialCollectionStub.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 void _SequentialCollectionStub.replace_first_element(Any element)
           
 void _SequentialCollectionStub.add_element_as_last_set_iterator(Any element, Iterator where)
           
 boolean _SequentialCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _SequentialCollectionStub.add_element_as_first_set_iterator(Any element, Iterator where)
           
 void _SequentialCollectionStub.add_element_as_previous(Any element, Iterator where)
           
 void _SequentialCollectionStub.add_all_from(Collection collector)
           
 void _SequentialCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _RelationStub.locate_next_element(Any element, Iterator where)
           
 boolean _RelationStub.contains_element(Any element)
           
 boolean _RelationStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _RelationStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _RelationStub.locate_or_add_element(Any element)
           
 boolean _RelationStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 int _RelationStub.remove_all_occurrences(Any element)
           
 boolean _RelationStub.locate_or_add_element_with_key(Any element)
           
 boolean _RelationStub.remove_element(Any element)
           
 boolean _RelationStub.locate_element(Any element, Iterator where)
           
 boolean _RelationStub.add_element(Any element)
           
 void _RelationStub.replace_element_at(Iterator where, Any element)
           
 boolean _RelationStub.add_or_replace_element_with_key(Any element)
           
 boolean _RelationStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void _RelationStub.keys(Any[] elements, AnySequenceHolder keys)
           
 boolean _RelationStub.contains_all_from(Collection collector)
           
 void _RelationStub.add_all_from(Collection collector)
           
 int _RelationStub.number_of_occurrences(Any element)
           
 boolean _RelationStub.replace_element_with_key(Any element)
           
 boolean _RelationStub.add_element_set_iterator(Any element, Iterator where)
           
 void _RelationStub.key(Any element, AnyHolder key)
           
 void _QueueStub.enqueue(Any element)
           
 void _PriorityQueueStub.enqueue(Any element)
           
 boolean _OrderedIteratorStub.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 boolean _OrderedIteratorStub.replace_element_set_to_previous(Any element)
           
 void _OrderedIteratorStub.replace_element(Any element)
           
 boolean _OrderedIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _OrderedIteratorStub.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean _OrderedIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _OrderedIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _OrderedIteratorStub.add_element_set_iterator(Any element)
           
 boolean _OrderedIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _OrderedCollectionStub.add_element(Any element)
           
 boolean _OrderedCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _OrderedCollectionStub.add_all_from(Collection collector)
           
 void _OrderedCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _MapStub.locate_next_element(Any element, Iterator where)
           
 boolean _MapStub.contains_element(Any element)
           
 boolean _MapStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _MapStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 void _MapStub.add_intersection(Map collector1, Map collector2)
           
 boolean _MapStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _MapStub.locate_or_add_element(Any element)
           
 int _MapStub.remove_all_occurrences(Any element)
           
 boolean _MapStub.locate_or_add_element_with_key(Any element)
           
 boolean _MapStub.remove_element(Any element)
           
 boolean _MapStub.locate_element(Any element, Iterator where)
           
 boolean _MapStub.add_element(Any element)
           
 void _MapStub.replace_element_at(Iterator where, Any element)
           
 boolean _MapStub.add_or_replace_element_with_key(Any element)
           
 void _MapStub.difference_with(Map collector)
           
 void _MapStub.keys(Any[] elements, AnySequenceHolder keys)
           
 boolean _MapStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _MapStub.contains_all_from(Collection collector)
           
 void _MapStub.add_all_from(Collection collector)
           
 void _MapStub.intersection_with(Map collector)
           
 void _MapStub.union_with(Map collector)
           
 int _MapStub.number_of_occurrences(Any element)
           
 boolean _MapStub.equal(Map collector)
           
 void _MapStub.add_union(Map collector1, Map collector2)
           
 boolean _MapStub.replace_element_with_key(Any element)
           
 boolean _MapStub.add_element_set_iterator(Any element, Iterator where)
           
 void _MapStub.add_difference(Map collector1, Map collector2)
           
 boolean _MapStub.not_equal(Map collector)
           
 void _MapStub.key(Any element, AnyHolder key)
           
 boolean _KeySortedSetStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedSetStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedSetStub.locate_or_add_element_with_key(Any element)
           
 boolean _KeySortedSetStub.add_element(Any element)
           
 void _KeySortedSetStub.replace_element_at(Iterator where, Any element)
           
 boolean _KeySortedSetStub.add_or_replace_element_with_key(Any element)
           
 boolean _KeySortedSetStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void _KeySortedSetStub.keys(Any[] elements, AnySequenceHolder keys)
           
 void _KeySortedSetStub.add_all_from(Collection collector)
           
 boolean _KeySortedSetStub.replace_element_with_key(Any element)
           
 boolean _KeySortedSetStub.add_element_set_iterator(Any element, Iterator where)
           
 void _KeySortedSetStub.key(Any element, AnyHolder key)
           
 boolean _KeySortedBagStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedBagStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedBagStub.locate_or_add_element_with_key(Any element)
           
 boolean _KeySortedBagStub.add_element(Any element)
           
 void _KeySortedBagStub.replace_element_at(Iterator where, Any element)
           
 boolean _KeySortedBagStub.add_or_replace_element_with_key(Any element)
           
 boolean _KeySortedBagStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void _KeySortedBagStub.keys(Any[] elements, AnySequenceHolder keys)
           
 void _KeySortedBagStub.add_all_from(Collection collector)
           
 boolean _KeySortedBagStub.replace_element_with_key(Any element)
           
 boolean _KeySortedBagStub.add_element_set_iterator(Any element, Iterator where)
           
 void _KeySortedBagStub.key(Any element, AnyHolder key)
           
 boolean _KeySetStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySetStub.replace_element_with_key(Any element)
           
 boolean _KeySetStub.add_or_replace_element_with_key(Any element)
           
 void _KeySetStub.keys(Any[] elements, AnySequenceHolder keys)
           
 void _KeySetStub.key(Any element, AnyHolder key)
           
 boolean _KeySetStub.add_element(Any element)
           
 boolean _KeySetStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySetStub.locate_or_add_element_with_key(Any element)
           
 boolean _KeySetStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySetStub.add_element_set_iterator(Any element, Iterator where)
           
 void _KeySetStub.add_all_from(Collection collector)
           
 void _KeySetStub.replace_element_at(Iterator where, Any element)
           
 boolean _KeyCollectionStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeyCollectionStub.replace_element_with_key(Any element)
           
 boolean _KeyCollectionStub.add_or_replace_element_with_key(Any element)
           
 void _KeyCollectionStub.keys(Any[] elements, AnySequenceHolder keys)
           
 void _KeyCollectionStub.key(Any element, AnyHolder key)
           
 boolean _KeyCollectionStub.add_element(Any element)
           
 boolean _KeyCollectionStub.locate_or_add_element_with_key(Any element)
           
 boolean _KeyCollectionStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeyCollectionStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeyCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _KeyCollectionStub.add_all_from(Collection collector)
           
 void _KeyCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _KeyBagStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeyBagStub.replace_element_with_key(Any element)
           
 boolean _KeyBagStub.add_or_replace_element_with_key(Any element)
           
 void _KeyBagStub.keys(Any[] elements, AnySequenceHolder keys)
           
 void _KeyBagStub.key(Any element, AnyHolder key)
           
 boolean _KeyBagStub.add_element(Any element)
           
 boolean _KeyBagStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeyBagStub.locate_or_add_element_with_key(Any element)
           
 boolean _KeyBagStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeyBagStub.add_element_set_iterator(Any element, Iterator where)
           
 void _KeyBagStub.add_all_from(Collection collector)
           
 void _KeyBagStub.replace_element_at(Iterator where, Any element)
           
 void _IteratorStub.replace_element(Any element)
           
 boolean _IteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _IteratorStub.replace_element_set_to_next(Any element)
           
 boolean _IteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _IteratorStub.add_element_set_iterator(Any element)
           
 boolean _IteratorStub.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 boolean _HeapStub.add_element(Any element)
           
 void _HeapStub.replace_element_at(Iterator where, Any element)
           
 boolean _HeapStub.add_element_set_iterator(Any element, Iterator where)
           
 void _HeapStub.add_all_from(Collection collector)
           
 boolean _EqualitySortedCollectionStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _EqualitySortedCollectionStub.locate_last_element(Any element, Iterator where)
           
 boolean _EqualitySortedCollectionStub.locate_element(Any element, Iterator where)
           
 boolean _EqualitySortedCollectionStub.locate_previous_element(Any element, Iterator where)
           
 boolean _EqualitySortedCollectionStub.remove_element(Any element)
           
 boolean _EqualitySortedCollectionStub.contains_element(Any element)
           
 boolean _EqualitySortedCollectionStub.add_element(Any element)
           
 boolean _EqualitySortedCollectionStub.locate_next_element(Any element, Iterator where)
           
 boolean _EqualitySortedCollectionStub.locate_or_add_element(Any element)
           
 boolean _EqualitySortedCollectionStub.contains_all_from(Collection collector)
           
 boolean _EqualitySortedCollectionStub.locate_first_element(Any element, Iterator where)
           
 int _EqualitySortedCollectionStub.number_of_occurrences(Any element)
           
 boolean _EqualitySortedCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _EqualitySortedCollectionStub.add_all_from(Collection collector)
           
 void _EqualitySortedCollectionStub.replace_element_at(Iterator where, Any element)
           
 int _EqualitySortedCollectionStub.remove_all_occurrences(Any element)
           
 boolean _EqualitySequentialCollectionStub.locate_next_element(Any element, Iterator where)
           
 boolean _EqualitySequentialCollectionStub.contains_element(Any element)
           
 boolean _EqualitySequentialCollectionStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _EqualitySequentialCollectionStub.locate_first_element_with_value(Any element, Iterator where)
           
 void _EqualitySequentialCollectionStub.add_element_as_first(Any element)
           
 void _EqualitySequentialCollectionStub.add_element_as_previous(Any element, Iterator where)
           
 boolean _EqualitySequentialCollectionStub.locate_or_add_element(Any element)
           
 int _EqualitySequentialCollectionStub.remove_all_occurrences(Any element)
           
 boolean _EqualitySequentialCollectionStub.locate_last_element_with_value(Any element, Iterator where)
           
 boolean _EqualitySequentialCollectionStub.remove_element(Any element)
           
 boolean _EqualitySequentialCollectionStub.locate_element(Any element, Iterator where)
           
 boolean _EqualitySequentialCollectionStub.add_element(Any element)
           
 void _EqualitySequentialCollectionStub.add_element_as_last(Any element)
           
 void _EqualitySequentialCollectionStub.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 void _EqualitySequentialCollectionStub.replace_element_at(Iterator where, Any element)
           
 void _EqualitySequentialCollectionStub.add_element_at_position(int position, Any element)
           
 void _EqualitySequentialCollectionStub.replace_last_element(Any element)
           
 boolean _EqualitySequentialCollectionStub.contains_all_from(Collection collector)
           
 void _EqualitySequentialCollectionStub.add_all_from(Collection collector)
           
 void _EqualitySequentialCollectionStub.replace_element_at_position(int position, Any element)
           
 void _EqualitySequentialCollectionStub.add_element_as_last_set_iterator(Any element, Iterator where)
           
 boolean _EqualitySequentialCollectionStub.locate_previous_element_with_value(Any element, Iterator where)
           
 int _EqualitySequentialCollectionStub.number_of_occurrences(Any element)
           
 void _EqualitySequentialCollectionStub.replace_first_element(Any element)
           
 boolean _EqualitySequentialCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _EqualitySequentialCollectionStub.add_element_as_next(Any element, Iterator where)
           
 void _EqualitySequentialCollectionStub.add_element_as_first_set_iterator(Any element, Iterator where)
           
 boolean _EqualitySequenceStub.locate_next_element(Any element, Iterator where)
           
 boolean _EqualitySequenceStub.contains_element(Any element)
           
 boolean _EqualitySequenceStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _EqualitySequenceStub.locate_first_element_with_value(Any element, Iterator where)
           
 void _EqualitySequenceStub.add_element_as_first(Any element)
           
 void _EqualitySequenceStub.add_element_as_previous(Any element, Iterator where)
           
 boolean _EqualitySequenceStub.locate_or_add_element(Any element)
           
 int _EqualitySequenceStub.remove_all_occurrences(Any element)
           
 boolean _EqualitySequenceStub.locate_last_element_with_value(Any element, Iterator where)
           
 boolean _EqualitySequenceStub.remove_element(Any element)
           
 boolean _EqualitySequenceStub.locate_element(Any element, Iterator where)
           
 boolean _EqualitySequenceStub.add_element(Any element)
           
 void _EqualitySequenceStub.add_element_as_last(Any element)
           
 void _EqualitySequenceStub.replace_element_at(Iterator where, Any element)
           
 void _EqualitySequenceStub.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 void _EqualitySequenceStub.add_element_at_position(int position, Any element)
           
 void _EqualitySequenceStub.replace_last_element(Any element)
           
 boolean _EqualitySequenceStub.contains_all_from(Collection collector)
           
 void _EqualitySequenceStub.add_all_from(Collection collector)
           
 void _EqualitySequenceStub.replace_element_at_position(int position, Any element)
           
 void _EqualitySequenceStub.add_element_as_last_set_iterator(Any element, Iterator where)
           
 boolean _EqualitySequenceStub.locate_previous_element_with_value(Any element, Iterator where)
           
 int _EqualitySequenceStub.number_of_occurrences(Any element)
           
 void _EqualitySequenceStub.replace_first_element(Any element)
           
 boolean _EqualitySequenceStub.add_element_set_iterator(Any element, Iterator where)
           
 void _EqualitySequenceStub.add_element_as_next(Any element, Iterator where)
           
 void _EqualitySequenceStub.add_element_as_first_set_iterator(Any element, Iterator where)
           
 boolean _EqualityCollectionStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _EqualityCollectionStub.locate_element(Any element, Iterator where)
           
 boolean _EqualityCollectionStub.remove_element(Any element)
           
 boolean _EqualityCollectionStub.contains_element(Any element)
           
 boolean _EqualityCollectionStub.add_element(Any element)
           
 boolean _EqualityCollectionStub.locate_next_element(Any element, Iterator where)
           
 boolean _EqualityCollectionStub.contains_all_from(Collection collector)
           
 boolean _EqualityCollectionStub.locate_or_add_element(Any element)
           
 int _EqualityCollectionStub.number_of_occurrences(Any element)
           
 boolean _EqualityCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _EqualityCollectionStub.add_all_from(Collection collector)
           
 void _EqualityCollectionStub.replace_element_at(Iterator where, Any element)
           
 int _EqualityCollectionStub.remove_all_occurrences(Any element)
           
 void _DequeStub.enqueue_as_last(Any element)
           
 void _DequeStub.enqueue_as_first(Any element)
           
 boolean _CollectionStub.add_element(Any element)
           
 void _CollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _CollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _CollectionStub.add_all_from(Collection collector)
           
 void _CSequenceStub.add_element_as_last(Any element)
           
 void _CSequenceStub.add_element_as_first(Any element)
           
 void _CSequenceStub.add_element_at_position(int position, Any element)
           
 void _CSequenceStub.add_element_as_next(Any element, Iterator where)
           
 void _CSequenceStub.replace_element_at_position(int position, Any element)
           
 void _CSequenceStub.replace_last_element(Any element)
           
 boolean _CSequenceStub.add_element(Any element)
           
 void _CSequenceStub.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 void _CSequenceStub.replace_first_element(Any element)
           
 void _CSequenceStub.add_element_as_last_set_iterator(Any element, Iterator where)
           
 boolean _CSequenceStub.add_element_set_iterator(Any element, Iterator where)
           
 void _CSequenceStub.add_element_as_first_set_iterator(Any element, Iterator where)
           
 void _CSequenceStub.add_element_as_previous(Any element, Iterator where)
           
 void _CSequenceStub.add_all_from(Collection collector)
           
 void _CSequenceStub.replace_element_at(Iterator where, Any element)
           
 boolean _BagStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _BagStub.locate_element(Any element, Iterator where)
           
 boolean _BagStub.remove_element(Any element)
           
 boolean _BagStub.contains_element(Any element)
           
 boolean _BagStub.add_element(Any element)
           
 boolean _BagStub.locate_next_element(Any element, Iterator where)
           
 boolean _BagStub.contains_all_from(Collection collector)
           
 boolean _BagStub.locate_or_add_element(Any element)
           
 int _BagStub.number_of_occurrences(Any element)
           
 boolean _BagStub.add_element_set_iterator(Any element, Iterator where)
           
 void _BagStub.add_all_from(Collection collector)
           
 void _BagStub.replace_element_at(Iterator where, Any element)
           
 int _BagStub.remove_all_occurrences(Any element)
           
 void StackPOATie.push(Any element)
           
 void StackOperations.push(Any element)
           
 boolean SortedRelationPOATie.locate_next_element(Any element, Iterator where)
           
 boolean SortedRelationPOATie.contains_element(Any element)
           
 boolean SortedRelationPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean SortedRelationPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean SortedRelationPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean SortedRelationPOATie.locate_or_add_element(Any element)
           
 int SortedRelationPOATie.remove_all_occurrences(Any element)
           
 boolean SortedRelationPOATie.locate_or_add_element_with_key(Any element)
           
 boolean SortedRelationPOATie.remove_element(Any element)
           
 boolean SortedRelationPOATie.locate_element(Any element, Iterator where)
           
 boolean SortedRelationPOATie.add_element(Any element)
           
 void SortedRelationPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SortedRelationPOATie.add_or_replace_element_with_key(Any element)
           
 boolean SortedRelationPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void SortedRelationPOATie.keys(Any[] elements, AnySequenceHolder keys)
           
 boolean SortedRelationPOATie.contains_all_from(Collection collector)
           
 void SortedRelationPOATie.add_all_from(Collection collector)
           
 int SortedRelationPOATie.number_of_occurrences(Any element)
           
 boolean SortedRelationPOATie.replace_element_with_key(Any element)
           
 boolean SortedRelationPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void SortedRelationPOATie.key(Any element, AnyHolder key)
           
 boolean SortedCollectionPOATie.add_element(Any element)
           
 boolean SortedCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void SortedCollectionPOATie.add_all_from(Collection collector)
           
 void SortedCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SequentialIteratorOperations.add_element_as_next_set_iterator(Any element)
           
 void SequentialIteratorOperations.add_n_elements_as_next_set_iterator(Any[] elements)
           
 boolean SequentialIteratorOperations.add_element_as_previous_set_iterator(Any element)
           
 void SequentialIteratorOperations.add_n_elements_as_previous_set_iterator(Any[] elements)
           
 void SequentialCollectionPOATie.add_element_as_last(Any element)
           
 void SequentialCollectionPOATie.add_element_as_first(Any element)
           
 void SequentialCollectionPOATie.add_element_at_position(int position, Any element)
           
 void SequentialCollectionPOATie.add_element_as_next(Any element, Iterator where)
           
 void SequentialCollectionPOATie.replace_element_at_position(int position, Any element)
           
 void SequentialCollectionPOATie.replace_last_element(Any element)
           
 boolean SequentialCollectionPOATie.add_element(Any element)
           
 void SequentialCollectionPOATie.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 void SequentialCollectionPOATie.replace_first_element(Any element)
           
 void SequentialCollectionPOATie.add_element_as_last_set_iterator(Any element, Iterator where)
           
 boolean SequentialCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void SequentialCollectionPOATie.add_element_as_first_set_iterator(Any element, Iterator where)
           
 void SequentialCollectionPOATie.add_element_as_previous(Any element, Iterator where)
           
 void SequentialCollectionPOATie.add_all_from(Collection collector)
           
 void SequentialCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 void SequentialCollectionOperations.add_element_as_first(Any element)
           
 void SequentialCollectionOperations.add_element_as_first_set_iterator(Any element, Iterator where)
           
 void SequentialCollectionOperations.add_element_as_last(Any element)
           
 void SequentialCollectionOperations.add_element_as_last_set_iterator(Any element, Iterator where)
           
 void SequentialCollectionOperations.add_element_as_next(Any element, Iterator where)
           
 void SequentialCollectionOperations.add_element_as_previous(Any element, Iterator where)
           
 void SequentialCollectionOperations.add_element_at_position(int position, Any element)
           
 void SequentialCollectionOperations.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 void SequentialCollectionOperations.replace_element_at_position(int position, Any element)
           
 void SequentialCollectionOperations.replace_first_element(Any element)
           
 void SequentialCollectionOperations.replace_last_element(Any element)
           
 boolean RelationPOATie.locate_next_element(Any element, Iterator where)
           
 boolean RelationPOATie.contains_element(Any element)
           
 boolean RelationPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean RelationPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean RelationPOATie.locate_or_add_element(Any element)
           
 boolean RelationPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 int RelationPOATie.remove_all_occurrences(Any element)
           
 boolean RelationPOATie.locate_or_add_element_with_key(Any element)
           
 boolean RelationPOATie.remove_element(Any element)
           
 boolean RelationPOATie.locate_element(Any element, Iterator where)
           
 boolean RelationPOATie.add_element(Any element)
           
 void RelationPOATie.replace_element_at(Iterator where, Any element)
           
 boolean RelationPOATie.add_or_replace_element_with_key(Any element)
           
 boolean RelationPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void RelationPOATie.keys(Any[] elements, AnySequenceHolder keys)
           
 boolean RelationPOATie.contains_all_from(Collection collector)
           
 void RelationPOATie.add_all_from(Collection collector)
           
 int RelationPOATie.number_of_occurrences(Any element)
           
 boolean RelationPOATie.replace_element_with_key(Any element)
           
 boolean RelationPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void RelationPOATie.key(Any element, AnyHolder key)
           
 void QueuePOATie.enqueue(Any element)
           
 void QueueOperations.enqueue(Any element)
           
 void PriorityQueuePOATie.enqueue(Any element)
           
 void PriorityQueueOperations.enqueue(Any element)
           
 boolean OrderedIteratorOperations.replace_element_set_to_previous(Any element)
           
 boolean OrderedIteratorOperations.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean OrderedIteratorOperations.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean OrderedCollectionPOATie.add_element(Any element)
           
 boolean OrderedCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void OrderedCollectionPOATie.add_all_from(Collection collector)
           
 void OrderedCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 void MapOperations.difference_with(Map collector)
           
 void MapOperations.add_difference(Map collector1, Map collector2)
           
 void MapOperations.intersection_with(Map collector)
           
 void MapOperations.add_intersection(Map collector1, Map collector2)
           
 void MapOperations.union_with(Map collector)
           
 void MapOperations.add_union(Map collector1, Map collector2)
           
 boolean MapOperations.equal(Map collector)
           
 boolean MapOperations.not_equal(Map collector)
           
 boolean KeyCollectionOperations.locate_or_add_element_with_key(Any element)
           
 boolean KeyCollectionOperations.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyCollectionOperations.add_or_replace_element_with_key(Any element)
           
 boolean KeyCollectionOperations.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyCollectionOperations.replace_element_with_key(Any element)
           
 boolean KeyCollectionOperations.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 void KeyCollectionOperations.key(Any element, AnyHolder key)
           
 void KeyCollectionOperations.keys(Any[] elements, AnySequenceHolder keys)
           
 void IteratorPOATie.replace_element(Any element)
           
 boolean IteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean IteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean IteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean IteratorPOATie.add_element_set_iterator(Any element)
           
 boolean IteratorPOATie.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 void IteratorOperations.replace_element(Any element)
           
 boolean IteratorOperations.replace_element_set_to_next(Any element)
           
 boolean IteratorOperations.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean IteratorOperations.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean IteratorOperations.add_element_set_iterator(Any element)
           
 boolean IteratorOperations.add_n_elements_set_iterator(Any[] elements, IntHolder actual_number)
           
 boolean HeapPOATie.add_element(Any element)
           
 void HeapPOATie.replace_element_at(Iterator where, Any element)
           
 boolean HeapPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void HeapPOATie.add_all_from(Collection collector)
           
 boolean EqualitySortedIteratorOperations.set_to_first_element_with_value(Any element, LowerBoundStyle style)
           
 boolean EqualitySortedIteratorOperations.set_to_last_element_with_value(Any element, UpperBoundStyle style)
           
 boolean EqualitySortedIteratorOperations.set_to_previous_element_with_value(Any elementally)
           
 boolean EqualitySortedCollectionPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean EqualitySortedCollectionPOATie.locate_last_element(Any element, Iterator where)
           
 boolean EqualitySortedCollectionPOATie.locate_element(Any element, Iterator where)
           
 boolean EqualitySortedCollectionPOATie.locate_previous_element(Any element, Iterator where)
           
 boolean EqualitySortedCollectionPOATie.remove_element(Any element)
           
 boolean EqualitySortedCollectionPOATie.contains_element(Any element)
           
 boolean EqualitySortedCollectionPOATie.add_element(Any element)
           
 boolean EqualitySortedCollectionPOATie.locate_next_element(Any element, Iterator where)
           
 boolean EqualitySortedCollectionPOATie.locate_or_add_element(Any element)
           
 boolean EqualitySortedCollectionPOATie.contains_all_from(Collection collector)
           
 boolean EqualitySortedCollectionPOATie.locate_first_element(Any element, Iterator where)
           
 int EqualitySortedCollectionPOATie.number_of_occurrences(Any element)
           
 boolean EqualitySortedCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void EqualitySortedCollectionPOATie.add_all_from(Collection collector)
           
 void EqualitySortedCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 int EqualitySortedCollectionPOATie.remove_all_occurrences(Any element)
           
 boolean EqualitySortedCollectionOperations.locate_first_element(Any element, Iterator where)
           
 boolean EqualitySortedCollectionOperations.locate_last_element(Any element, Iterator where)
           
 boolean EqualitySortedCollectionOperations.locate_previous_element(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionPOATie.locate_next_element(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionPOATie.contains_element(Any element)
           
 boolean EqualitySequentialCollectionPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionPOATie.locate_first_element_with_value(Any element, Iterator where)
           
 void EqualitySequentialCollectionPOATie.add_element_as_first(Any element)
           
 void EqualitySequentialCollectionPOATie.add_element_as_previous(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionPOATie.locate_or_add_element(Any element)
           
 int EqualitySequentialCollectionPOATie.remove_all_occurrences(Any element)
           
 boolean EqualitySequentialCollectionPOATie.locate_last_element_with_value(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionPOATie.remove_element(Any element)
           
 boolean EqualitySequentialCollectionPOATie.locate_element(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionPOATie.add_element(Any element)
           
 void EqualitySequentialCollectionPOATie.add_element_as_last(Any element)
           
 void EqualitySequentialCollectionPOATie.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 void EqualitySequentialCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 void EqualitySequentialCollectionPOATie.add_element_at_position(int position, Any element)
           
 void EqualitySequentialCollectionPOATie.replace_last_element(Any element)
           
 boolean EqualitySequentialCollectionPOATie.contains_all_from(Collection collector)
           
 void EqualitySequentialCollectionPOATie.add_all_from(Collection collector)
           
 void EqualitySequentialCollectionPOATie.replace_element_at_position(int position, Any element)
           
 void EqualitySequentialCollectionPOATie.add_element_as_last_set_iterator(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionPOATie.locate_previous_element_with_value(Any element, Iterator where)
           
 int EqualitySequentialCollectionPOATie.number_of_occurrences(Any element)
           
 void EqualitySequentialCollectionPOATie.replace_first_element(Any element)
           
 boolean EqualitySequentialCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void EqualitySequentialCollectionPOATie.add_element_as_next(Any element, Iterator where)
           
 void EqualitySequentialCollectionPOATie.add_element_as_first_set_iterator(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionOperations.locate_first_element_with_value(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionOperations.locate_last_element_with_value(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionOperations.locate_previous_element_with_value(Any element, Iterator where)
           
 boolean EqualitySequencePOATie.locate_next_element(Any element, Iterator where)
           
 boolean EqualitySequencePOATie.contains_element(Any element)
           
 boolean EqualitySequencePOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean EqualitySequencePOATie.locate_first_element_with_value(Any element, Iterator where)
           
 void EqualitySequencePOATie.add_element_as_first(Any element)
           
 void EqualitySequencePOATie.add_element_as_previous(Any element, Iterator where)
           
 boolean EqualitySequencePOATie.locate_or_add_element(Any element)
           
 int EqualitySequencePOATie.remove_all_occurrences(Any element)
           
 boolean EqualitySequencePOATie.locate_last_element_with_value(Any element, Iterator where)
           
 boolean EqualitySequencePOATie.remove_element(Any element)
           
 boolean EqualitySequencePOATie.locate_element(Any element, Iterator where)
           
 boolean EqualitySequencePOATie.add_element(Any element)
           
 void EqualitySequencePOATie.add_element_as_last(Any element)
           
 void EqualitySequencePOATie.replace_element_at(Iterator where, Any element)
           
 void EqualitySequencePOATie.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 void EqualitySequencePOATie.add_element_at_position(int position, Any element)
           
 void EqualitySequencePOATie.replace_last_element(Any element)
           
 boolean EqualitySequencePOATie.contains_all_from(Collection collector)
           
 void EqualitySequencePOATie.add_all_from(Collection collector)
           
 void EqualitySequencePOATie.replace_element_at_position(int position, Any element)
           
 void EqualitySequencePOATie.add_element_as_last_set_iterator(Any element, Iterator where)
           
 boolean EqualitySequencePOATie.locate_previous_element_with_value(Any element, Iterator where)
           
 int EqualitySequencePOATie.number_of_occurrences(Any element)
           
 void EqualitySequencePOATie.replace_first_element(Any element)
           
 boolean EqualitySequencePOATie.add_element_set_iterator(Any element, Iterator where)
           
 void EqualitySequencePOATie.add_element_as_next(Any element, Iterator where)
           
 void EqualitySequencePOATie.add_element_as_first_set_iterator(Any element, Iterator where)
           
 boolean EqualityIteratorOperations.set_to_element_with_value(Any element)
           
 boolean EqualityIteratorOperations.set_to_next_element_with_value(Any element)
           
 boolean EqualityCollectionPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean EqualityCollectionPOATie.locate_element(Any element, Iterator where)
           
 boolean EqualityCollectionPOATie.remove_element(Any element)
           
 boolean EqualityCollectionPOATie.contains_element(Any element)
           
 boolean EqualityCollectionPOATie.add_element(Any element)
           
 boolean EqualityCollectionPOATie.locate_next_element(Any element, Iterator where)
           
 boolean EqualityCollectionPOATie.contains_all_from(Collection collector)
           
 boolean EqualityCollectionPOATie.locate_or_add_element(Any element)
           
 int EqualityCollectionPOATie.number_of_occurrences(Any element)
           
 boolean EqualityCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void EqualityCollectionPOATie.add_all_from(Collection collector)
           
 void EqualityCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 int EqualityCollectionPOATie.remove_all_occurrences(Any element)
           
 boolean EqualityCollectionOperations.contains_element(Any element)
           
 boolean EqualityCollectionOperations.contains_all_from(Collection collector)
           
 boolean EqualityCollectionOperations.locate_or_add_element(Any element)
           
 boolean EqualityCollectionOperations.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean EqualityCollectionOperations.locate_element(Any element, Iterator where)
           
 boolean EqualityCollectionOperations.locate_next_element(Any element, Iterator where)
           
 boolean EqualityCollectionOperations.remove_element(Any element)
           
 int EqualityCollectionOperations.remove_all_occurrences(Any element)
           
 int EqualityCollectionOperations.number_of_occurrences(Any element)
           
 void DequePOATie.enqueue_as_last(Any element)
           
 void DequePOATie.enqueue_as_first(Any element)
           
 void DequeOperations.enqueue_as_first(Any element)
           
 void DequeOperations.enqueue_as_last(Any element)
           
 boolean CollectionPOATie.add_element(Any element)
           
 void CollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean CollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void CollectionPOATie.add_all_from(Collection collector)
           
 boolean CollectionOperations.add_element(Any element)
           
 boolean CollectionOperations.add_element_set_iterator(Any element, Iterator where)
           
 void CollectionOperations.add_all_from(Collection collector)
           
 void CollectionOperations.replace_element_at(Iterator where, Any element)
           
 void CSequencePOATie.add_element_as_last(Any element)
           
 void CSequencePOATie.add_element_as_first(Any element)
           
 void CSequencePOATie.add_element_at_position(int position, Any element)
           
 void CSequencePOATie.add_element_as_next(Any element, Iterator where)
           
 void CSequencePOATie.replace_element_at_position(int position, Any element)
           
 void CSequencePOATie.replace_last_element(Any element)
           
 boolean CSequencePOATie.add_element(Any element)
           
 void CSequencePOATie.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 void CSequencePOATie.replace_first_element(Any element)
           
 void CSequencePOATie.add_element_as_last_set_iterator(Any element, Iterator where)
           
 boolean CSequencePOATie.add_element_set_iterator(Any element, Iterator where)
           
 void CSequencePOATie.add_element_as_first_set_iterator(Any element, Iterator where)
           
 void CSequencePOATie.add_element_as_previous(Any element, Iterator where)
           
 void CSequencePOATie.add_all_from(Collection collector)
           
 void CSequencePOATie.replace_element_at(Iterator where, Any element)
           
 

Constructors in org.omg.CosCollection with parameters of type ElementInvalid
ElementInvalidHolder(ElementInvalid initial)