//File: CosCollection.idl
//This is the single module for the Collection Service

#ifndef _COS_COLLECTION_IDL_
#define _COS_COLLECTION_IDL_

// omniORB specific pragmas to insert extra includes into the stub header.
#pragma hh #include "COS_sysdep.h"

#pragma prefix "omg.org"

#include <orb.idl>

module CosCollection { 

	interface Collection;


	//  T y p e   d e f i n i t i o n s

	typedef sequence<any> AnySequence;
	typedef string Istring;
	struct NVPair {
		Istring name; 
		any value;
	};
	typedef sequence<NVPair> ParameterList; 

	//  E x c e p t i o n s
	exception  EmptyCollection{};
	exception  PositionInvalid{};
	enum IteratorInvalidReason {is_invalid, 
								is_not_for_collection,  
								is_const};

	exception IteratorInvalid {IteratorInvalidReason why;};
	exception IteratorInBetween{};
	enum ElementInvalidReason {	element_type_invalid, 
								positioning_property_invalid, 
								element_exists};

	exception ElementInvalid {ElementInvalidReason why;};
	exception KeyInvalid {};
	exception ParameterInvalid {unsigned long which; Istring why;}; 


	// O p e r a t i o n s
	interface Operations {

		//  e l e m e n t   t y p e   s p e c i f i c   
		//    i n f o r m a t i o n
		readonly attribute CORBA::TypeCode element_type;
		boolean check_element_type (in any element);
		boolean equal (in any element1, in any element2);
		long compare (in any element1, in any element2);
		unsigned long hash (in any element, in unsigned long value);

		//  k e y   r e t r i e v a l
		any key (in any element);
		
		//  k e y   t y p e   s p e c i f i c   
		//    i n f o r m a t i o n
		readonly attribute CORBA::TypeCode key_type;
		boolean check_key_type (in any a_key);
		boolean key_equal (in any a_key1, in any a_key2);
		long key_compare (in any a_key1, in any a_key2);
		unsigned long key_hash (in any thisKey, 
								in unsigned long value);
		
		//  d e s t r o y i n g
		void destroy();
		
	};

	interface Command {
		boolean do_on (in any element);
	};

	interface Comparator { 
		long compare (in any element1, in any element2);
	};



	// Iterators

	// I t e r a t o r
	interface Iterator { 

		//  m o v i n g   i t e r a t o r s
		boolean set_to_first_element ();
		boolean set_to_next_element() raises (IteratorInvalid);
		boolean set_to_next_nth_element (in unsigned long n)
			raises  (IteratorInvalid); 

		//  r e t r i e v i n g   e l e m e n t s
		boolean retrieve_element (out any element)
			raises (IteratorInvalid,  IteratorInBetween);
		boolean retrieve_element_set_to_next (	
				out any element, 
				out boolean  more)
			raises (IteratorInvalid, IteratorInBetween);
		boolean retrieve_next_n_elements (	
				in unsigned long n, 
				out AnySequence result, 
				out boolean more)
			raises (IteratorInvalid,  IteratorInBetween); 
		boolean not_equal_retrieve_element_set_to_next (
				in  Iterator test,  
				out any element)
			raises (IteratorInvalid, IteratorInBetween); 

		//   r e m o v i n g   e l e m e n t s
		void remove_element() 
			raises (IteratorInvalid, IteratorInBetween);
		boolean remove_element_set_to_next()
			raises (IteratorInvalid,  IteratorInBetween); 
		boolean remove_next_n_elements (
				in  unsigned long n, 
				out unsigned long actual_number)
			raises (IteratorInvalid, IteratorInBetween); 
		boolean not_equal_remove_element_set_to_next (in Iterator test)
			raises (IteratorInvalid, IteratorInBetween); 
		
		//  r e p l a c i n g   e l e m e n t s
		void replace_element (in any element)
			raises (IteratorInvalid, IteratorInBetween, ElementInvalid);
		boolean replace_element_set_to_next (in any element)
			raises(IteratorInvalid, IteratorInBetween, ElementInvalid);
		boolean replace_next_n_elements (
				in  AnySequence   elements, 
				out unsigned long actual_number)
			raises (IteratorInvalid, IteratorInBetween, ElementInvalid); 
		boolean not_equal_replace_element_set_to_next (
				in Iterator test, 
				in any element)
			raises(IteratorInvalid, IteratorInBetween, ElementInvalid); 
		
