// This file contains the OMG IDL module for the CIF MOF Repository.
//
// Editor: Dr. Philippe Merle - LIFL & INRIA

#pragma prefix "ccm.omg.org"
#include "ComponentIDL.idl"

module CIF
{
   interface ArtifactDefClass;
   interface ArtifactDef;
   typedef sequence<ArtifactDef> ArtifactDefSet;
   interface SegmentDefClass;
   interface SegmentDef;
   typedef sequence<SegmentDef> SegmentDefSet;
   interface ComponentImplDefClass;
   interface ComponentImplDef;
   typedef sequence<ComponentImplDef> ComponentImplDefSet;
   interface PolicyClass;
   interface Policy;
   typedef sequence<Policy> PolicySet;
   interface HomeImplDefClass;
   interface HomeImplDef;
   typedef sequence<HomeImplDef> HomeImplDefSet;
   interface CIFPackage;
   enum ComponentCategory {PROCESS, SESSION, ENTITY, SERVICE};

   interface ArtifactDefClass : BaseIDL::ContainedClass
   {
      readonly attribute ArtifactDefSet all_of_type_artifact_def;
      readonly attribute ArtifactDefSet all_of_class_artifact_def;
      ArtifactDef create_artifact_def (
         in string identifier,
         in string repository_id,
         in string version)
         raises (Reflective::MofError);
   };

   interface ArtifactDef : ArtifactDefClass, BaseIDL::Contained
   {
   }; // end of interface ArtifactDef

   interface SegmentDefClass : BaseIDL::ContainedClass
   {
      readonly attribute SegmentDefSet all_of_type_segment_def;
      readonly attribute SegmentDefSet all_of_class_segment_def;
      SegmentDef create_segment_def (
         in string identifier,
         in string repository_id,
         in string version,
         in boolean is_serialized)
         raises (Reflective::MofError);
   };

