Uses of Class
org.omg.CosCollection.IteratorInBetween

Packages that use IteratorInBetween
org.omg.CosCollection   
 

Uses of IteratorInBetween in org.omg.CosCollection
 

Fields in org.omg.CosCollection declared as IteratorInBetween
 IteratorInBetween IteratorInBetweenHolder.value
           
 

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

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

Methods in org.omg.CosCollection that throw IteratorInBetween
 boolean OrderedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean OrderedIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 void OrderedIteratorPOATie.replace_element(Any element)
           
 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.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.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 EqualitySequentialIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean EqualitySequentialIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 void EqualitySequentialIteratorPOATie.replace_element(Any element)
           
 boolean EqualitySequentialIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean EqualitySequentialIteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean EqualitySequentialIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 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.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 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 EqualityIteratorPOATie.replace_element(Any element)
           
 boolean EqualityIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 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.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 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)
           
 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)
           
 boolean SequentialIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean SequentialIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 void SequentialIteratorPOATie.replace_element(Any element)
           
 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.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.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)
           
 boolean EqualitySortedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean EqualitySortedIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 void EqualitySortedIteratorPOATie.replace_element(Any element)
           
 boolean EqualitySortedIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean EqualitySortedIteratorPOATie.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean EqualitySortedIteratorPOATie.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean EqualitySortedIteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 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.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 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)
           
 void _EqualitySortedIteratorStub.replace_element(Any element)
           
 boolean _EqualitySortedIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _EqualitySortedIteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _EqualitySortedIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 boolean _EqualitySortedIteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 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.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 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 SortedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean SortedIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 void SortedIteratorPOATie.replace_element(Any element)
           
 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.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.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 _EqualitySequentialIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _EqualitySequentialIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 void _EqualitySequentialIteratorStub.replace_element(Any element)
           
 boolean _EqualitySequentialIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _EqualitySequentialIteratorStub.retrieve_next_n_elements(int n, AnySequenceHolder result, BooleanHolder more)
           
 boolean _EqualitySequentialIteratorStub.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 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.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 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 _SortedIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _SortedIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 void _SortedIteratorStub.replace_element(Any element)
           
 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.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.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)
           
 boolean _SequentialIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _SequentialIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 void _SequentialIteratorStub.replace_element(Any element)
           
 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.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.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)
           
 void _EqualityIteratorStub.replace_element(Any element)
           
 boolean _EqualityIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 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.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 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)
           
 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)
           
 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)
           
 void _SortedRelationStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedRelationStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _SortedRelationStub.locate_next_element_with_different_key(Iterator where)
           
 void _SortedRelationStub.remove_element_at(Iterator where)
           
 boolean _SortedRelationStub.locate_next_different_element(Iterator where)
           
 void SortedBagPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SortedBagPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void SortedBagPOATie.remove_element_at(Iterator where)
           
 boolean SortedBagPOATie.locate_next_different_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)
           
 void KeySetPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SetPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void SetPOATie.remove_element_at(Iterator where)
           
 boolean SetPOATie.locate_next_different_element(Iterator where)
           
 void SetPOATie.replace_element_at(Iterator where, Any element)
           
 boolean KeySortedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean KeySortedIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 void KeySortedIteratorPOATie.replace_element(Any element)
           
 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.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 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.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.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)
           
 void _SortedMapStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedMapStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _SortedMapStub.locate_next_element_with_different_key(Iterator where)
           
 void _SortedMapStub.remove_element_at(Iterator where)
           
 boolean _SortedMapStub.locate_next_different_element(Iterator where)
           
 boolean _KeySortedIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _KeySortedIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 void _KeySortedIteratorStub.replace_element(Any element)
           
 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.replace_previous_n_elements(Any[] elements, IntHolder actual_number)
           
 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.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.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)
           
 void _EqualitySequentialCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _EqualitySequentialCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _EqualitySequentialCollectionStub.remove_element_at(Iterator where)
           
 boolean _EqualitySequentialCollectionStub.locate_next_different_element(Iterator 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 _BagStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _BagStub.remove_element_at(Iterator where)
           
 boolean _BagStub.locate_next_different_element(Iterator where)
           
 void _BagStub.replace_element_at(Iterator where, Any element)
           
 boolean SortedCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void SortedCollectionPOATie.remove_element_at(Iterator where)
           
 void SortedCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean BagPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void BagPOATie.remove_element_at(Iterator where)
           
 boolean BagPOATie.locate_next_different_element(Iterator where)
           
 void BagPOATie.replace_element_at(Iterator where, Any element)
           
 void _EqualityKeyIteratorStub.replace_element(Any element)
           
 boolean _EqualityKeyIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 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_different_key()
           
 boolean _EqualityKeyIteratorStub.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean _EqualityKeyIteratorStub.retrieve_next_n_keys(AnySequenceHolder keys)
           
 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)
           
 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 _IteratorStub.replace_element(Any element)
           
 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.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 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)
           
 void _IteratorStub.remove_element()
           
 boolean _IteratorStub.retrieve_element(AnyHolder element)
           
 boolean _IteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 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 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)
           
 void KeyCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 void EqualityKeyIteratorPOATie.replace_element(Any element)
           
 boolean EqualityKeyIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 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_different_key()
           
 boolean EqualityKeyIteratorPOATie.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 boolean EqualityKeyIteratorPOATie.retrieve_next_n_keys(AnySequenceHolder keys)
           
 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)
           
 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 MapPOATie.replace_element_at(Iterator where, Any element)
           
 boolean MapPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean MapPOATie.locate_next_element_with_different_key(Iterator where)
           
 void MapPOATie.remove_element_at(Iterator where)
           
 boolean MapPOATie.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 EqualityIteratorOperations.set_to_next_element_with_different_value()
           
 boolean KeyCollectionOperations.locate_next_element_with_different_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.locate_next_element_with_different_key(Iterator where)
           
 void KeySortedBagPOATie.remove_element_at(Iterator where)
           
 void _EqualityKeySortedCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _EqualityKeySortedCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _EqualityKeySortedCollectionStub.locate_next_element_with_different_key(Iterator where)
           
 void _EqualityKeySortedCollectionStub.remove_element_at(Iterator where)
           
 boolean _EqualityKeySortedCollectionStub.locate_next_different_element(Iterator where)
           
 boolean KeyIteratorOperations.set_to_next_element_with_different_key()
           
 boolean KeyIteratorOperations.retrieve_key(AnyHolder key)
           
 boolean KeyIteratorOperations.retrieve_next_n_keys(AnySequenceHolder keys)
           
 boolean _OrderedIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _OrderedIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 void _OrderedIteratorStub.replace_element(Any element)
           
 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.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.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)
           
 void SortedRelationPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SortedRelationPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean SortedRelationPOATie.locate_next_element_with_different_key(Iterator where)
           
 void SortedRelationPOATie.remove_element_at(Iterator where)
           
 boolean SortedRelationPOATie.locate_next_different_element(Iterator where)
           
 boolean EqualitySortedIteratorOperations.set_to_previous_element_with_different_value()
           
 void IteratorPOATie.replace_element(Any element)
           
 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.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 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)
           
 void IteratorPOATie.remove_element()
           
 boolean IteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean IteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 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.locate_next_element_with_different_key(Iterator where)
           
 void KeySortedSetPOATie.remove_element_at(Iterator where)
           
 void _EqualityKeyCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _EqualityKeyCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _EqualityKeyCollectionStub.locate_next_element_with_different_key(Iterator where)
           
 void _EqualityKeyCollectionStub.remove_element_at(Iterator where)
           
 boolean _EqualityKeyCollectionStub.locate_next_different_element(Iterator where)
           
 void _EqualitySequenceStub.replace_element_at(Iterator where, Any element)
           
 boolean _EqualitySequenceStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _EqualitySequenceStub.remove_element_at(Iterator where)
           
 boolean _EqualitySequenceStub.locate_next_different_element(Iterator where)
           
 boolean _SortedCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _SortedCollectionStub.remove_element_at(Iterator where)
           
 void _SortedCollectionStub.replace_element_at(Iterator where, Any element)
           
 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.locate_next_element_with_different_key(Iterator where)
           
 void _KeySortedSetStub.remove_element_at(Iterator where)
           
 boolean _CSequenceStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _CSequenceStub.remove_element_at(Iterator where)
           
 void _CSequenceStub.replace_element_at(Iterator where, Any element)
           
 boolean EqualityKeySortedIteratorPOATie.replace_element_set_to_previous(Any element)
           
 boolean EqualityKeySortedIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 void EqualityKeySortedIteratorPOATie.replace_element(Any element)
           
 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.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 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.retrieve_next_n_keys(AnySequenceHolder keys)
           
 boolean EqualityKeySortedIteratorPOATie.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 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.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()
           
 void _RelationStub.replace_element_at(Iterator where, Any element)
           
 boolean _RelationStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _RelationStub.locate_next_element_with_different_key(Iterator where)
           
 void _RelationStub.remove_element_at(Iterator where)
           
 boolean _RelationStub.locate_next_different_element(Iterator where)
           
 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)
           
 void _KeyIteratorStub.replace_element(Any element)
           
 boolean _KeyIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 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.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 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)
           
 void _KeyIteratorStub.remove_element()
           
 boolean _KeyIteratorStub.retrieve_element(AnyHolder element)
           
 boolean _KeyIteratorStub.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 void EqualitySequentialCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean EqualitySequentialCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void EqualitySequentialCollectionPOATie.remove_element_at(Iterator where)
           
 boolean EqualitySequentialCollectionPOATie.locate_next_different_element(Iterator where)
           
 boolean OrderedCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void OrderedCollectionPOATie.remove_element_at(Iterator where)
           
 void OrderedCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 void EqualityKeyCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean EqualityKeyCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean EqualityKeyCollectionPOATie.locate_next_element_with_different_key(Iterator where)
           
 void EqualityKeyCollectionPOATie.remove_element_at(Iterator where)
           
 boolean EqualityKeyCollectionPOATie.locate_next_different_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)
           
 void _KeyCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean KeySortedIteratorOperations.set_to_previous_element_with_different_key()
           
 boolean KeySortedIteratorOperations.retrieve_previous_n_keys(AnySequenceHolder keys)
           
 void _SortedSetStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedSetStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _SortedSetStub.remove_element_at(Iterator where)
           
 boolean _SortedSetStub.locate_next_different_element(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.locate_next_element_with_different_key(Iterator where)
           
 void _KeySortedBagStub.remove_element_at(Iterator where)
           
 boolean _OrderedCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _OrderedCollectionStub.remove_element_at(Iterator where)
           
 void _OrderedCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean KeySortedCollectionOperations.locate_previous_element_with_different_key(Iterator where)
           
 boolean _SequentialCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _SequentialCollectionStub.remove_element_at(Iterator where)
           
 void _SequentialCollectionStub.replace_element_at(Iterator where, Any element)
           
 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)
           
 void _KeySetStub.replace_element_at(Iterator where, Any element)
           
 boolean SequentialCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void SequentialCollectionPOATie.remove_element_at(Iterator where)
           
 void SequentialCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 void _SortedBagStub.replace_element_at(Iterator where, Any element)
           
 boolean _SortedBagStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _SortedBagStub.remove_element_at(Iterator where)
           
 boolean _SortedBagStub.locate_next_different_element(Iterator where)
           
 void SortedMapPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SortedMapPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean SortedMapPOATie.locate_next_element_with_different_key(Iterator where)
           
 void SortedMapPOATie.remove_element_at(Iterator where)
           
 boolean SortedMapPOATie.locate_next_different_element(Iterator where)
           
 void _MapStub.replace_element_at(Iterator where, Any element)
           
 boolean _MapStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean _MapStub.locate_next_element_with_different_key(Iterator where)
           
 void _MapStub.remove_element_at(Iterator where)
           
 boolean _MapStub.locate_next_different_element(Iterator where)
           
 boolean EqualityCollectionOperations.locate_next_different_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)
           
 void _EqualityCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean _SetStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _SetStub.remove_element_at(Iterator where)
           
 boolean _SetStub.locate_next_different_element(Iterator where)
           
 void _SetStub.replace_element_at(Iterator where, Any element)
           
 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)
           
 void KeyBagPOATie.replace_element_at(Iterator where, Any element)
           
 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)
           
 void _KeyBagStub.replace_element_at(Iterator where, Any element)
           
 boolean _EqualitySortedCollectionStub.retrieve_element_at(Iterator where, AnyHolder element)
           
 void _EqualitySortedCollectionStub.remove_element_at(Iterator where)
           
 boolean _EqualitySortedCollectionStub.locate_next_different_element(Iterator where)
           
 void _EqualitySortedCollectionStub.replace_element_at(Iterator where, Any element)
           
 boolean EqualitySortedCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void EqualitySortedCollectionPOATie.remove_element_at(Iterator where)
           
 boolean EqualitySortedCollectionPOATie.locate_next_different_element(Iterator where)
           
 void EqualitySortedCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 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.locate_next_element_with_different_key(Iterator where)
           
 void KeySortedCollectionPOATie.remove_element_at(Iterator where)
           
 boolean CSequencePOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void CSequencePOATie.remove_element_at(Iterator where)
           
 void CSequencePOATie.replace_element_at(Iterator where, Any element)
           
 void RelationPOATie.replace_element_at(Iterator where, Any element)
           
 boolean RelationPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean RelationPOATie.locate_next_element_with_different_key(Iterator where)
           
 void RelationPOATie.remove_element_at(Iterator where)
           
 boolean RelationPOATie.locate_next_different_element(Iterator where)
           
 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 _EqualityKeySortedIteratorStub.replace_element_set_to_previous(Any element)
           
 boolean _EqualityKeySortedIteratorStub.remove_next_n_elements(int n, IntHolder actual_number)
           
 void _EqualityKeySortedIteratorStub.replace_element(Any element)
           
 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.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 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.retrieve_next_n_keys(AnySequenceHolder keys)
           
 boolean _EqualityKeySortedIteratorStub.retrieve_element_set_to_previous(AnyHolder element, BooleanHolder more)
           
 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.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()
           
 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 EqualityCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void EqualityCollectionPOATie.remove_element_at(Iterator where)
           
 boolean EqualityCollectionPOATie.locate_next_different_element(Iterator where)
           
 void EqualityCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 void KeyIteratorPOATie.replace_element(Any element)
           
 boolean KeyIteratorPOATie.remove_next_n_elements(int n, IntHolder actual_number)
           
 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.retrieve_element_set_to_next(AnyHolder element, BooleanHolder more)
           
 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)
           
 void KeyIteratorPOATie.remove_element()
           
 boolean KeyIteratorPOATie.retrieve_element(AnyHolder element)
           
 boolean KeyIteratorPOATie.not_equal_retrieve_element_set_to_next(Iterator test, AnyHolder element)
           
 void EqualitySequencePOATie.replace_element_at(Iterator where, Any element)
           
 boolean EqualitySequencePOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void EqualitySequencePOATie.remove_element_at(Iterator where)
           
 boolean EqualitySequencePOATie.locate_next_different_element(Iterator where)
           
 void SortedSetPOATie.replace_element_at(Iterator where, Any element)
           
 boolean SortedSetPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 void SortedSetPOATie.remove_element_at(Iterator where)
           
 boolean SortedSetPOATie.locate_next_different_element(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.locate_next_element_with_different_key(Iterator where)
           
 void _KeySortedCollectionStub.remove_element_at(Iterator where)
           
 void EqualityKeySortedCollectionPOATie.replace_element_at(Iterator where, Any element)
           
 boolean EqualityKeySortedCollectionPOATie.retrieve_element_at(Iterator where, AnyHolder element)
           
 boolean EqualityKeySortedCollectionPOATie.locate_next_element_with_different_key(Iterator where)
           
 void EqualityKeySortedCollectionPOATie.remove_element_at(Iterator where)
           
 boolean EqualityKeySortedCollectionPOATie.locate_next_different_element(Iterator where)
           
 

Constructors in org.omg.CosCollection with parameters of type IteratorInBetween
IteratorInBetweenHolder(IteratorInBetween initial)