		//   a d d i n g   e l e m e n t s
		boolean add_element_set_iterator (in any element)raises  
			(ElementInvalid); 
		boolean add_n_elements_set_iterator (
				in  AnySequence elements, 
				out unsigned long actual_number)
			raises (ElementInvalid);
		
		//  s e t t i n g   i t e r a t o r   s t a t e
		void invalidate (); 
		
		//  t e s t i n g   i t e r a t o r s
		boolean is_valid ();
		boolean is_in_between ();
		boolean is_for(in Collection collector);
		boolean is_const ();
		boolean is_equal (in Iterator test) raises (IteratorInvalid); 
		
		//  c l o n i n g ,   a s s i g n i n g ,    
		//    d e s t r o y i n g  i t e r a t o r s
		Iterator clone ();
		void assign (in Iterator from_where) raises (IteratorInvalid);
		void destroy (); 
		
	};


	// O r d e r e d I t e r a t o r
	interface OrderedIterator: Iterator {

		//   m o v i n g   i t e r a t o r s
		boolean set_to_last_element ();
		boolean set_to_previous_element() raises (IteratorInvalid);
		boolean set_to_nth_previous_element(in unsigned long n)
			raises  (IteratorInvalid);
		void set_to_position (in unsigned long position) 
			raises (PositionInvalid);
		
		//  c o m p u t i n g   i t e r a t o r   p o s i t i o n
		unsigned long position () raises (IteratorInvalid); 
		
		//  r e t r i e v i n g   e l e m e n t s
		boolean retrieve_element_set_to_previous(
				out any element, 
				out boolean more)
			raises (IteratorInvalid, IteratorInBetween);
		boolean retrieve_previous_n_elements (
				in  unsigned long n, 
				out AnySequence result, 
				out boolean more)
			raises (IteratorInvalid,  IteratorInBetween); 
		boolean not_equal_retrieve_element_set_to_previous (
				in Iterator  test, 
				out any element)
			raises (IteratorInvalid, IteratorInBetween); 

		//   r e m o v i n g   e l e m e n t s
		boolean remove_element_set_to_previous()
			raises (IteratorInvalid,  IteratorInBetween); 
		boolean remove_previous_n_elements (
				in  unsigned long n, 
				out unsigned long actual_number)
			raises (IteratorInvalid, IteratorInBetween);
		boolean not_equal_remove_element_set_to_previous(
				in Iterator test)
			raises (IteratorInvalid, IteratorInBetween); 

		//  r e p l a c i n g   e l e m e n t s
		boolean replace_element_set_to_previous(in any element)
			raises (IteratorInvalid, IteratorInBetween, ElementInvalid);
		boolean replace_previous_n_elements(
				in  AnySequence   elements, 
				out unsigned long actual_number)
			raises (IteratorInvalid, IteratorInBetween, ElementInvalid); 
		boolean not_equal_replace_element_set_to_previous (
				in Iterator  test, 
				in any       element)
			raises (IteratorInvalid, IteratorInBetween, ElementInvalid); 
		
		//  t e s t i n g   i t e r a t o r s
		boolean is_first ();
		boolean is_last ();
		boolean is_for_same (in Iterator test);
		boolean is_reverse ();

	};


	// S e q u e n t i a l I t e r a t o r
	interface SequentialIterator : OrderedIterator { 

		// adding elements
		boolean add_element_as_next_set_iterator (in any element)
			raises(IteratorInvalid, ElementInvalid);
		void add_n_elements_as_next_set_iterator(
				in AnySequence elements)
			raises(IteratorInvalid, ElementInvalid); 
		boolean add_element_as_previous_set_iterator(in any element)
			raises(IteratorInvalid, ElementInvalid);
		void add_n_elements_as_previous_set_iterator(
				in AnySequence  elements)
			raises(IteratorInvalid, ElementInvalid);

	};


	// K e y I t e r a t o r
	interface KeyIterator : Iterator { 
		//  m o v i n g   t h e   i t e r a t o r s
		boolean set_to_element_with_key (in any a_key) 
			raises(KeyInvalid);
		boolean set_to_next_element_with_key (in any a_key)
			raises(IteratorInvalid, KeyInvalid);
		boolean set_to_next_element_with_different_key()
			raises (IteratorInBetween, IteratorInvalid); 
		
