Uses of Class
org.omg.CosCollection.IteratorInvalid

Packages that use IteratorInvalid
org.omg.CosCollection   
 

Uses of IteratorInvalid in org.omg.CosCollection
 

Fields in org.omg.CosCollection declared as IteratorInvalid
 IteratorInvalid IteratorInvalidHolder.value
           
 

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

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

Methods in org.omg.CosCollection that throw IteratorInvalid
 boolean SortedBagPOATie.locate_next_element(Any element, Iterator where)
           
 boolean SortedBagPOATie.locate_previous_element(Any element, Iterator where)
           
 boolean SortedBagPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean SortedBagPOATie.locate_element(Any element, Iterator where)
           
 void SortedBagPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SortedBagPOATie.locate_previous_different_element(Iterator where)
           
 boolean SortedBagPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean SortedBagPOATie.locate_first_element(Any element, Iterator where)
           
 void SortedBagPOATie.remove_element_at(Iterator where)
           
 boolean SortedBagPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean SortedBagPOATie.locate_last_element(Any element, Iterator where)
           
 boolean SortedBagPOATie.locate_next_different_element(Iterator where)
           
 boolean SortedSetPOATie.locate_next_element(Any element, Iterator where)
           
 boolean SortedSetPOATie.locate_previous_element(Any element, Iterator where)
           
 boolean SortedSetPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean SortedSetPOATie.locate_element(Any element, Iterator where)
           
 void SortedSetPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SortedSetPOATie.locate_previous_different_element(Iterator where)
           
 boolean SortedSetPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean SortedSetPOATie.locate_first_element(Any element, Iterator where)
           
 void SortedSetPOATie.remove_element_at(Iterator where)
           
 boolean SortedSetPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean SortedSetPOATie.locate_last_element(Any element, Iterator where)
           
 boolean SortedSetPOATie.locate_next_different_element(Iterator where)
           
 boolean SortedMapPOATie.locate_next_element(Any element, Iterator where)
           
 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_next_element_with_key(Any key, Iterator where)
           
 boolean SortedMapPOATie.locate_element_with_key(Any key, Iterator where)
           
 boolean SortedMapPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean SortedMapPOATie.locate_element(Any element, Iterator where)
           
 void SortedMapPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SortedMapPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean SortedMapPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean SortedMapPOATie.locate_next_element_with_different_key(Iterator where)
           
 void SortedMapPOATie.remove_element_at(Iterator where)
           
 boolean SortedMapPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean SortedMapPOATie.locate_next_different_element(Iterator where)
           
 boolean KeySortedBagPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedBagPOATie.locate_next_element_with_key(Any key, Iterator where)
           
 boolean KeySortedBagPOATie.locate_element_with_key(Any key, Iterator where)
           
 boolean KeySortedBagPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedBagPOATie.locate_first_element_with_key(Any key, Iterator where)
           
 void KeySortedBagPOATie.replace_element_at(Iterator where, Any element)
           
 boolean KeySortedBagPOATie.locate_previous_element_with_different_key(Iterator where)
           
 boolean KeySortedBagPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean KeySortedBagPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedBagPOATie.locate_next_element_with_different_key(Iterator where)
           
 boolean KeySortedBagPOATie.locate_last_element_with_key(Any key, Iterator where)
           
 void KeySortedBagPOATie.remove_element_at(Iterator where)
           
 boolean KeySortedBagPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean KeySortedBagPOATie.locate_previous_element_with_key(Any key, Iterator where)
           
 boolean KeySortedSetPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedSetPOATie.locate_next_element_with_key(Any key, Iterator where)
           
 boolean KeySortedSetPOATie.locate_element_with_key(Any key, Iterator where)
           
 boolean KeySortedSetPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedSetPOATie.locate_first_element_with_key(Any key, Iterator where)
           
 void KeySortedSetPOATie.replace_element_at(Iterator where, Any element)
           
 boolean KeySortedSetPOATie.locate_previous_element_with_different_key(Iterator where)
           
 boolean KeySortedSetPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean KeySortedSetPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedSetPOATie.locate_next_element_with_different_key(Iterator where)
           
 boolean KeySortedSetPOATie.locate_last_element_with_key(Any key, Iterator where)
           
 void KeySortedSetPOATie.remove_element_at(Iterator where)
           
 boolean KeySortedSetPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean KeySortedSetPOATie.locate_previous_element_with_key(Any key, Iterator where)
           
 boolean BagPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean BagPOATie.locate_element(Any element, Iterator where)
           
 boolean BagPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void BagPOATie.remove_element_at(Iterator where)
           
 boolean BagPOATie.locate_next_different_element(Iterator where)
           
 boolean BagPOATie.locate_next_element(Any element, Iterator where)
           
 boolean BagPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void BagPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SetPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean SetPOATie.locate_element(Any element, Iterator where)
           
 boolean SetPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void SetPOATie.remove_element_at(Iterator where)
           
 boolean SetPOATie.locate_next_different_element(Iterator where)
           
 boolean SetPOATie.locate_next_element(Any element, Iterator where)
           
 boolean SetPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void SetPOATie.replace_element_at(Iterator where, Any element)
           
 boolean MapPOATie.locate_next_element(Any element, Iterator where)
           
 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)
           
 boolean MapPOATie.locate_next_element_with_key(Any key, Iterator where)
           
 boolean MapPOATie.locate_element_with_key(Any key, Iterator where)
           
 boolean MapPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean MapPOATie.locate_element(Any element, Iterator where)
           
 void MapPOATie.replace_element_at(Iterator where, Any element)
           
 boolean MapPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean MapPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean MapPOATie.locate_next_element_with_different_key(Iterator where)
           
 void MapPOATie.remove_element_at(Iterator where)
           
 boolean MapPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean MapPOATie.locate_next_different_element(Iterator where)
           
 boolean KeyBagPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyBagPOATie.locate_next_element_with_different_key(Iterator where)
           
 boolean KeyBagPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void KeyBagPOATie.remove_element_at(Iterator where)
           
 boolean KeyBagPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyBagPOATie.locate_next_element_with_key(Any key, Iterator where)
           
 boolean KeyBagPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyBagPOATie.locate_element_with_key(Any key, Iterator where)
           
 boolean KeyBagPOATie.add_element_set_iterator(Any element, Iterator where)
           
 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.locate_next_element_with_different_key(Iterator where)
           
 boolean KeySetPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void KeySetPOATie.remove_element_at(Iterator where)
           
 boolean KeySetPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySetPOATie.locate_next_element_with_key(Any key, Iterator where)
           
 boolean KeySetPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySetPOATie.locate_element_with_key(Any key, Iterator where)
           
 boolean KeySetPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void KeySetPOATie.replace_element_at(Iterator where, Any element)
           
 boolean EqualityKeySortedCollectionPOATie.locate_next_element(Any element, Iterator where)
           
 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_next_element_with_key(Any key, Iterator where)
           
 boolean EqualityKeySortedCollectionPOATie.locate_element_with_key(Any key, Iterator where)
           
 boolean EqualityKeySortedCollectionPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean EqualityKeySortedCollectionPOATie.locate_element(Any element, Iterator where)
           
 void EqualityKeySortedCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean EqualityKeySortedCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean EqualityKeySortedCollectionPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean EqualityKeySortedCollectionPOATie.locate_next_element_with_different_key(Iterator where)
           
 void EqualityKeySortedCollectionPOATie.remove_element_at(Iterator where)
           
 boolean EqualityKeySortedCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean EqualityKeySortedCollectionPOATie.locate_next_different_element(Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.locate_next_element(Any element, Iterator where)
           
 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_next_element_with_key(Any key, Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.locate_element_with_key(Any key, Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.locate_element(Any element, Iterator where)
           
 void _EqualityKeySortedCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _EqualityKeySortedCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _EqualityKeySortedCollectionStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.locate_next_element_with_different_key(Iterator where)
           
 void _EqualityKeySortedCollectionStub.remove_element_at(Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.locate_next_different_element(Iterator where)
           
 boolean KeySortedCollectionPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedCollectionPOATie.locate_next_element_with_key(Any key, Iterator where)
           
 boolean KeySortedCollectionPOATie.locate_element_with_key(Any key, Iterator where)
           
 boolean KeySortedCollectionPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedCollectionPOATie.locate_first_element_with_key(Any key, Iterator where)
           
 void KeySortedCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean KeySortedCollectionPOATie.locate_previous_element_with_different_key(Iterator where)
           
 boolean KeySortedCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean KeySortedCollectionPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeySortedCollectionPOATie.locate_next_element_with_different_key(Iterator where)
           
 boolean KeySortedCollectionPOATie.locate_last_element_with_key(Any key, Iterator where)
           
 void KeySortedCollectionPOATie.remove_element_at(Iterator where)
           
 boolean KeySortedCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean KeySortedCollectionPOATie.locate_previous_element_with_key(Any key, Iterator where)
           
 boolean _KeySortedCollectionStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedCollectionStub.locate_next_element_with_key(Any key, Iterator where)
           
 boolean _KeySortedCollectionStub.locate_element_with_key(Any key, Iterator where)
           
 boolean _KeySortedCollectionStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedCollectionStub.locate_first_element_with_key(Any key, Iterator where)
           
 void _KeySortedCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _KeySortedCollectionStub.locate_previous_element_with_different_key(Iterator where)
           
 boolean _KeySortedCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _KeySortedCollectionStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedCollectionStub.locate_next_element_with_different_key(Iterator where)
           
 boolean _KeySortedCollectionStub.locate_last_element_with_key(Any key, Iterator where)
           
 void _KeySortedCollectionStub.remove_element_at(Iterator where)
           
 boolean _KeySortedCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedCollectionStub.locate_previous_element_with_key(Any key, Iterator where)
           
 boolean EqualityKeyCollectionPOATie.locate_next_element(Any element, Iterator where)
           
 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_next_element_with_key(Any key, Iterator where)
           
 boolean EqualityKeyCollectionPOATie.locate_element_with_key(Any key, Iterator where)
           
 boolean EqualityKeyCollectionPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean EqualityKeyCollectionPOATie.locate_element(Any element, Iterator where)
           
 void EqualityKeyCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean EqualityKeyCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean EqualityKeyCollectionPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean EqualityKeyCollectionPOATie.locate_next_element_with_different_key(Iterator where)
           
 void EqualityKeyCollectionPOATie.remove_element_at(Iterator where)
           
 boolean EqualityKeyCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean EqualityKeyCollectionPOATie.locate_next_different_element(Iterator where)
           
 boolean _EqualityKeyCollectionStub.locate_next_element(Any element, Iterator where)
           
 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_next_element_with_key(Any key, Iterator where)
           
 boolean _EqualityKeyCollectionStub.locate_element_with_key(Any key, Iterator where)
           
 boolean _EqualityKeyCollectionStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _EqualityKeyCollectionStub.locate_element(Any element, Iterator where)
           
 void _EqualityKeyCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _EqualityKeyCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _EqualityKeyCollectionStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _EqualityKeyCollectionStub.locate_next_element_with_different_key(Iterator where)
           
 void _EqualityKeyCollectionStub.remove_element_at(Iterator where)
           
 boolean _EqualityKeyCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _EqualityKeyCollectionStub.locate_next_different_element(Iterator where)
           
 boolean KeyCollectionPOATie.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyCollectionPOATie.locate_next_element_with_different_key(Iterator where)
           
 boolean KeyCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void KeyCollectionPOATie.remove_element_at(Iterator where)
           
 boolean KeyCollectionPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyCollectionPOATie.locate_next_element_with_key(Any key, 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)
           
 boolean KeyCollectionPOATie.locate_element_with_key(Any key, Iterator where)
           
 void KeyCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 void EqualitySequentialIteratorPOATie.add_n_elements_as_next_set_iterator(Any[] elements)
           
 boolean EqualitySequentialIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean EqualitySequentialIteratorPOATie.add_element_as_previous_set_iterator(Any element)
           
 boolean EqualitySequentialIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean EqualitySequentialIteratorPOATie.set_to_next_nth_element(int n)
           
 void EqualitySequentialIteratorPOATie.replace_element(Any element)
           
 void EqualitySequentialIteratorPOATie.add_n_elements_as_previous_set_iterator(Any[] elements)
           
 void EqualitySequentialIteratorPOATie.assign(Iterator from_where)
           
 int EqualitySequentialIteratorPOATie.position()
           
 boolean EqualitySequentialIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean EqualitySequentialIteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean EqualitySequentialIteratorPOATie.set_to_previous_element()
           
 boolean EqualitySequentialIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualitySequentialIteratorPOATie.set_to_next_element()
           
 boolean EqualitySequentialIteratorPOATie.set_to_nth_previous_element(int n)
           
 boolean EqualitySequentialIteratorPOATie.add_element_as_next_set_iterator(Any element)
           
 boolean EqualitySequentialIteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 boolean EqualitySequentialIteratorPOATie.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean EqualitySequentialIteratorPOATie.remove_element_set_to_previous()
           
 void EqualitySequentialIteratorPOATie.remove_element()
           
 boolean EqualitySequentialIteratorPOATie.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean EqualitySequentialIteratorPOATie.is_equal(Iterator test)
           
 boolean EqualitySequentialIteratorPOATie.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean EqualitySequentialIteratorPOATie.set_to_next_element_with_value(Any element)
           
 boolean EqualitySequentialIteratorPOATie.remove_element_set_to_next()
           
 boolean EqualitySequentialIteratorPOATie.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean EqualitySequentialIteratorPOATie.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean EqualitySequentialIteratorPOATie.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean EqualitySequentialIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean EqualitySequentialIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean EqualitySequentialIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualitySequentialIteratorPOATie.set_to_next_element_with_different_value()
           
 boolean EqualitySequentialIteratorPOATie.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean EqualitySequentialIteratorPOATie.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 void _EqualitySequentialIteratorStub.add_n_elements_as_next_set_iterator(Any[] elements)
           
 boolean _EqualitySequentialIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _EqualitySequentialIteratorStub.add_element_as_previous_set_iterator(Any element)
           
 boolean _EqualitySequentialIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean _EqualitySequentialIteratorStub.set_to_next_nth_element(int n)
           
 void _EqualitySequentialIteratorStub.replace_element(Any element)
           
 void _EqualitySequentialIteratorStub.add_n_elements_as_previous_set_iterator(Any[] elements)
           
 void _EqualitySequentialIteratorStub.assign(Iterator from_where)
           
 int _EqualitySequentialIteratorStub.position()
           
 boolean _EqualitySequentialIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _EqualitySequentialIteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _EqualitySequentialIteratorStub.set_to_previous_element()
           
 boolean _EqualitySequentialIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualitySequentialIteratorStub.set_to_next_element()
           
 boolean _EqualitySequentialIteratorStub.set_to_nth_previous_element(int n)
           
 boolean _EqualitySequentialIteratorStub.add_element_as_next_set_iterator(Any element)
           
 boolean _EqualitySequentialIteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 boolean _EqualitySequentialIteratorStub.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean _EqualitySequentialIteratorStub.remove_element_set_to_previous()
           
 void _EqualitySequentialIteratorStub.remove_element()
           
 boolean _EqualitySequentialIteratorStub.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean _EqualitySequentialIteratorStub.is_equal(Iterator test)
           
 boolean _EqualitySequentialIteratorStub.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean _EqualitySequentialIteratorStub.set_to_next_element_with_value(Any element)
           
 boolean _EqualitySequentialIteratorStub.remove_element_set_to_next()
           
 boolean _EqualitySequentialIteratorStub.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean _EqualitySequentialIteratorStub.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean _EqualitySequentialIteratorStub.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _EqualitySequentialIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _EqualitySequentialIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _EqualitySequentialIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualitySequentialIteratorStub.set_to_next_element_with_different_value()
           
 boolean _EqualitySequentialIteratorStub.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean _EqualitySequentialIteratorStub.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean EqualityKeySortedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean EqualityKeySortedIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_next_nth_element(int n)
           
 void EqualityKeySortedIteratorPOATie.replace_element(Any element)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_previous_element_with_key(Any key)
           
 void EqualityKeySortedIteratorPOATie.assign(Iterator from_where)
           
 int EqualityKeySortedIteratorPOATie.position()
           
 boolean EqualityKeySortedIteratorPOATie.set_to_next_element_with_different_key()
           
 boolean EqualityKeySortedIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean EqualityKeySortedIteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean EqualityKeySortedIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_previous_element()
           
 boolean EqualityKeySortedIteratorPOATie.set_to_next_element()
           
 boolean EqualityKeySortedIteratorPOATie.set_to_nth_previous_element(int n)
           
 boolean EqualityKeySortedIteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 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.remove_element_set_to_previous()
           
 void EqualityKeySortedIteratorPOATie.remove_element()
           
 boolean EqualityKeySortedIteratorPOATie.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean EqualityKeySortedIteratorPOATie.is_equal(Iterator test)
           
 boolean EqualityKeySortedIteratorPOATie.retrieve_next_n_keys(AnySequenceHolder keys)
           
 boolean EqualityKeySortedIteratorPOATie.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_next_element_with_value(Any element)
           
 boolean EqualityKeySortedIteratorPOATie.remove_element_set_to_next()
           
 boolean EqualityKeySortedIteratorPOATie.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean EqualityKeySortedIteratorPOATie.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean EqualityKeySortedIteratorPOATie.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean EqualityKeySortedIteratorPOATie.retrieve_previous_n_keys(AnySequenceHolder keys)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_previous_element_with_different_key()
           
 boolean EqualityKeySortedIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean EqualityKeySortedIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean EqualityKeySortedIteratorPOATie.retrieve_key(AnyHolder key)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_next_element_with_key(Any key)
           
 boolean EqualityKeySortedIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_next_element_with_different_value()
           
 boolean EqualityKeySortedIteratorPOATie.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean EqualityKeySortedIteratorPOATie.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean EqualityKeySortedIteratorPOATie.set_to_previous_element_with_different_value()
           
 boolean _EqualityKeySortedIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _EqualityKeySortedIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean _EqualityKeySortedIteratorStub.set_to_next_nth_element(int n)
           
 void _EqualityKeySortedIteratorStub.replace_element(Any element)
           
 boolean _EqualityKeySortedIteratorStub.set_to_previous_element_with_key(Any key)
           
 void _EqualityKeySortedIteratorStub.assign(Iterator from_where)
           
 int _EqualityKeySortedIteratorStub.position()
           
 boolean _EqualityKeySortedIteratorStub.set_to_next_element_with_different_key()
           
 boolean _EqualityKeySortedIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _EqualityKeySortedIteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _EqualityKeySortedIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualityKeySortedIteratorStub.set_to_previous_element()
           
 boolean _EqualityKeySortedIteratorStub.set_to_next_element()
           
 boolean _EqualityKeySortedIteratorStub.set_to_nth_previous_element(int n)
           
 boolean _EqualityKeySortedIteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 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.remove_element_set_to_previous()
           
 void _EqualityKeySortedIteratorStub.remove_element()
           
 boolean _EqualityKeySortedIteratorStub.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean _EqualityKeySortedIteratorStub.is_equal(Iterator test)
           
 boolean _EqualityKeySortedIteratorStub.retrieve_next_n_keys(AnySequenceHolder keys)
           
 boolean _EqualityKeySortedIteratorStub.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean _EqualityKeySortedIteratorStub.set_to_next_element_with_value(Any element)
           
 boolean _EqualityKeySortedIteratorStub.remove_element_set_to_next()
           
 boolean _EqualityKeySortedIteratorStub.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean _EqualityKeySortedIteratorStub.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean _EqualityKeySortedIteratorStub.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _EqualityKeySortedIteratorStub.retrieve_previous_n_keys(AnySequenceHolder keys)
           
 boolean _EqualityKeySortedIteratorStub.set_to_previous_element_with_different_key()
           
 boolean _EqualityKeySortedIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _EqualityKeySortedIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _EqualityKeySortedIteratorStub.retrieve_key(AnyHolder key)
           
 boolean _EqualityKeySortedIteratorStub.set_to_next_element_with_key(Any key)
           
 boolean _EqualityKeySortedIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualityKeySortedIteratorStub.set_to_next_element_with_different_value()
           
 boolean _EqualityKeySortedIteratorStub.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean _EqualityKeySortedIteratorStub.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean _EqualityKeySortedIteratorStub.set_to_previous_element_with_different_value()
           
 boolean EqualitySortedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean EqualitySortedIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean EqualitySortedIteratorPOATie.set_to_next_nth_element(int n)
           
 void EqualitySortedIteratorPOATie.replace_element(Any element)
           
 void EqualitySortedIteratorPOATie.assign(Iterator from_where)
           
 int EqualitySortedIteratorPOATie.position()
           
 boolean EqualitySortedIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean EqualitySortedIteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean EqualitySortedIteratorPOATie.set_to_previous_element()
           
 boolean EqualitySortedIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualitySortedIteratorPOATie.set_to_next_element()
           
 boolean EqualitySortedIteratorPOATie.set_to_nth_previous_element(int n)
           
 boolean EqualitySortedIteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 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.remove_element_set_to_previous()
           
 void EqualitySortedIteratorPOATie.remove_element()
           
 boolean EqualitySortedIteratorPOATie.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean EqualitySortedIteratorPOATie.is_equal(Iterator test)
           
 boolean EqualitySortedIteratorPOATie.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean EqualitySortedIteratorPOATie.set_to_next_element_with_value(Any element)
           
 boolean EqualitySortedIteratorPOATie.remove_element_set_to_next()
           
 boolean EqualitySortedIteratorPOATie.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean EqualitySortedIteratorPOATie.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean EqualitySortedIteratorPOATie.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean EqualitySortedIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean EqualitySortedIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean EqualitySortedIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualitySortedIteratorPOATie.set_to_next_element_with_different_value()
           
 boolean EqualitySortedIteratorPOATie.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean EqualitySortedIteratorPOATie.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean EqualitySortedIteratorPOATie.set_to_previous_element_with_different_value()
           
 boolean _EqualitySortedIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _EqualitySortedIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean _EqualitySortedIteratorStub.set_to_next_nth_element(int n)
           
 void _EqualitySortedIteratorStub.replace_element(Any element)
           
 void _EqualitySortedIteratorStub.assign(Iterator from_where)
           
 int _EqualitySortedIteratorStub.position()
           
 boolean _EqualitySortedIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _EqualitySortedIteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _EqualitySortedIteratorStub.set_to_previous_element()
           
 boolean _EqualitySortedIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualitySortedIteratorStub.set_to_next_element()
           
 boolean _EqualitySortedIteratorStub.set_to_nth_previous_element(int n)
           
 boolean _EqualitySortedIteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 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.remove_element_set_to_previous()
           
 void _EqualitySortedIteratorStub.remove_element()
           
 boolean _EqualitySortedIteratorStub.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean _EqualitySortedIteratorStub.is_equal(Iterator test)
           
 boolean _EqualitySortedIteratorStub.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean _EqualitySortedIteratorStub.set_to_next_element_with_value(Any element)
           
 boolean _EqualitySortedIteratorStub.remove_element_set_to_next()
           
 boolean _EqualitySortedIteratorStub.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _EqualitySortedIteratorStub.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean _EqualitySortedIteratorStub.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean _EqualitySortedIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _EqualitySortedIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _EqualitySortedIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualitySortedIteratorStub.set_to_next_element_with_different_value()
           
 boolean _EqualitySortedIteratorStub.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean _EqualitySortedIteratorStub.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean _EqualitySortedIteratorStub.set_to_previous_element_with_different_value()
           
 boolean KeySortedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean KeySortedIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean KeySortedIteratorPOATie.set_to_next_nth_element(int n)
           
 void KeySortedIteratorPOATie.replace_element(Any element)
           
 boolean KeySortedIteratorPOATie.set_to_previous_element_with_key(Any key)
           
 void KeySortedIteratorPOATie.assign(Iterator from_where)
           
 int KeySortedIteratorPOATie.position()
           
 boolean KeySortedIteratorPOATie.set_to_next_element_with_different_key()
           
 boolean KeySortedIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean KeySortedIteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean KeySortedIteratorPOATie.set_to_previous_element()
           
 boolean KeySortedIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean KeySortedIteratorPOATie.set_to_next_element()
           
 boolean KeySortedIteratorPOATie.set_to_nth_previous_element(int n)
           
 boolean KeySortedIteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 boolean KeySortedIteratorPOATie.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean KeySortedIteratorPOATie.remove_element_set_to_previous()
           
 void KeySortedIteratorPOATie.remove_element()
           
 boolean KeySortedIteratorPOATie.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean KeySortedIteratorPOATie.is_equal(Iterator test)
           
 boolean KeySortedIteratorPOATie.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean KeySortedIteratorPOATie.retrieve_next_n_keys(AnySequenceHolder keys)
           
 boolean KeySortedIteratorPOATie.remove_element_set_to_next()
           
 boolean KeySortedIteratorPOATie.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean KeySortedIteratorPOATie.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean KeySortedIteratorPOATie.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean KeySortedIteratorPOATie.retrieve_previous_n_keys(AnySequenceHolder keys)
           
 boolean KeySortedIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean KeySortedIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean KeySortedIteratorPOATie.set_to_previous_element_with_different_key()
           
 boolean KeySortedIteratorPOATie.retrieve_key(AnyHolder key)
           
 boolean KeySortedIteratorPOATie.set_to_next_element_with_key(Any key)
           
 boolean KeySortedIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean KeySortedIteratorPOATie.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean KeySortedIteratorPOATie.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean _KeySortedIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _KeySortedIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean _KeySortedIteratorStub.set_to_next_nth_element(int n)
           
 void _KeySortedIteratorStub.replace_element(Any element)
           
 boolean _KeySortedIteratorStub.set_to_previous_element_with_key(Any key)
           
 void _KeySortedIteratorStub.assign(Iterator from_where)
           
 int _KeySortedIteratorStub.position()
           
 boolean _KeySortedIteratorStub.set_to_next_element_with_different_key()
           
 boolean _KeySortedIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _KeySortedIteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _KeySortedIteratorStub.set_to_previous_element()
           
 boolean _KeySortedIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _KeySortedIteratorStub.set_to_next_element()
           
 boolean _KeySortedIteratorStub.set_to_nth_previous_element(int n)
           
 boolean _KeySortedIteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 boolean _KeySortedIteratorStub.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean _KeySortedIteratorStub.remove_element_set_to_previous()
           
 void _KeySortedIteratorStub.remove_element()
           
 boolean _KeySortedIteratorStub.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean _KeySortedIteratorStub.is_equal(Iterator test)
           
 boolean _KeySortedIteratorStub.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean _KeySortedIteratorStub.retrieve_next_n_keys(AnySequenceHolder keys)
           
 boolean _KeySortedIteratorStub.remove_element_set_to_next()
           
 boolean _KeySortedIteratorStub.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _KeySortedIteratorStub.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean _KeySortedIteratorStub.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean _KeySortedIteratorStub.retrieve_previous_n_keys(AnySequenceHolder keys)
           
 boolean _KeySortedIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _KeySortedIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _KeySortedIteratorStub.set_to_previous_element_with_different_key()
           
 boolean _KeySortedIteratorStub.retrieve_key(AnyHolder key)
           
 boolean _KeySortedIteratorStub.set_to_next_element_with_key(Any key)
           
 boolean _KeySortedIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _KeySortedIteratorStub.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean _KeySortedIteratorStub.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean KeySortedIteratorOperations.set_to_previous_element_with_key(Any key)
           
 boolean KeySortedIteratorOperations.set_to_previous_element_with_different_key()
           
 boolean KeySortedIteratorOperations.retrieve_previous_n_keys(AnySequenceHolder keys)
           
 boolean SortedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean SortedIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean SortedIteratorPOATie.set_to_next_nth_element(int n)
           
 void SortedIteratorPOATie.replace_element(Any element)
           
 void SortedIteratorPOATie.assign(Iterator from_where)
           
 int SortedIteratorPOATie.position()
           
 boolean SortedIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean SortedIteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean SortedIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean SortedIteratorPOATie.set_to_previous_element()
           
 boolean SortedIteratorPOATie.set_to_next_element()
           
 boolean SortedIteratorPOATie.set_to_nth_previous_element(int n)
           
 boolean SortedIteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 boolean SortedIteratorPOATie.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean SortedIteratorPOATie.remove_element_set_to_previous()
           
 void SortedIteratorPOATie.remove_element()
           
 boolean SortedIteratorPOATie.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean SortedIteratorPOATie.is_equal(Iterator test)
           
 boolean SortedIteratorPOATie.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean SortedIteratorPOATie.remove_element_set_to_next()
           
 boolean SortedIteratorPOATie.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean SortedIteratorPOATie.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean SortedIteratorPOATie.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean SortedIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean SortedIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean SortedIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean SortedIteratorPOATie.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean SortedIteratorPOATie.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean _SortedIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _SortedIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean _SortedIteratorStub.set_to_next_nth_element(int n)
           
 void _SortedIteratorStub.replace_element(Any element)
           
 void _SortedIteratorStub.assign(Iterator from_where)
           
 int _SortedIteratorStub.position()
           
 boolean _SortedIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _SortedIteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _SortedIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _SortedIteratorStub.set_to_previous_element()
           
 boolean _SortedIteratorStub.set_to_next_element()
           
 boolean _SortedIteratorStub.set_to_nth_previous_element(int n)
           
 boolean _SortedIteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 boolean _SortedIteratorStub.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean _SortedIteratorStub.remove_element_set_to_previous()
           
 void _SortedIteratorStub.remove_element()
           
 boolean _SortedIteratorStub.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean _SortedIteratorStub.is_equal(Iterator test)
           
 boolean _SortedIteratorStub.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean _SortedIteratorStub.remove_element_set_to_next()
           
 boolean _SortedIteratorStub.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean _SortedIteratorStub.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean _SortedIteratorStub.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _SortedIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _SortedIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _SortedIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _SortedIteratorStub.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean _SortedIteratorStub.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 void EqualityKeyIteratorPOATie.replace_element(Any element)
           
 boolean EqualityKeyIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 void EqualityKeyIteratorPOATie.assign(Iterator from_where)
           
 boolean EqualityKeyIteratorPOATie.retrieve_key(AnyHolder key)
           
 boolean EqualityKeyIteratorPOATie.remove_element_set_to_next()
           
 boolean EqualityKeyIteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean EqualityKeyIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualityKeyIteratorPOATie.set_to_next_element_with_key(Any key)
           
 boolean EqualityKeyIteratorPOATie.set_to_next_element_with_different_key()
           
 boolean EqualityKeyIteratorPOATie.is_equal(Iterator test)
           
 boolean EqualityKeyIteratorPOATie.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean EqualityKeyIteratorPOATie.set_to_next_nth_element(int n)
           
 boolean EqualityKeyIteratorPOATie.retrieve_next_n_keys(AnySequenceHolder keys)
           
 boolean EqualityKeyIteratorPOATie.set_to_next_element_with_value(Any element)
           
 boolean EqualityKeyIteratorPOATie.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean EqualityKeyIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean EqualityKeyIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean EqualityKeyIteratorPOATie.set_to_next_element()
           
 void EqualityKeyIteratorPOATie.remove_element()
           
 boolean EqualityKeyIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean EqualityKeyIteratorPOATie.set_to_next_element_with_different_value()
           
 boolean EqualityKeyIteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 void _EqualityKeyIteratorStub.replace_element(Any element)
           
 boolean _EqualityKeyIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 void _EqualityKeyIteratorStub.assign(Iterator from_where)
           
 boolean _EqualityKeyIteratorStub.retrieve_key(AnyHolder key)
           
 boolean _EqualityKeyIteratorStub.remove_element_set_to_next()
           
 boolean _EqualityKeyIteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _EqualityKeyIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualityKeyIteratorStub.set_to_next_element_with_key(Any key)
           
 boolean _EqualityKeyIteratorStub.set_to_next_element_with_different_key()
           
 boolean _EqualityKeyIteratorStub.is_equal(Iterator test)
           
 boolean _EqualityKeyIteratorStub.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean _EqualityKeyIteratorStub.set_to_next_nth_element(int n)
           
 boolean _EqualityKeyIteratorStub.retrieve_next_n_keys(AnySequenceHolder keys)
           
 boolean _EqualityKeyIteratorStub.set_to_next_element_with_value(Any element)
           
 boolean _EqualityKeyIteratorStub.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean _EqualityKeyIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _EqualityKeyIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _EqualityKeyIteratorStub.set_to_next_element()
           
 void _EqualityKeyIteratorStub.remove_element()
           
 boolean _EqualityKeyIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _EqualityKeyIteratorStub.set_to_next_element_with_different_value()
           
 boolean _EqualityKeyIteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 void EqualityIteratorPOATie.replace_element(Any element)
           
 boolean EqualityIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 void EqualityIteratorPOATie.assign(Iterator from_where)
           
 boolean EqualityIteratorPOATie.remove_element_set_to_next()
           
 boolean EqualityIteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean EqualityIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualityIteratorPOATie.is_equal(Iterator test)
           
 boolean EqualityIteratorPOATie.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean EqualityIteratorPOATie.set_to_next_nth_element(int n)
           
 boolean EqualityIteratorPOATie.set_to_next_element_with_value(Any element)
           
 boolean EqualityIteratorPOATie.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean EqualityIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean EqualityIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean EqualityIteratorPOATie.set_to_next_element()
           
 void EqualityIteratorPOATie.remove_element()
           
 boolean EqualityIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean EqualityIteratorPOATie.set_to_next_element_with_different_value()
           
 boolean EqualityIteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 void _EqualityIteratorStub.replace_element(Any element)
           
 boolean _EqualityIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 void _EqualityIteratorStub.assign(Iterator from_where)
           
 boolean _EqualityIteratorStub.remove_element_set_to_next()
           
 boolean _EqualityIteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _EqualityIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualityIteratorStub.is_equal(Iterator test)
           
 boolean _EqualityIteratorStub.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean _EqualityIteratorStub.set_to_next_nth_element(int n)
           
 boolean _EqualityIteratorStub.set_to_next_element_with_value(Any element)
           
 boolean _EqualityIteratorStub.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean _EqualityIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _EqualityIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _EqualityIteratorStub.set_to_next_element()
           
 void _EqualityIteratorStub.remove_element()
           
 boolean _EqualityIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _EqualityIteratorStub.set_to_next_element_with_different_value()
           
 boolean _EqualityIteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 void KeyIteratorPOATie.replace_element(Any element)
           
 boolean KeyIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 void KeyIteratorPOATie.assign(Iterator from_where)
           
 boolean KeyIteratorPOATie.retrieve_key(AnyHolder key)
           
 boolean KeyIteratorPOATie.remove_element_set_to_next()
           
 boolean KeyIteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean KeyIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean KeyIteratorPOATie.set_to_next_element_with_different_key()
           
 boolean KeyIteratorPOATie.set_to_next_element_with_key(Any key)
           
 boolean KeyIteratorPOATie.is_equal(Iterator test)
           
 boolean KeyIteratorPOATie.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean KeyIteratorPOATie.set_to_next_nth_element(int n)
           
 boolean KeyIteratorPOATie.retrieve_next_n_keys(AnySequenceHolder keys)
           
 boolean KeyIteratorPOATie.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean KeyIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean KeyIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean KeyIteratorPOATie.set_to_next_element()
           
 void KeyIteratorPOATie.remove_element()
           
 boolean KeyIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean KeyIteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 void _KeyIteratorStub.replace_element(Any element)
           
 boolean _KeyIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 void _KeyIteratorStub.assign(Iterator from_where)
           
 boolean _KeyIteratorStub.retrieve_key(AnyHolder key)
           
 boolean _KeyIteratorStub.remove_element_set_to_next()
           
 boolean _KeyIteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _KeyIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _KeyIteratorStub.set_to_next_element_with_different_key()
           
 boolean _KeyIteratorStub.set_to_next_element_with_key(Any key)
           
 boolean _KeyIteratorStub.is_equal(Iterator test)
           
 boolean _KeyIteratorStub.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean _KeyIteratorStub.set_to_next_nth_element(int n)
           
 boolean _KeyIteratorStub.retrieve_next_n_keys(AnySequenceHolder keys)
           
 boolean _KeyIteratorStub.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean _KeyIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _KeyIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _KeyIteratorStub.set_to_next_element()
           
 void _KeyIteratorStub.remove_element()
           
 boolean _KeyIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _KeyIteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 boolean KeyIteratorOperations.set_to_next_element_with_key(Any key)
           
 boolean KeyIteratorOperations.set_to_next_element_with_different_key()
           
 boolean KeyIteratorOperations.retrieve_key(AnyHolder key)
           
 boolean KeyIteratorOperations.retrieve_next_n_keys(AnySequenceHolder keys)
           
 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)
           
 boolean SequentialIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean SequentialIteratorPOATie.set_to_next_nth_element(int n)
           
 void SequentialIteratorPOATie.replace_element(Any element)
           
 void SequentialIteratorPOATie.add_n_elements_as_previous_set_iterator(Any[] elements)
           
 void SequentialIteratorPOATie.assign(Iterator from_where)
           
 int SequentialIteratorPOATie.position()
           
 boolean SequentialIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean SequentialIteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean SequentialIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean SequentialIteratorPOATie.set_to_previous_element()
           
 boolean SequentialIteratorPOATie.set_to_next_element()
           
 boolean SequentialIteratorPOATie.set_to_nth_previous_element(int n)
           
 boolean SequentialIteratorPOATie.add_element_as_next_set_iterator(Any element)
           
 boolean SequentialIteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 boolean SequentialIteratorPOATie.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean SequentialIteratorPOATie.remove_element_set_to_previous()
           
 void SequentialIteratorPOATie.remove_element()
           
 boolean SequentialIteratorPOATie.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean SequentialIteratorPOATie.is_equal(Iterator test)
           
 boolean SequentialIteratorPOATie.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean SequentialIteratorPOATie.remove_element_set_to_next()
           
 boolean SequentialIteratorPOATie.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean SequentialIteratorPOATie.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean SequentialIteratorPOATie.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean SequentialIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean SequentialIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean SequentialIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean SequentialIteratorPOATie.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean SequentialIteratorPOATie.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 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)
           
 boolean _SequentialIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean _SequentialIteratorStub.set_to_next_nth_element(int n)
           
 void _SequentialIteratorStub.replace_element(Any element)
           
 void _SequentialIteratorStub.add_n_elements_as_previous_set_iterator(Any[] elements)
           
 void _SequentialIteratorStub.assign(Iterator from_where)
           
 int _SequentialIteratorStub.position()
           
 boolean _SequentialIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _SequentialIteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _SequentialIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _SequentialIteratorStub.set_to_previous_element()
           
 boolean _SequentialIteratorStub.set_to_next_element()
           
 boolean _SequentialIteratorStub.set_to_nth_previous_element(int n)
           
 boolean _SequentialIteratorStub.add_element_as_next_set_iterator(Any element)
           
 boolean _SequentialIteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 boolean _SequentialIteratorStub.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 boolean _SequentialIteratorStub.remove_element_set_to_previous()
           
 void _SequentialIteratorStub.remove_element()
           
 boolean _SequentialIteratorStub.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean _SequentialIteratorStub.is_equal(Iterator test)
           
 boolean _SequentialIteratorStub.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean _SequentialIteratorStub.remove_element_set_to_next()
           
 boolean _SequentialIteratorStub.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _SequentialIteratorStub.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean _SequentialIteratorStub.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean _SequentialIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _SequentialIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _SequentialIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _SequentialIteratorStub.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean _SequentialIteratorStub.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean OrderedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean OrderedIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean OrderedIteratorPOATie.set_to_next_nth_element(int n)
           
 void OrderedIteratorPOATie.replace_element(Any element)
           
 void OrderedIteratorPOATie.assign(Iterator from_where)
           
 int OrderedIteratorPOATie.position()
           
 boolean OrderedIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean OrderedIteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean OrderedIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean OrderedIteratorPOATie.set_to_previous_element()
           
 boolean OrderedIteratorPOATie.set_to_next_element()
           
 boolean OrderedIteratorPOATie.set_to_nth_previous_element(int n)
           
 boolean OrderedIteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 boolean OrderedIteratorPOATie.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 void OrderedIteratorPOATie.remove_element()
           
 boolean OrderedIteratorPOATie.remove_element_set_to_previous()
           
 boolean OrderedIteratorPOATie.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean OrderedIteratorPOATie.is_equal(Iterator test)
           
 boolean OrderedIteratorPOATie.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean OrderedIteratorPOATie.remove_element_set_to_next()
           
 boolean OrderedIteratorPOATie.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean OrderedIteratorPOATie.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean OrderedIteratorPOATie.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean OrderedIteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean OrderedIteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean OrderedIteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean OrderedIteratorPOATie.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean OrderedIteratorPOATie.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean _SortedSetStub.locate_next_element(Any element, Iterator where)
           
 boolean _SortedSetStub.locate_previous_element(Any element, Iterator where)
           
 boolean _SortedSetStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _SortedSetStub.locate_element(Any element, Iterator where)
           
 void _SortedSetStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedSetStub.locate_previous_different_element(Iterator where)
           
 boolean _SortedSetStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _SortedSetStub.locate_first_element(Any element, Iterator where)
           
 void _SortedSetStub.remove_element_at(Iterator where)
           
 boolean _SortedSetStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _SortedSetStub.locate_last_element(Any element, Iterator where)
           
 boolean _SortedSetStub.locate_next_different_element(Iterator where)
           
 boolean _SortedRelationStub.locate_next_element(Any element, Iterator where)
           
 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_next_element_with_key(Any key, Iterator where)
           
 boolean _SortedRelationStub.locate_element_with_key(Any key, Iterator where)
           
 boolean _SortedRelationStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _SortedRelationStub.locate_element(Any element, Iterator where)
           
 void _SortedRelationStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedRelationStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _SortedRelationStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _SortedRelationStub.locate_next_element_with_different_key(Iterator where)
           
 void _SortedRelationStub.remove_element_at(Iterator where)
           
 boolean _SortedRelationStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _SortedRelationStub.locate_next_different_element(Iterator where)
           
 boolean _SortedMapStub.locate_next_element(Any element, Iterator where)
           
 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_next_element_with_key(Any key, Iterator where)
           
 boolean _SortedMapStub.locate_element_with_key(Any key, Iterator where)
           
 boolean _SortedMapStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _SortedMapStub.locate_element(Any element, Iterator where)
           
 void _SortedMapStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedMapStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _SortedMapStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _SortedMapStub.locate_next_element_with_different_key(Iterator where)
           
 void _SortedMapStub.remove_element_at(Iterator where)
           
 boolean _SortedMapStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _SortedMapStub.locate_next_different_element(Iterator where)
           
 boolean _SortedCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _SortedCollectionStub.remove_element_at(Iterator where)
           
 boolean _SortedCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _SortedCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedBagStub.locate_next_element(Any element, Iterator where)
           
 boolean _SortedBagStub.locate_previous_element(Any element, Iterator where)
           
 boolean _SortedBagStub.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean _SortedBagStub.locate_element(Any element, Iterator where)
           
 void _SortedBagStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedBagStub.locate_previous_different_element(Iterator where)
           
 boolean _SortedBagStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _SortedBagStub.locate_first_element(Any element, Iterator where)
           
 void _SortedBagStub.remove_element_at(Iterator where)
           
 boolean _SortedBagStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _SortedBagStub.locate_last_element(Any element, Iterator where)
           
 boolean _SortedBagStub.locate_next_different_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.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _SetStub.remove_element_at(Iterator where)
           
 boolean _SetStub.locate_next_different_element(Iterator where)
           
 boolean _SetStub.locate_next_element(Any element, Iterator where)
           
 boolean _SetStub.add_element_set_iterator(Any element, Iterator where)
           
 void _SetStub.replace_element_at(Iterator where, Any element)
           
 boolean _SequentialCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _SequentialCollectionStub.add_element_as_next(Any element, Iterator where)
           
 void _SequentialCollectionStub.remove_element_at(Iterator where)
           
 void _SequentialCollectionStub.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 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.replace_element_at(Iterator where, Any element)
           
 boolean _RelationStub.locate_next_element(Any element, Iterator where)
           
 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_next_element_with_key(Any key, Iterator where)
           
 boolean _RelationStub.locate_element_with_key(Any key, Iterator where)
           
 boolean _RelationStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _RelationStub.locate_element(Any element, Iterator where)
           
 void _RelationStub.replace_element_at(Iterator where, Any element)
           
 boolean _RelationStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _RelationStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _RelationStub.locate_next_element_with_different_key(Iterator where)
           
 void _RelationStub.remove_element_at(Iterator where)
           
 boolean _RelationStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _RelationStub.locate_next_different_element(Iterator where)
           
 boolean _OrderedIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _OrderedIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean _OrderedIteratorStub.set_to_next_nth_element(int n)
           
 void _OrderedIteratorStub.replace_element(Any element)
           
 void _OrderedIteratorStub.assign(Iterator from_where)
           
 int _OrderedIteratorStub.position()
           
 boolean _OrderedIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _OrderedIteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _OrderedIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _OrderedIteratorStub.set_to_previous_element()
           
 boolean _OrderedIteratorStub.set_to_next_element()
           
 boolean _OrderedIteratorStub.set_to_nth_previous_element(int n)
           
 boolean _OrderedIteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 boolean _OrderedIteratorStub.not_equal_replace_element_set_to_previous(Iterator test, Any element)
           
 void _OrderedIteratorStub.remove_element()
           
 boolean _OrderedIteratorStub.remove_element_set_to_previous()
           
 boolean _OrderedIteratorStub.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean _OrderedIteratorStub.is_equal(Iterator test)
           
 boolean _OrderedIteratorStub.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean _OrderedIteratorStub.remove_element_set_to_next()
           
 boolean _OrderedIteratorStub.not_equal_remove_element_set_to_previous(Iterator test)
           
 boolean _OrderedIteratorStub.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean _OrderedIteratorStub.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _OrderedIteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _OrderedIteratorStub.replace_element_set_to_next(Any element)
           
 boolean _OrderedIteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _OrderedIteratorStub.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean _OrderedIteratorStub.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean _OrderedCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _OrderedCollectionStub.remove_element_at(Iterator where)
           
 boolean _OrderedCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _OrderedCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _MapStub.locate_next_element(Any element, Iterator where)
           
 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)
           
 boolean _MapStub.locate_next_element_with_key(Any key, Iterator where)
           
 boolean _MapStub.locate_element_with_key(Any key, Iterator where)
           
 boolean _MapStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _MapStub.locate_element(Any element, Iterator where)
           
 void _MapStub.replace_element_at(Iterator where, Any element)
           
 boolean _MapStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _MapStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _MapStub.locate_next_element_with_different_key(Iterator where)
           
 void _MapStub.remove_element_at(Iterator where)
           
 boolean _MapStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _MapStub.locate_next_different_element(Iterator where)
           
 boolean _KeySortedSetStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedSetStub.locate_next_element_with_key(Any key, Iterator where)
           
 boolean _KeySortedSetStub.locate_element_with_key(Any key, Iterator where)
           
 boolean _KeySortedSetStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedSetStub.locate_first_element_with_key(Any key, Iterator where)
           
 void _KeySortedSetStub.replace_element_at(Iterator where, Any element)
           
 boolean _KeySortedSetStub.locate_previous_element_with_different_key(Iterator where)
           
 boolean _KeySortedSetStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _KeySortedSetStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedSetStub.locate_next_element_with_different_key(Iterator where)
           
 boolean _KeySortedSetStub.locate_last_element_with_key(Any key, Iterator where)
           
 void _KeySortedSetStub.remove_element_at(Iterator where)
           
 boolean _KeySortedSetStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedSetStub.locate_previous_element_with_key(Any key, Iterator where)
           
 boolean _KeySortedBagStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedBagStub.locate_next_element_with_key(Any key, Iterator where)
           
 boolean _KeySortedBagStub.locate_element_with_key(Any key, Iterator where)
           
 boolean _KeySortedBagStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedBagStub.locate_first_element_with_key(Any key, Iterator where)
           
 void _KeySortedBagStub.replace_element_at(Iterator where, Any element)
           
 boolean _KeySortedBagStub.locate_previous_element_with_different_key(Iterator where)
           
 boolean _KeySortedBagStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _KeySortedBagStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedBagStub.locate_next_element_with_different_key(Iterator where)
           
 boolean _KeySortedBagStub.locate_last_element_with_key(Any key, Iterator where)
           
 void _KeySortedBagStub.remove_element_at(Iterator where)
           
 boolean _KeySortedBagStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _KeySortedBagStub.locate_previous_element_with_key(Any key, Iterator where)
           
 boolean _KeySetStub.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySetStub.locate_next_element_with_different_key(Iterator where)
           
 boolean _KeySetStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _KeySetStub.remove_element_at(Iterator where)
           
 boolean _KeySetStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySetStub.locate_next_element_with_key(Any key, Iterator where)
           
 boolean _KeySetStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeySetStub.locate_element_with_key(Any key, Iterator where)
           
 boolean _KeySetStub.add_element_set_iterator(Any element, Iterator where)
           
 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.locate_next_element_with_different_key(Iterator where)
           
 boolean _KeyCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _KeyCollectionStub.remove_element_at(Iterator where)
           
 boolean _KeyCollectionStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeyCollectionStub.locate_next_element_with_key(Any key, 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)
           
 boolean _KeyCollectionStub.locate_element_with_key(Any key, Iterator where)
           
 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.locate_next_element_with_different_key(Iterator where)
           
 boolean _KeyBagStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _KeyBagStub.remove_element_at(Iterator where)
           
 boolean _KeyBagStub.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeyBagStub.locate_next_element_with_key(Any key, Iterator where)
           
 boolean _KeyBagStub.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean _KeyBagStub.locate_element_with_key(Any key, Iterator where)
           
 boolean _KeyBagStub.add_element_set_iterator(Any element, Iterator where)
           
 void _KeyBagStub.replace_element_at(Iterator where, Any element)
           
 void _IteratorStub.replace_element(Any element)
           
 void _IteratorStub.assign(Iterator from_where)
           
 boolean _IteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean _IteratorStub.remove_element_set_to_next()
           
 boolean _IteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _IteratorStub.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _IteratorStub.is_equal(Iterator test)
           
 boolean _IteratorStub.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean _IteratorStub.set_to_next_nth_element(int n)
           
 boolean _IteratorStub.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean _IteratorStub.replace_element_set_to_next(Any element)
           
 boolean _IteratorStub.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean _IteratorStub.set_to_next_element()
           
 void _IteratorStub.remove_element()
           
 boolean _IteratorStub.retrieve_element(AnyHolder element)
           
 boolean _IteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 void _HeapStub.remove_element_at(Iterator where)
           
 void _HeapStub.replace_element_at(Iterator where, Any element)
           
 boolean _HeapStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _HeapStub.add_element_set_iterator(Any element, Iterator where)
           
 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.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _EqualitySortedCollectionStub.locate_previous_different_element(Iterator where)
           
 boolean _EqualitySortedCollectionStub.locate_previous_element(Any element, Iterator where)
           
 void _EqualitySortedCollectionStub.remove_element_at(Iterator where)
           
 boolean _EqualitySortedCollectionStub.locate_next_different_element(Iterator where)
           
 boolean _EqualitySortedCollectionStub.locate_next_element(Any element, Iterator where)
           
 boolean _EqualitySortedCollectionStub.locate_first_element(Any element, Iterator where)
           
 boolean _EqualitySortedCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _EqualitySortedCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _EqualitySequentialCollectionStub.locate_next_element(Any element, Iterator where)
           
 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_previous(Any element, Iterator where)
           
 boolean _EqualitySequentialCollectionStub.locate_last_element_with_value(Any element, Iterator where)
           
 boolean _EqualitySequentialCollectionStub.locate_element(Any element, Iterator where)
           
 void _EqualitySequentialCollectionStub.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 void _EqualitySequentialCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _EqualitySequentialCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _EqualitySequentialCollectionStub.add_element_as_last_set_iterator(Any element, Iterator where)
           
 boolean _EqualitySequentialCollectionStub.locate_previous_element_with_value(Any element, Iterator where)
           
 void _EqualitySequentialCollectionStub.remove_element_at(Iterator where)
           
 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 _EqualitySequentialCollectionStub.locate_next_different_element(Iterator where)
           
 boolean _EqualitySequenceStub.locate_next_element(Any element, Iterator where)
           
 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_previous(Any element, Iterator where)
           
 boolean _EqualitySequenceStub.locate_last_element_with_value(Any element, Iterator where)
           
 boolean _EqualitySequenceStub.locate_element(Any element, Iterator where)
           
 void _EqualitySequenceStub.replace_element_at(Iterator where, Any element)
           
 void _EqualitySequenceStub.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 boolean _EqualitySequenceStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _EqualitySequenceStub.add_element_as_last_set_iterator(Any element, Iterator where)
           
 boolean _EqualitySequenceStub.locate_previous_element_with_value(Any element, Iterator where)
           
 void _EqualitySequenceStub.remove_element_at(Iterator where)
           
 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 _EqualitySequenceStub.locate_next_different_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.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _EqualityCollectionStub.remove_element_at(Iterator where)
           
 boolean _EqualityCollectionStub.locate_next_different_element(Iterator where)
           
 boolean _EqualityCollectionStub.locate_next_element(Any element, Iterator where)
           
 boolean _EqualityCollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 void _EqualityCollectionStub.replace_element_at(Iterator where, Any element)
           
 void _CollectionStub.remove_element_at(Iterator where)
           
 void _CollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _CollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _CollectionStub.add_element_set_iterator(Any element, Iterator where)
           
 boolean _CSequenceStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _CSequenceStub.add_element_as_next(Any element, Iterator where)
           
 void _CSequenceStub.remove_element_at(Iterator where)
           
 void _CSequenceStub.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 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.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.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _BagStub.remove_element_at(Iterator where)
           
 boolean _BagStub.locate_next_different_element(Iterator where)
           
 boolean _BagStub.locate_next_element(Any element, Iterator where)
           
 boolean _BagStub.add_element_set_iterator(Any element, Iterator where)
           
 void _BagStub.replace_element_at(Iterator where, Any element)
           
 boolean SortedRelationPOATie.locate_next_element(Any element, Iterator where)
           
 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_next_element_with_key(Any key, Iterator where)
           
 boolean SortedRelationPOATie.locate_element_with_key(Any key, Iterator where)
           
 boolean SortedRelationPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean SortedRelationPOATie.locate_element(Any element, Iterator where)
           
 void SortedRelationPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SortedRelationPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean SortedRelationPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean SortedRelationPOATie.locate_next_element_with_different_key(Iterator where)
           
 void SortedRelationPOATie.remove_element_at(Iterator where)
           
 boolean SortedRelationPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean SortedRelationPOATie.locate_next_different_element(Iterator where)
           
 boolean SortedCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void SortedCollectionPOATie.remove_element_at(Iterator where)
           
 boolean SortedCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 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)
           
 boolean SequentialCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void SequentialCollectionPOATie.add_element_as_next(Any element, Iterator where)
           
 void SequentialCollectionPOATie.remove_element_at(Iterator where)
           
 void SequentialCollectionPOATie.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 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.replace_element_at(Iterator where, Any element)
           
 void SequentialCollectionOperations.add_element_as_first_set_iterator(Any element, Iterator where)
           
 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_set_iterator(int position, Any element, Iterator where)
           
 boolean RelationPOATie.locate_next_element(Any element, Iterator where)
           
 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_next_element_with_key(Any key, Iterator where)
           
 boolean RelationPOATie.locate_element_with_key(Any key, Iterator where)
           
 boolean RelationPOATie.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean RelationPOATie.locate_element(Any element, Iterator where)
           
 void RelationPOATie.replace_element_at(Iterator where, Any element)
           
 boolean RelationPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean RelationPOATie.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean RelationPOATie.locate_next_element_with_different_key(Iterator where)
           
 void RelationPOATie.remove_element_at(Iterator where)
           
 boolean RelationPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean RelationPOATie.locate_next_different_element(Iterator where)
           
 boolean OrderedIteratorOperations.set_to_previous_element()
           
 boolean OrderedIteratorOperations.set_to_nth_previous_element(int n)
           
 int OrderedIteratorOperations.position()
           
 boolean OrderedIteratorOperations.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 boolean OrderedIteratorOperations.retrieve_previous_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean OrderedIteratorOperations.not_equal_retrieve_element_set_to_previous(Iterator test, AnyHolder element)
           
 boolean OrderedIteratorOperations.remove_element_set_to_previous()
           
 boolean OrderedIteratorOperations.remove_previous_n_elements(int n, IntHolder actual_number)
           
 boolean OrderedIteratorOperations.not_equal_remove_element_set_to_previous(Iterator test)
           
 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.retrieve_element_at(Iterator where, AnyHolder element)
           
 void OrderedCollectionPOATie.remove_element_at(Iterator where)
           
 boolean OrderedCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void OrderedCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean KeySortedCollectionOperations.locate_first_element_with_key(Any key, Iterator where)
           
 boolean KeySortedCollectionOperations.locate_last_element_with_key(Any key, Iterator where)
           
 boolean KeySortedCollectionOperations.locate_previous_element_with_key(Any key, Iterator where)
           
 boolean KeySortedCollectionOperations.locate_previous_element_with_different_key(Iterator where)
           
 boolean KeyCollectionOperations.locate_or_add_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyCollectionOperations.add_or_replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyCollectionOperations.replace_element_with_key_set_iterator(Any element, Iterator where)
           
 boolean KeyCollectionOperations.locate_element_with_key(Any key, Iterator where)
           
 boolean KeyCollectionOperations.locate_next_element_with_key(Any key, Iterator where)
           
 boolean KeyCollectionOperations.locate_next_element_with_different_key(Iterator where)
           
 void IteratorPOATie.replace_element(Any element)
           
 void IteratorPOATie.assign(Iterator from_where)
           
 boolean IteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean IteratorPOATie.remove_element_set_to_next()
           
 boolean IteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean IteratorPOATie.replace_next_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean IteratorPOATie.is_equal(Iterator test)
           
 boolean IteratorPOATie.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean IteratorPOATie.set_to_next_nth_element(int n)
           
 boolean IteratorPOATie.not_equal_remove_element_set_to_next(Iterator test)
           
 boolean IteratorPOATie.replace_element_set_to_next(Any element)
           
 boolean IteratorPOATie.not_equal_replace_element_set_to_next(Iterator test, Any element)
           
 boolean IteratorPOATie.set_to_next_element()
           
 void IteratorPOATie.remove_element()
           
 boolean IteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean IteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 boolean IteratorOperations.set_to_next_element()
           
 boolean IteratorOperations.set_to_next_nth_element(int n)
           
 boolean IteratorOperations.retrieve_element(AnyHolder element)
           
 boolean IteratorOperations.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean IteratorOperations.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean IteratorOperations.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 void IteratorOperations.remove_element()
           
 boolean IteratorOperations.remove_element_set_to_next()
           
 boolean IteratorOperations.remove_next_n_elements(int n, IntHolder actual_number)
           
 boolean IteratorOperations.not_equal_remove_element_set_to_next(Iterator test)
           
 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.is_equal(Iterator test)
           
 void IteratorOperations.assign(Iterator from_where)
           
 void HeapPOATie.remove_element_at(Iterator where)
           
 void HeapPOATie.replace_element_at(Iterator where, Any element)
           
 boolean HeapPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean HeapPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean EqualitySortedIteratorOperations.set_to_previous_element_with_value(Any elementally)
           
 boolean EqualitySortedIteratorOperations.set_to_previous_element_with_different_value()
           
 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.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean EqualitySortedCollectionPOATie.locate_previous_different_element(Iterator where)
           
 boolean EqualitySortedCollectionPOATie.locate_previous_element(Any element, Iterator where)
           
 void EqualitySortedCollectionPOATie.remove_element_at(Iterator where)
           
 boolean EqualitySortedCollectionPOATie.locate_next_different_element(Iterator where)
           
 boolean EqualitySortedCollectionPOATie.locate_next_element(Any element, Iterator where)
           
 boolean EqualitySortedCollectionPOATie.locate_first_element(Any element, Iterator where)
           
 boolean EqualitySortedCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void EqualitySortedCollectionPOATie.replace_element_at(Iterator where, 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 EqualitySortedCollectionOperations.locate_previous_different_element(Iterator where)
           
 boolean EqualitySequentialCollectionPOATie.locate_next_element(Any element, Iterator where)
           
 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_previous(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionPOATie.locate_last_element_with_value(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionPOATie.locate_element(Any element, Iterator where)
           
 void EqualitySequentialCollectionPOATie.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 void EqualitySequentialCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean EqualitySequentialCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void EqualitySequentialCollectionPOATie.add_element_as_last_set_iterator(Any element, Iterator where)
           
 boolean EqualitySequentialCollectionPOATie.locate_previous_element_with_value(Any element, Iterator where)
           
 void EqualitySequentialCollectionPOATie.remove_element_at(Iterator where)
           
 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 EqualitySequentialCollectionPOATie.locate_next_different_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.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_previous(Any element, Iterator where)
           
 boolean EqualitySequencePOATie.locate_last_element_with_value(Any element, Iterator where)
           
 boolean EqualitySequencePOATie.locate_element(Any element, Iterator where)
           
 void EqualitySequencePOATie.replace_element_at(Iterator where, Any element)
           
 void EqualitySequencePOATie.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 boolean EqualitySequencePOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void EqualitySequencePOATie.add_element_as_last_set_iterator(Any element, Iterator where)
           
 boolean EqualitySequencePOATie.locate_previous_element_with_value(Any element, Iterator where)
           
 void EqualitySequencePOATie.remove_element_at(Iterator where)
           
 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 EqualitySequencePOATie.locate_next_different_element(Iterator where)
           
 boolean EqualityIteratorOperations.set_to_next_element_with_value(Any element)
           
 boolean EqualityIteratorOperations.set_to_next_element_with_different_value()
           
 boolean EqualityCollectionPOATie.locate_or_add_element_set_iterator(Any element, Iterator where)
           
 boolean EqualityCollectionPOATie.locate_element(Any element, Iterator where)
           
 boolean EqualityCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void EqualityCollectionPOATie.remove_element_at(Iterator where)
           
 boolean EqualityCollectionPOATie.locate_next_different_element(Iterator where)
           
 boolean EqualityCollectionPOATie.locate_next_element(Any element, Iterator where)
           
 boolean EqualityCollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 void EqualityCollectionPOATie.replace_element_at(Iterator where, 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.locate_next_different_element(Iterator where)
           
 void CollectionPOATie.remove_element_at(Iterator where)
           
 void CollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean CollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean CollectionPOATie.add_element_set_iterator(Any element, Iterator where)
           
 boolean CollectionOperations.add_element_set_iterator(Any element, Iterator where)
           
 void CollectionOperations.remove_element_at(Iterator where)
           
 void CollectionOperations.replace_element_at(Iterator where, Any element)
           
 boolean CollectionOperations.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean CSequencePOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void CSequencePOATie.add_element_as_next(Any element, Iterator where)
           
 void CSequencePOATie.remove_element_at(Iterator where)
           
 void CSequencePOATie.add_element_at_position_set_iterator(int position, Any element, Iterator where)
           
 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.replace_element_at(Iterator where, Any element)
           
 

Constructors in org.omg.CosCollection with parameters of type IteratorInvalid
IteratorInvalidHolder(IteratorInvalid initial)