#ifndef Reflective_IDL
#define Reflective_IDL

module Reflective {
   interface RefBaseObject;   
   interface RefObject;  
   typedef sequence < RefObject > RefObjectUList;   
   typedef sequence < RefObject > RefObjectSet;   
   interface RefAssociation;    
   interface RefPackage;  
   typedef RefObject DesignatorType;
   typedef any ValueType;
   typedef sequence < ValueType > ValueTypeList;
   typedef sequence < RefObject, 2 > Link;
   typedef sequence < ValueType > ErroneousValues;    
   const string UNDERFLOW_VIOLATION = "underflow";  
   const string OVERFLOW_VIOLATION = "overflow";  
   const string DUPLICATE_VIOLATION = "duplicate";  
   const string TYPE_CLOSURE_VIOLATION = "type closure";  
   const string COMPOSITION_VIOLATION = "composition";  
   const string INVALID_OBJECT_VIOLATION = "invalid object";    
   struct StructuralViolation {    
      string violation_kind;     
      RefObject element_designator;
      ErroneousValues offending_values;
   };  
   typedef sequence < StructuralViolation > StructuralViolationSet;    
   exception StructuralError {    
      StructuralViolationSet violations;  
   };
   struct ConstraintViolation {    
      RefObject constraint_designator;
      ErroneousValues offending_values;
      string explanation_text;
   };  
   exception ConstraintError {    
      ConstraintViolation violation;   
   };
   struct ErrorDescription {    
      string error_name;     
      ErroneousValues offending_values;     
      string explanation_text;   
   };    
   exception SemanticError {    
      ErrorDescription error;  
   };
   exception NotFound {};
   exception NotSet {};
   exception BadPosition {};
   exception AlreadyCreated {};
   exception InvalidLink {};
   exception InvalidDesignator {    
      DesignatorType designator;    
      string element_kind;  
   };
   exception InvalidValue {    
      DesignatorType designator;    
      string element_kind;    
      ValueType value;    
      TypeCode type_expected;   
   };
   exception InvalidObject {    
      DesignatorType designator;
      RefObject obj;
      TypeCode type_expected;   
   };
   exception MissingParameter {    
      DesignatorType designator;
   };
   exception TooManyParameters {};
   exception OtherException {
      DesignatorType exception_designator;
      ValueTypeList exception_values;
   };
   interface RefBaseObject {
      DesignatorType meta_object ();
      boolean itself (in RefBaseObject other_object);
      RefBaseObject repository_container ();
   }; 
   interface RefObject : RefBaseObject {
      boolean is_instance_of (in DesignatorType obj_type,                    
                              in boolean consider_subtypes);
      RefObject create_instance (in ValueTypeList args)
         raises (TooManyParameters,
                 MissingParameter,
                 InvalidValue,
                 AlreadyCreated,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
      RefObjectSet all_objects (in boolean include_subtypes);
      void set_value (in DesignatorType feature,
                      in ValueType value)
         raises (InvalidDesignator,
                 InvalidValue,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
      ValueType value (in DesignatorType feature)
         raises (InvalidDesignator,
                 SemanticError);
      void add_value (in DesignatorType feature,
                      in ValueType value)
         raises (InvalidDesignator,
                 InvalidValue,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
      void add_value_before (in DesignatorType feature,
                             in ValueType value,
                             in ValueType existing_value)
         raises (InvalidDesignator,
                 InvalidValue,
                 NotFound,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
      void add_value_at (in DesignatorType feature,
                         in ValueType value,
                         in long position)
         raises (InvalidDesignator,
                 InvalidValue,
                 BadPosition,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
      void modify_value (in DesignatorType feature,
                         in ValueType existing_value,
                         in ValueType new_value)
         raises (InvalidDesignator,
                 InvalidValue,
                 NotFound,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
      void modify_value_at (in DesignatorType feature,
                            in ValueType new_value,
                            in long position)
         raises (InvalidDesignator,
                 InvalidValue,
                 BadPosition,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
      void remove_value (in DesignatorType feature,
                         in ValueType existing_value)
         raises (InvalidDesignator,
                 InvalidValue,
                 NotFound,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
      void remove_value_at (in DesignatorType feature,
                            in long position)
         raises (InvalidDesignator,
                 InvalidValue,
                 BadPosition,
                 NotFound,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
      ValueType invoke_operation (in DesignatorType requested_operation,
                                  in ValueTypeList args)
         raises (InvalidDesignator,
                 TooManyParameters,
                 MissingParameter,
                 InvalidValue,
                 OtherException,
                 ConstraintError,
                 SemanticError);
   }; 
   interface RefAssociation : RefBaseObject {
      boolean link_exists (in Link some_link)      
         raises (InvalidLink,
                 SemanticError);
      RefObjectUList query (in DesignatorType query_end,
                            in RefObject query_object)      
         raises (InvalidDesignator,
                 InvalidObject,
                 SemanticError);
      void add_link (in Link new_link)      
         raises (InvalidLink,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
      void add_link_before (in Link new_link,
                            in DesignatorType position_end,
                            in RefObject position_value)      
         raises (InvalidDesignator,
                 InvalidObject,
                 InvalidLink,
                 NotFound,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
      void modify_link (in Link existing_link,
                        in DesignatorType position_end,
                        in RefObject position_value)      
         raises (InvalidDesignator,
                 InvalidObject,
                 InvalidLink,
                 NotFound,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
      void remove_link (in Link existing_link)      
         raises (InvalidLink,
                 NotFound,
                 StructuralError,
                 ConstraintError,
                 SemanticError);
   }; 
   interface RefPackage : RefBaseObject {
      RefObject get_class_ref (in DesignatorType type)
         raises (InvalidDesignator);    
      RefAssociation get_association (in DesignatorType association)      
         raises (InvalidDesignator);    
      RefPackage get_nested_package (in DesignatorType nested_package)      
         raises (InvalidDesignator);
   }; 
}; 
 
#endif