		//  r e t r i e v i n g   t h e   k e y s
		boolean retrieve_key (out any a_key)
			raises (IteratorInBetween,  IteratorInvalid);
		boolean retrieve_next_n_keys (out AnySequence some_keys)
			raises (IteratorInBetween, IteratorInvalid); 
		
	};


	// E q u a l i t y I t e r a t o r
	interface EqualityIterator : Iterator { 

		//  m o v i n g   t h e   i t e r a t o r s
		boolean set_to_element_with_value(in any element) 
			raises(ElementInvalid);
		boolean set_to_next_element_with_value(in any element)
			raises (IteratorInvalid, ElementInvalid);
		boolean set_to_next_element_with_different_value()
			raises (IteratorInBetween, IteratorInvalid);

	};



	// E q u a l i t y K e y I t e r a t o r
	interface EqualityKeyIterator : EqualityIterator, KeyIterator {};

	// S o r t e d I t e r a t o r
	interface SortedIterator : OrderedIterator {};


	//  e n u m e r a t i o n   t y p e   f o r   s p e c i f y i n g   r a n g e s
	enum LowerBoundStyle {equal_lo, greater, greater_or_equal};
	enum UpperBoundStyle {equal_up, less, less_or_equal};

	// K e y S o r t e d I t e r a t o r
	interface KeySortedIterator : KeyIterator, SortedIterator {

		//  m o v i n g   t h e   i t e r a t o r s
		boolean set_to_first_element_with_key (
				in any             a_key, 
				in LowerBoundStyle style)
			raises(KeyInvalid);
		boolean set_to_last_element_with_key (
				in any              a_key, 
				in UpperBoundStyle  style)
			raises (KeyInvalid); 
		boolean set_to_previous_element_with_key (in any a_key)
			raises(IteratorInvalid, KeyInvalid);
		boolean set_to_previous_element_with_different_key()
			raises (IteratorInBetween, IteratorInvalid); 
		
		//  r e t r i e v i n g   k e y s
		boolean retrieve_previous_n_keys(out AnySequence some_keys)
			raises (IteratorInBetween, IteratorInvalid);

	};


	// E q u a l i t y S o r t e d I t e r a t o r
	interface EqualitySortedIterator : 
					EqualityIterator, SortedIterator  {

		//  m o v i n g   t h e   i t e r a t o r
		boolean set_to_first_element_with_value (
				in any             element, 
				in LowerBoundStyle style)
			raises (ElementInvalid);
		boolean set_to_last_element_with_value (
				in any             element, 
				in UpperBoundStyle style)
			raises (ElementInvalid); 
		boolean set_to_previous_element_with_value (in any elementally)
			raises (IteratorInvalid, ElementInvalid);
		boolean set_to_previous_element_with_different_value()
			raises (IteratorInBetween, IteratorInvalid);

	};


	// E q u a l i t y K e y S o r t e d I t e r a t o r
	interface EqualityKeySortedIterator : 
					EqualitySortedIterator,  KeySortedIterator {};

	// E q u a l i t y S e q u e n t i a l I t e r a t o r
	interface EqualitySequentialIterator : 
					EqualityIterator,  SequentialIterator {

		//  l o c a t i n g   e l e m e n t s
		boolean set_to_first_element_with_value (in any element)
			raises (ElementInvalid);
		boolean set_to_last_element_with_value (in any element)
			raises (ElementInvalid);
		boolean set_to_previous_element_with_value (in any element)
			raises (ElementInvalid);

	};


	interface Collection {
	 //   e l e m e n t   t y p e   i n f o r m a t i o n
		readonly attribute CORBA::TypeCode element_type;
		
		// a d d i n g   e l e m e n t s
		boolean add_element (in any element) 
			raises (ElementInvalid);
		boolean add_element_set_iterator (
				in any      element, 
				in Iterator where) 
			raises (IteratorInvalid, ElementInvalid); 
		void add_all_from (in Collection collector) 
			raises (ElementInvalid);
		
		//   r e m o v i n g   e l e m e n t s
		void remove_element_at (in Iterator where) 
			raises (IteratorInvalid,  IteratorInBetween); 
		unsigned long remove_all ();
		
		//  r e p l a c i n g   e l e m e n t s
		void replace_element_at (
				in Iterator where, 
				in any      element)
			raises(IteratorInvalid, IteratorInBetween, ElementInvalid); 
		