   interface SegmentDef : SegmentDefClass, BaseIDL::Contained
   {
      ArtifactDef artifact ()
         raises (Reflective::MofError);
      void set_artifact (in ArtifactDef new_value)
         raises (Reflective::MofError);
      ComponentIDL::ComponentFeatureSet features ()
         raises (Reflective::MofError);
      void set_features (in ComponentIDL::ComponentFeatureSet new_value)
         raises (Reflective::MofError);
      void add_features (in ComponentIDL::ComponentFeature new_element)
         raises (Reflective::MofError);
      void modify_features (
         in ComponentIDL::ComponentFeature old_element,
         in ComponentIDL::ComponentFeature new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_features (in ComponentIDL::ComponentFeature old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      PolicySet policies ()
         raises (Reflective::MofError);
      void set_policies (in PolicySet new_value)
         raises (Reflective::MofError);
      void unset_policies ()
         raises (Reflective::MofError);
      void add_policies (in Policy new_element)
         raises (Reflective::MofError);
      void modify_policies (
         in Policy old_element,
         in Policy new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_policies (in Policy old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      boolean is_serialized ()
         raises (Reflective::MofError);
      void set_is_serialized (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface SegmentDef

   interface ComponentImplDefClass : BaseIDL::ContainerClass
   {
      readonly attribute ComponentImplDefSet all_of_type_component_impl_def;
      readonly attribute ComponentImplDefSet all_of_class_component_impl_def;
      ComponentImplDef create_component_impl_def (
         in string identifier,
         in string repository_id,
         in string version,
         in ComponentCategory category)
         raises (Reflective::MofError);
   };

   interface ComponentImplDef : ComponentImplDefClass, BaseIDL::Container
   {
      ComponentIDL::ComponentDef component ()
         raises (Reflective::MofError);
      void set_component (in ComponentIDL::ComponentDef new_value)
         raises (Reflective::MofError);
      SegmentDefSet segments ()
         raises (Reflective::MofError);
      void set_segments (in SegmentDefSet new_value)
         raises (Reflective::MofError);
      void add_segments (in SegmentDef new_element)
         raises (Reflective::MofError);
      void modify_segments (
         in SegmentDef old_element,
         in SegmentDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_segments (in SegmentDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ComponentCategory category ()
         raises (Reflective::MofError);
      void set_category (in ComponentCategory new_value)
         raises (Reflective::MofError);
   }; // end of interface ComponentImplDef

   interface PolicyClass : Reflective::RefObject
   {
      readonly attribute PolicySet all_of_type_policy;
   };

   interface Policy : PolicyClass
   {
   }; // end of interface Policy

   interface HomeImplDefClass : BaseIDL::ContainerClass
   {
      readonly attribute HomeImplDefSet all_of_type_home_impl_def;
      readonly attribute HomeImplDefSet all_of_class_home_impl_def;
      HomeImplDef create_home_impl_def (
         in string identifier,
         in string repository_id,
         in string version)
         raises (Reflective::MofError);
   };

   interface HomeImplDef : HomeImplDefClass, BaseIDL::Container
   {
      ComponentIDL::HomeDef home ()
         raises (Reflective::MofError);
      void set_home (in ComponentIDL::HomeDef new_value)
         raises (Reflective::MofError);
      ComponentImplDef component_impl ()
         raises (Reflective::MofError);
      void set_component_impl (in ComponentImplDef new_value)
         raises (Reflective::MofError);
   }; // end of interface HomeImplDef

   struct AArtifactSegmentDefLink
   {
      ArtifactDef artifact;
      SegmentDef segment_def;
   };
   typedef sequence<AArtifactSegmentDefLink> AArtifactSegmentDefLinkSet;

   interface AArtifactSegmentDef : Reflective::RefAssociation
   {
      AArtifactSegmentDefLinkSet all_a_artifact_segment_def_links()
         raises (Reflective::MofError);
      boolean exists (
         in ArtifactDef artifact,
         in SegmentDef segment_def)
         raises (Reflective::MofError);
      ArtifactDef artifact (in SegmentDef segment_def)
         raises (Reflective::MofError);
      void add (
         in ArtifactDef artifact,
         in SegmentDef segment_def)
         raises (Reflective::MofError);
      void modify_artifact (
         in ArtifactDef artifact,
         in SegmentDef segment_def,
         in ArtifactDef new_artifact)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ArtifactDef artifact,
         in SegmentDef segment_def)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AArtifactSegmentDef

// ISSUE:: There are 2 Associations named Implements in the CIF Metamodel!
//         They should be renamed.
/*
   struct ImplementsLink
   {
      ComponentIDL::ComponentDef component;
      ComponentImplDef component_impl_def;
   };
   typedef sequence<ImplementsLink> ImplementsLinkSet;

   interface Implements : Reflective::RefAssociation
   {
      ImplementsLinkSet all_implements_links()
         raises (Reflective::MofError);
      boolean exists (
         in ComponentIDL::ComponentDef component,
         in ComponentImplDef component_impl_def)
         raises (Reflective::MofError);
      ComponentIDL::ComponentDef component (in ComponentImplDef component_impl_def)
         raises (Reflective::MofError);
      void add (
         in ComponentIDL::ComponentDef component,
         in ComponentImplDef component_impl_def)
         raises (Reflective::MofError);
      void modify_component (
         in ComponentIDL::ComponentDef component,
         in ComponentImplDef component_impl_def,
         in ComponentIDL::ComponentDef new_component)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ComponentIDL::ComponentDef component,
         in ComponentImplDef component_impl_def)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Implements
*/

   struct SegmentsLink
   {
      SegmentDef segments;
      ComponentImplDef component_impl_def;
   };
   typedef sequence<SegmentsLink> SegmentsLinkSet;

   interface Segments : Reflective::RefAssociation
   {
      SegmentsLinkSet all_segments_links()
         raises (Reflective::MofError);
      boolean exists (
         in SegmentDef segments,
         in ComponentImplDef component_impl_def)
         raises (Reflective::MofError);

// ISSUE: This operation should not be named as its immediate scope!
//
//      SegmentDefSet segments (in ComponentImplDef component_impl_def)
//         raises (Reflective::MofError);

      void add (
         in SegmentDef segments,
         in ComponentImplDef component_impl_def)
         raises (Reflective::MofError);
      void modify_segments (
         in SegmentDef segments,
         in ComponentImplDef component_impl_def,
         in SegmentDef new_segments)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in SegmentDef segments,
         in ComponentImplDef component_impl_def)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Segments

   struct ImplementedByLink
   {
      ComponentIDL::ComponentFeature features;
      SegmentDef segment_def;
   };
   typedef sequence<ImplementedByLink> ImplementedByLinkSet;

   interface ImplementedBy : Reflective::RefAssociation
   {
      ImplementedByLinkSet all_implemented_by_links()
         raises (Reflective::MofError);
      boolean exists (
         in ComponentIDL::ComponentFeature features,
         in SegmentDef segment_def)
         raises (Reflective::MofError);
      ComponentIDL::ComponentFeatureSet features (in SegmentDef segment_def)
         raises (Reflective::MofError);
      void add (
         in ComponentIDL::ComponentFeature features,
         in SegmentDef segment_def)
         raises (Reflective::MofError);
      void modify_features (
         in ComponentIDL::ComponentFeature features,
         in SegmentDef segment_def,
         in ComponentIDL::ComponentFeature new_features)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ComponentIDL::ComponentFeature features,
         in SegmentDef segment_def)
      raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ImplementedBy

   struct PoliciesLink
   {
      Policy policies;
      SegmentDef segment_def;
   };
   typedef sequence<PoliciesLink> PoliciesLinkSet;

   interface Policies : Reflective::RefAssociation
   {
      PoliciesLinkSet all_policies_links()
         raises (Reflective::MofError);
      boolean exists (
         in Policy policies,
         in SegmentDef segment_def)
         raises (Reflective::MofError);

// ISSUE: This operation should not be named as its immediate scope!
//
//      PolicySet policies (in SegmentDef segment_def)
//         raises (Reflective::MofError);

      void add (
         in Policy policies,
         in SegmentDef segment_def)
         raises (Reflective::MofError);
      void modify_policies (
         in Policy policies,
         in SegmentDef segment_def,
         in Policy new_policies)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Policy policies,
         in SegmentDef segment_def)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Policies

// ISSUE: There are 2 Associations named Implements in the CIF Metamodel!
//        They should be renamed.
/*
   struct ImplementsLink
   {
      ComponentIDL::HomeDef home;
      HomeImplDef home_impl_def;
   };
   typedef sequence<ImplementsLink> ImplementsLinkSet;

   interface Implements : Reflective::RefAssociation
   {
      ImplementsLinkSet all_implements_links()
         raises (Reflective::MofError);
      boolean exists (
         in ComponentIDL::HomeDef home,
         in HomeImplDef home_impl_def)
         raises (Reflective::MofError);
      ComponentIDL::HomeDef home (in HomeImplDef home_impl_def)
         raises (Reflective::MofError);
      void add (
         in ComponentIDL::HomeDef home,
         in HomeImplDef home_impl_def)
         raises (Reflective::MofError);
      void modify_home (
         in ComponentIDL::HomeDef home,
         in HomeImplDef home_impl_def,
         in ComponentIDL::HomeDef new_home)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ComponentIDL::HomeDef home,
         in HomeImplDef home_impl_def)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Implements
*/

   struct ManagesLink
   {
      ComponentImplDef component_impl;
      HomeImplDef home_impl;
   };
   typedef sequence<ManagesLink> ManagesLinkSet;

   interface Manages : Reflective::RefAssociation
   {
      ManagesLinkSet all_manages_links()
         raises (Reflective::MofError);
      boolean exists (
         in ComponentImplDef component_impl,
         in HomeImplDef home_impl)
         raises (Reflective::MofError);
      ComponentImplDef component_impl (in HomeImplDef home_impl)
         raises (Reflective::MofError);
      void add (
         in ComponentImplDef component_impl,
         in HomeImplDef home_impl)
         raises (Reflective::MofError);
      void modify_component_impl (
         in ComponentImplDef component_impl,
         in HomeImplDef home_impl,
         in ComponentImplDef new_component_impl)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ComponentImplDef component_impl,
         in HomeImplDef home_impl)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Manages

   interface CIFPackageFactory
   {
      CIFPackage create_cif_package ()
         raises (Reflective::MofError);
   };

   interface CIFPackage : Reflective::RefPackage
   {
      readonly attribute ArtifactDefClass artifact_def_ref;
      readonly attribute SegmentDefClass segment_def_ref;
      readonly attribute ComponentImplDefClass component_impl_def_ref;
      readonly attribute PolicyClass policy_ref;
      readonly attribute HomeImplDefClass home_impl_def_ref;
      readonly attribute AArtifactSegmentDef a_artifact_segment_def_ref;

// ISSUE: There are 2 Associations named Implements in the CIF Metamodel!
//        They should be renamed.
//
//      readonly attribute Implements implements_ref;

      readonly attribute Segments segments_ref;
      readonly attribute ImplementedBy implemented_by_ref;
      readonly attribute Policies policies_ref;

// ISSUE: There are 2 Associations named Implements in the CIF Metamodel!
//        They should be renamed.
//
//      readonly attribute Implements implements_ref;

      readonly attribute Manages manages_ref;
   };
}; // end of module CIF