		// r e t r i e v i n g   e l e m e n t s
		boolean retrieve_element_at (
				in  Iterator where, 
				out any element)
			raises (IteratorInvalid, IteratorInBetween); 
		
		// i t e r a t i n g   o v e r   t h e   c o l l e c t i o n
		boolean all_elements_do (in Command what) ;
		
		//   i n q u i r i n g   c o l l e c t i o n   
		//       i n f o r m a t i o n 
		unsigned long number_of_elements ();
		boolean is_empty ();
		
		//  d e s t r o y i n g   c o l l e c t i o n
		void destroy(); 
		
		//  c r e a t i n g   i t e r a t o r s
		Iterator create_iterator (in boolean read_only); 

	}; 
	
	//  O r d e r e d C o l l e c t i o n
	interface OrderedCollection: Collection {

		//  r e m o v i n g   e l e m e n t s
		void remove_element_at_position (in unsigned long position)
			raises  (PositionInvalid);
		void remove_first_element () raises (EmptyCollection);
		void remove_last_element () raises (EmptyCollection); 
		
		//  r e t r i e v i n g   e l e m e n t s
		boolean retrieve_element_at_position (
				in  unsigned long position, 
				out any           element)
			raises (PositionInvalid);
		boolean retrieve_first_element (out any element) 
			raises  (EmptyCollection);
		boolean retrieve_last_element (out any element) 
			raises  (EmptyCollection);
		
		//  c r e a t i n g   i t e r a t o r s
		OrderedIterator create_ordered_iterator(
			in boolean read_only, 
			in boolean reverse_iteration);
		
	}; 
	
	
	// S e q u e n t i a l C o l l e c t i o n
	interface SequentialCollection: OrderedCollection {

		//   a d d i n g   e l e m e n t s   
		void add_element_as_first (in any element) 
			raises (ElementInvalid);
		
		void add_element_as_first_set_iterator (
				in any       element, 
				in Iterator  where)
			raises (ElementInvalid, IteratorInvalid); 
		void add_element_as_last (in any element) 
			raises (ElementInvalid);
		void add_element_as_last_set_iterator (
				in any       element, 
				in Iterator  where)
			raises (ElementInvalid, IteratorInvalid); 
		void add_element_as_next (
				in any      element, 
				in Iterator where)
			raises  (ElementInvalid, IteratorInvalid); 
		void add_element_as_previous (
				in any      element, 
				in Iterator where)
			raises (ElementInvalid,IteratorInvalid); 
		void add_element_at_position (
				in unsigned long position, 
				in any           element)
			raises(PositionInvalid, ElementInvalid); 
		void add_element_at_position_set_iterator (
				in unsigned long  position, 
				in any            element, 
				in Iterator       where) 
			raises  (PositionInvalid, ElementInvalid, IteratorInvalid); 
		
		//  r e p l a c i n g   e l e m e n t s
		void replace_element_at_position (
				in unsigned long position, 
				in any           element)
			raises (PositionInvalid, ElementInvalid);
		void replace_first_element (in any element)
			raises (ElementInvalid,  EmptyCollection);
		void replace_last_element (in any element) 
			raises (ElementInvalid,  EmptyCollection); 
		
		//  r e o r d e r i n g   e l e m e n t s
		void sort (in Comparator comparison); void reverse(); 
		
	};
	
	
	// S o r t e C o l l e c t i o n
	interface SortedCollection: OrderedCollection{};
	
	// E q u a l i t y C o l l e c t i o n
	interface EqualityCollection: Collection {

		//  t e s t i n g   e l e m e n t   c o n t a i n m e n t
		boolean contains_element (in any element) 
			raises(ElementInvalid);
		boolean contains_all_from (in Collection collector)  
			raises(ElementInvalid); 
		
		//  a d d i n g   e l e m e n t s
		boolean locate_or_add_element (in any element) 
			raises (ElementInvalid); 
		boolean locate_or_add_element_set_iterator (
				in any      element, 
				in Iterator where)
			raises (ElementInvalid, IteratorInvalid); 
		
		//  l o c a t i n g   e l e m e n t s
		boolean locate_element (
				in any      element, 
				in Iterator where) 
			raises (ElementInvalid, IteratorInvalid);
		boolean locate_next_element (
				in any      element, 
				in Iterator where)
			raises (ElementInvalid, IteratorInvalid);
		boolean locate_next_different_element (in Iterator where)
			raises  (IteratorInvalid, IteratorInBetween);
		
		//  r e m o v i n g   e l e m e n t s
		boolean remove_element (in any element) 
			raises (ElementInvalid);
		unsigned long remove_all_occurrences (in any element)
			raises (ElementInvalid); 
		
		//  i n q u i r i n g   c o l l e c t i o n   
		//      i n f o r m a t i o n
		unsigned long number_of_different_elements ();
		unsigned long number_of_occurrences (in any element) 
			raises(ElementInvalid);
		
	};

	// K e y C o l l e c t i o n
	interface KeyCollection: Collection { 

		//  K e y   t y p e   i n f o r m a t i o n
		readonly attribute CORBA::TypeCode key_type; 
		
		//  t e s t i n g   c o n t a i n m e n t
		boolean contains_element_with_key (in any a_key) 
			raises(KeyInvalid);
		boolean contains_all_keys_from (in KeyCollection collector)
			raises(KeyInvalid);
		
		//  a d d i n g   e l e m e n t s
		boolean locate_or_add_element_with_key (in any element)
			raises(ElementInvalid);
		boolean locate_or_add_element_with_key_set_iterator (
				in any      element, 
				in Iterator where)
			raises (ElementInvalid,  IteratorInvalid);
		
		//  a d d i n g   o r   r e p l a c i n g   e l e m e n t s
		boolean add_or_replace_element_with_key (in any element)
			raises(ElementInvalid); 
		boolean add_or_replace_element_with_key_set_iterator (
				in any      element, 
				in Iterator where)
			raises (ElementInvalid,  IteratorInvalid); 
		
		//  r e m o v i n g   e l e m e n t s
		boolean remove_element_with_key(in any a_key) 
			raises(KeyInvalid);
		unsigned long remove_all_elements_with_key (in any a_key) 
			raises(KeyInvalid); 
		
		//  r e p l a c i n g   e l e m e n t s
		boolean replace_element_with_key (in any element) 
			raises(ElementInvalid);
		boolean replace_element_with_key_set_iterator (
				in any      element, 
				in Iterator where)
			raises (ElementInvalid, IteratorInvalid);
		
		//  r e t r i e v i n g   e l e m e n t s
		boolean retrieve_element_with_key (
				in  any a_key, 
				out any element)
			raises (KeyInvalid); 
		
		//  c o m p u t i n g   t h e   k e y s
		void key (in any element, out any a_key) 
			raises (ElementInvalid);
		void keys (in AnySequence elements, out AnySequence some_keys)
			raises (ElementInvalid);
		
		//  l o c a t i n g   e l e m e n t s
		boolean locate_element_with_key (
				in any      key, 
				in Iterator where)
			raises (KeyInvalid, IteratorInvalid);
		boolean locate_next_element_with_key (
				in any      key, 
				in Iterator where)
			raises (KeyInvalid, IteratorInvalid);
		boolean locate_next_element_with_different_key (
				in Iterator where)
			raises (IteratorInBetween, IteratorInvalid);
		
		//  i n q u i r i n g   c o l l e c t i o n   
		//      i n f o r m a t i o n
		unsigned long number_of_different_keys ();
		unsigned long number_of_elements_with_key (in any a_key) 
			raises(KeyInvalid);
		
	};


	// E q u a l i t y K e y C o l l e c t i o n
	interface EqualityKeyCollection : 
				EqualityCollection, KeyCollection{};

	// K e y S o r t e d C o l l e c t i o n
	interface KeySortedCollection : 
				KeyCollection, SortedCollection { 

		//  l o c a t i n g   e l e m e n t s
		boolean locate_first_element_with_key (
				in any      key, 
				in Iterator where)
			raises (KeyInvalid, IteratorInvalid); 
		boolean locate_last_element_with_key(
				in any      key, 
				in Iterator where)
			raises (KeyInvalid, IteratorInvalid);
		boolean locate_previous_element_with_key (
				in any      key, 
				in Iterator where)
			raises (KeyInvalid, IteratorInvalid); 
		boolean locate_previous_element_with_different_key(
				in Iterator  where)
			raises (IteratorInBetween, IteratorInvalid);

	};
	
	
	// E q u a l i t y S o r t e d C o l l e c t i o n
	interface EqualitySortedCollection : 
						EqualityCollection,  SortedCollection {
	
		//  l o c a t i n g   e l e m e n t s
		boolean locate_first_element (
				in any      element, 
				in Iterator where)
			raises (ElementInvalid, IteratorInvalid);
		boolean locate_last_element (
				in any      element, 
				in Iterator where)
			raises (ElementInvalid, IteratorInvalid);
		boolean locate_previous_element (
				in any      element, 
				in Iterator where)
			raises  (ElementInvalid, IteratorInvalid);
		boolean locate_previous_different_element (in Iterator where)
			raises  (IteratorInvalid);

	}; 
	
	
	// E q u a l i t y K e y S o r t e d C o l l e c t i o n
	interface EqualityKeySortedCollection : 
			EqualityCollection, KeyCollection,  SortedCollection {};


	// E q u a l i t y S e q u e n t i a l C o l l e c t i o n
	interface EqualitySequentialCollection : 
				EqualityCollection,  SequentialCollection  {

		//  l o c a t i n g   e l e m e n t s
		boolean locate_first_element_with_value (
				in any      element, 
				in Iterator where)
			raises (ElementInvalid, IteratorInvalid);
		boolean locate_last_element_with_value (
				in any      element, 
				in Iterator where)
			raises (ElementInvalid, IteratorInvalid);
		boolean locate_previous_element_with_value (
				in any      element, 
				in Iterator where)
			raises (ElementInvalid, IteratorInvalid);
		
	};
	
	
	// THE CONCRETE COLLECTION INTERFACES
	
	
	// K e y S e t
	interface KeySet: KeyCollection {};
	
	// K e y B a g
	interface KeyBag: KeyCollection {};
	
	// M a p
	interface Map : EqualityKeyCollection { 
	
		//  s e t   t h e o r e t i c a l   o p e r a t i o n s
		void difference_with (in Map collector) 
			raises (ElementInvalid);
		void add_difference (
				in Map collector1, 
				in Map collector2) 
			raises  (ElementInvalid);
		void intersection_with (in Map collector) 
			raises (ElementInvalid);
		void add_intersection (
				in Map collector1, 
				in Map collector2)
			raises  (ElementInvalid);
		void union_with (in Map collector) 
			raises (ElementInvalid);
		void add_union (
				in Map collector1, 
				in Map collector2) 
			raises (ElementInvalid);
		
		//   t e s t i n g   e q u a l i t y
		boolean equal (in Map collector) 
			raises (ElementInvalid);
		boolean not_equal (in Map collector) 
			raises(ElementInvalid);
		
	};
	
	
	// R e l a t i o n
	interface Relation : EqualityKeyCollection { 
	
		//  e q u a l ,   n o t _ e q u a l ,   a n d   t h e   
		//  s e t - t h e o r e t i c a l   o p e r a t i o n s   a s   
		//  d e f i n e d   f o r   M a p  
	}; 


	// S e t
	interface Set : EqualityCollection { 
	
		//  e q u a l ,   n o t _ e q u a l ,   a n d   t h e   s e t   
		//  t h e o r e t i c a l   o p e r a t i o n s   a s   
		//  d e f i n e d   f o r   M a p
	}; 
	
	
	// B a g
	interface Bag : EqualityCollection { 
	
		//  e q u a l ,   n o t _ e q u a l ,   a n d   t h e   s e t   
		//  t h e o r e t i c a l   o p e r a t i o n s   a s   d e f i n e d   
		//  d e f i n e d   f o r   M a p
	
	};
	
	
	// K e y S o r t e d S e t
	interface KeySortedSet : KeySortedCollection {
		long compare (	in KeySortedSet collector, 
						in Comparator comparison); 
	};
	
	
	// K e y S o r t e d B a g
	interface KeySortedBag : KeySortedCollection {
		long compare (	in KeySortedBag collector, 
						in Comparator comparison); 
	};


	// S o r t e d M a p
	interface SortedMap : EqualityKeySortedCollection { 
	
		//  e q u a l ,   n o t _ e q u a l ,   a n d   t h e   s e t   
		// t h e o r e t i c a l   o p e r a t i o n s
		long compare (	in SortedMap collector, 
						in Comparator comparison);
	};
	
	
	// S o r t e d R e l a t i o n
	interface SortedRelation : EqualityKeySortedCollection {
	
		//  e q u a l ,   n o t _ e q u a l ,   a n d   t h e   s e t
		//  t h e o r e t i c a l   o p e r a t i o n s
		long compare (	in SortedRelation collector, 
						in Comparator  comparison);
	};
	
	
	// S o r t e d S e t
	interface SortedSet : EqualitySortedCollection {
	
		// e q u a l ,   n o t _ e q u a l ,   a n d   t h e   s e t   
		// t h e o r e t i c a l   o p e r a t i o n s
		long compare (	in SortedSet collector, 
						in Comparator comparison);
	};
	
	
	// S o r t e d B a g
	interface SortedBag: EqualitySortedCollection { 
	
		//  e q u a l ,   n o t _ e q u a l ,   a n d   t h e   s e t
		// t h e o r e t i c a l   o p e r a t i o n s
		long compare (	in SortedBag collector, 
						in Comparator comparison);
	};
	
	
	// S e q u e n c e
	interface CSequence : SequentialCollection { 
		//  C o m p a r i s o n
		long compare (	in CSequence collector, 
						in Comparator comparison);
	};


	// E q u a l i t y S e q u e n c e
	interface EqualitySequence : EqualitySequentialCollection { 
	
		//  t e s t   o n   e q u a l i t y
		boolean equal     (in EqualitySequence collector);
		boolean not_equal (in EqualitySequence collector); 
		//   c o m p a r i s o n
		long compare (     in EqualitySequence collector, 
						   in Comparator       comparison);
	};
	
	
	// H e a p
	interface Heap : Collection {};


	//  R e s t r i c t e d   A c c e s s   C o l l e c t i o n s 

	interface RestrictedAccessCollection {

		//  g e t t i n g   i n f o r m a t i o n   o n   
		//      c o l l e c t i o n   s t a t e   
		boolean unfilled ();
		unsigned long size ();
		
		//  r e m o v i n g   e l e m e n t s
		void purge ();
	};


	// Q u e u e
	interface Queue : RestrictedAccessCollection {
	
		//  a d d i n g   e l e m e n t s
		void enqueue (in any element) raises (ElementInvalid);
		
		//   r e m o v i n g   e l e m e n t s
		void dequeue () raises (EmptyCollection);
		boolean element_dequeue (out any element) 
			raises (EmptyCollection);
	}; 
	
	
	// D e q u e
	interface Deque : RestrictedAccessCollection {
	
		//  a d d i n g   e l e m e n t s
		void enqueue_as_first (in any element) 
			raises (ElementInvalid);
		void enqueue_as_last (in any element) 
			raises(ElementInvalid);
	
		//  r e m o v i n g   e l e m e n t s
		void dequeue_first () raises (EmptyCollection);
		boolean element_dequeue_first (out any element) 
			raises (EmptyCollection);
		void dequeue_last () raises (EmptyCollection);
		boolean element_dequeue_last (out any element) 
			raises (EmptyCollection);
	
	};


	// S t a c k
	interface Stack: RestrictedAccessCollection {

		//  a d d i n g   e l e m e n t s
		void push (in any element) raises (ElementInvalid);
		
		//  r e m o v i n g   a n d   r e t r i e v i n g   
		//      e l e m e n t s
		void pop () raises (EmptyCollection);
		boolean element_pop (out any element) 
			raises (EmptyCollection);
		boolean top (out any element) 
			raises (EmptyCollection);
	};


	// P r i o r i t y Q u e u e
	interface PriorityQueue: RestrictedAccessCollection {
		//  a d d i n g   e l e m e n t s
		void enqueue (in any element) raises (ElementInvalid);
	
		//  r e m o v i n g   e l e m e n t s
		void dequeue () raises (EmptyCollection);
		boolean element_dequeue (out any element) 
			raises (EmptyCollection);
	};


	// COLLECTION FACTORIES

	// C o l l e c t i o n F a c t o r y
	interface CollectionFactory { 
		Collection generic_create (in ParameterList parameters)
			raises (ParameterInvalid); 
	};


	// C o l l e c t i o n F a c t o r i e s
	interface CollectionFactories : CollectionFactory { 
		boolean add_factory (
				in Istring            collection_interface, 
				in Istring            impl_category, 
				in Istring            impl_interface, 
				in CollectionFactory  c_factory);
		boolean remove_factory (
				in Istring collection_interface, 
				in Istring impl_category, 
				in Istring impl_interface); 
		Collection create (in ParameterList parameters) 
			raises (ParameterInvalid);
	}; 


	// R A C o l l e c t i o n F a ct o r y
	interface RACollectionFactory { 
		RestrictedAccessCollection generic_create (
				in ParameterList  parameters)
			raises (ParameterInvalid); 
	};


	// R A C o l l e c t i o n F a c t o r i e s
	interface RACollectionFactories : RACollectionFactory {
		boolean add_factory (
				in Istring              collection_interface, 
				in Istring              impl_category, 
				in Istring              impl_interface, 
				in RACollectionFactory  rac_factory); 
		boolean remove_factory (
				in Istring collection_interface, 
				in Istring impl_category, 
				in Istring impl_interface); 
		Collection create ( in ParameterList parameters) 
			raises (ParameterInvalid);
	}; 


	// K e y S e t F a c t o r y
	interface KeySetFactory : CollectionFactory { 
		KeySet create (	in Operations    ops, 
						in unsigned long expected_size);
	};

	// K e y B a g F a c t o r y
	interface KeyBagFactory : CollectionFactory {
		KeyBag create ( in Operations    ops, 
						in unsigned long expected_size);
	};


	// M a p F a c t o r y
	interface MapFactory : CollectionFactory { 
		Map create (in Operations    ops, 
					in unsigned long expected_size);
	};


	// R e l a t i o n F a c t o r y
	interface RelationFactory : CollectionFactory { 
		Relation create (	in Operations    ops, 
							in unsigned long expected_size);
	};


	// S e t F a c t o r y
	interface SetFactory : CollectionFactory {
		Set create (in Operations ops, 
					in unsigned long expected_size);
	};


	// B a g F a c t o r y
	interface BagFactory {
		Bag create (in Operations ops, 
					in unsigned long expected_size);
	};


	// K e y S o r t e d S e t F a c t o r y
	interface KeySortedSetFactory { 
		KeySortedSet create (in Operations    ops, 
							 in unsigned long expected_size);
	};


	// K e y S o r t e d B a g F a c t o r y
	interface KeySortedBagFactory : CollectionFactory {
		KeySortedBag create (in Operations    ops, 
							 in unsigned long expected_size);
	}; 


	// S o r t e d M a p F a c t o r y
	interface SortedMapFactory : CollectionFactory {
		SortedMap create (in Operations    ops, 
						  in unsigned long expected_size);
	};


	// S o r t e d R e l a t i o n F a c t o r y
	interface SortedRelationFactory : CollectionFactory {
		SortedRelation create (	in Operations    ops, 
								in unsigned long expected_size);
	};


	// S o r t e d S e t F a c t o r y
	interface SortedSetFactory : CollectionFactory {
		SortedSet create (	in Operations    ops, 
							in unsigned long expected_size);
	}; 


	// S o r t e d B a g F a c t o r y
	interface SortedBagFactory { 
		SortedBag create (	in Operations    ops, 
							in unsigned long expected_size);
	};


	// S e q u e n c e F a c t o r y
	interface SequenceFactory : CollectionFactory {
		CSequence create (	in Operations    ops, 
							in unsigned long expected_size);
	};


	// E q u a l i t y S e q u e n c e F a c t o r y
	interface EqualitySequenceFactory : CollectionFactory { 
		EqualitySequence create (in Operations    ops, 
								 in unsigned long expected_size);
	};


	// H e a p F a c t o r y
	interface HeapFactory : CollectionFactory {
		Heap create (in Operations    ops, 
					 in unsigned long expected_size);
	};


	// Q u e u e F a c t o r y
	interface QueueFactory : RACollectionFactory {
		Queue create (	in Operations ops, 
						in unsigned long expected_size);
	};


	// S t a c k F a c t o r y
	interface StackFactory : RACollectionFactory {
		Stack create (	in Operations    ops, 
						in unsigned long expected_size);
	};


	// D e q u e F a c t o r y
	interface DequeFactory : RACollectionFactory { 
		Deque create (	in Operations    ops, 
						in unsigned long expected_size);
	};


	// P r i o r i t y Q u e u e F a c t o r y
	interface PriorityQueueFactory : RACollectionFactory {
		PriorityQueue create (	in Operations    ops, 
								in unsigned long expected_size);
	};

};
#endif /* ifndef _COS_COLLECTION_IDL_ */

