Interstage Application Server アプリケーション作成ガイド （CORBAサービス編）

11.3.1 インタフェースリポジトリサービスが提供するインタフェース

  module CORBA{
      interface IRObject; 
      interface Contained    : IRObject{};
      interface Container    : IRObject{};
      interface IDLType      : IRObject{};
      interface Repository   : Container{};
      interface ModuleDef    : Container, Contained{};
      interface ConstantDef  : Contained{};
      interface TypedefDef   : Contained, IDLType{};
      interface StructDef    : TypedefDef{};
      interface UnionDef     : TypedefDef{};
      interface EnumDef      : TypedefDef{};
      interface AliasDef     : TypedefDef{};
      interface PrimitiveDef : IDLType{};
      interface StringDef    : IDLType{};
      interface WstringDef   : IDLType{};
      interface SequenceDef  : IDLType{};
      interface ArrayDef     : IDLType{};
      interface FixedDef     : IDLType{};
      interface ExceptionDef : Contained{};
      interface AttributeDef : Contained{};
      interface OperationDef : Contained{};
      interface InterfaceDef : Contained, Container, IDLType{};
   // interface TypeCode; 

      typedef string    Identifier; 
      typedef string    ScopedName; 
      typedef string    RepositoryId; 

      enum DefinitionKind{
          dk_none,dk_all,dk_Attribute,dk_Constant,dk_Exception, 
          dk_Interface,dk_Module,dk_Operation,dk_Typedef, 
          dk_Alias,dk_Struct,dk_Union,dk_Enum,dk_Primitive, 
          dk_String,dk_Sequence,dk_Array,dk_Repository,
        dk_Wstring,dk_Fixed
      };

      interface IRObject{
          // read interface
          readonly attribute DefinitionKind   def_kind; 

          // write interface
          void destroy();
      };

      typedef string    VersionSpec; 

      interface Contained; 
      interface Repository; 
      interface Container; 
   // interface TypeCode; 

      interface Contained:IRObject{
          // read/write interface
          attribute RepositoryId      id; 
          attribute Identifier        name; 
          attribute VersionSpec       version; 

          // read interface
          readonly attribute Container         defined_in; 
          readonly attribute ScopedName        absolute_name; 
          readonly attribute Repository        containing_repository; 
    
          struct Description{
              DefinitionKind    kind; 
              any               value; 
          };
  
          Description describe();

          // write interface
          void move(
              in Container       new_container, 
              in Identifier      new_name, 
              in VersionSpec     new_version
          ); 
      };

      interface ModuleDef; 
      interface ConstantDef; 
      interface IDLType; 
      interface StructDef; 
      interface UnionDef; 
      interface EnumDef; 
      interface AliasDef; 
      interface InterfaceDef; 
      interface ExceptionDef; 

      typedef sequence<InterfaceDef>InterfaceDefSeq; 

      typedef sequence<Contained>ContainedSeq; 

      struct StructMember{
          Identifier name; 
          TypeCode   type; 
          IDLType    type_def; 
      };

      typedef sequence<StructMember>StructMemberSeq; 

      struct UnionMember{
          Identifier name; 
          any        label; 
          TypeCode   type; 
          IDLType    type_def; 
      };

      typedef sequence<UnionMember>UnionMemberSeq; 

      typedef sequence<Identifier>EnumMemberSeq; 

      interface Container:IRObject{
          // read interface

          Contained lookup(in ScopedName search_name); 

          ContainedSeq contents(
              in DefinitionKind   limit_type, 
              in boolean          exclude_inherited
          ); 

          ContainedSeq lookup_name(
              in Identifier       search_name, 
              in long             levels_to_search, 
              in DefinitionKind   limit_type, 
              in boolean          exclude_inherited
          ); 

          struct Description{
              Contained           contained_object; 
              DefinitionKind      kind; 
              any                 value; 
         }; 

          typedef sequence<Description>DescriptionSeq; 

          DescriptionSeq describe_contents(
              in DefinitionKind   limit_type, 
              in boolean          exclude_inherited, 
              in long             max_returned_objs
          ); 
      
          // write interface

          ModuleDef create_module(
              in RepositoryId     id, 
              in Identifier       name, 
              in VersionSpec      version
          ); 
  
          ConstantDef create_constant(
              in RepositoryId     id, 
              in Identifier       name, 
              in VersionSpec      version, 
              in IDLType          type, 
              in any              value
          ); 

          ExceptionDef create_exception(
              in RepositoryId     id, 
              in Identifier       name, 
              in VersionSpec      version, 
              in StructMemberSeq  members
          ); 

          StructDef create_struct(
              in RepositoryId     id, 
              in Identifier       name, 
              in VersionSpec      version, 
              in StructMemberSeq  members
          ); 

          UnionDef create_union(
              in RepositoryId     id, 
              in Identifier       name, 
              in VersionSpec      version, 
              in IDLType          discriminator_type, 
              in UnionMemberSeq   members
          ); 

          EnumDef create_enum(
              in RepositoryId     id, 
              in Identifier       name, 
              in VersionSpec      version, 
              in EnumMemberSeq    members
          ); 

          AliasDef create_alias(
              in RepositoryId     id, 
              in Identifier       name, 
              in VersionSpec      version, 
              in IDLType          original_type
          ); 

          InterfaceDef create_interface(
              in RepositoryId     id, 
              in Identifier       name, 
              in VersionSpec      version, 
              in InterfaceDefSeq  base_interfaces
          ); 
      };

      interface IDLType:IRObject{
          readonly attribute TypeCode type; 
      };

      enum PrimitiveKind{
          pk_null,pk_void,pk_short,pk_long,pk_ushort,pk_ulong, 
          pk_float,pk_double,pk_boolean,pk_char,pk_octet, 
          pk_any,pk_TypeCode,pk_Principal,pk_string,pk_objref,
          pk_longlong,pk_ulonglong,pk_longdouble,pk_wchar,pk_wstring
      };

      interface PrimitiveDef; 
      interface StringDef; 
      interface WstringDef;
      interface SequenceDef; 
      interface ArrayDef; 
      interface FixedDef;
      interface Repository:Container{

          // read interface
          Contained lookup_id(in RepositoryId search_id); 
          PrimitiveDef get_primitive(in PrimitiveKind kind); 

          // write interface
          StringDef create_string(in unsigned long bound); 

          WstringDef create_wstring(in unsigned long bound);

          SequenceDef create_sequence(
              in unsigned long bound, 
              in IDLType element_type
          ); 

          ArrayDef create_array(
              in unsigned long length, 
              in IDLType element_type
          ); 

          FixedDef create_fixed(
              in unsigned short digits, 
              in short scale
          );

          void load();
          void destroy_rep();
      };

      interface ModuleDef:Container,Contained{
      };

      struct ModuleDescription{
          Identifier         name; 
          RepositoryId       id; 
          RepositoryId       defined_in; 
          VersionSpec        version; 
      };

      interface ConstantDef:Contained{
          readonly attribute TypeCode type; 
                   attribute IDLType  type_def; 
                   attribute any      value; 
      };

      struct ConstantDescription{
          Identifier         name; 
          RepositoryId       id; 
          RepositoryId       defined_in; 
          VersionSpec        version; 
          TypeCode           type; 
          any                value; 
      };

      interface TypedefDef:Contained,IDLType{
      };

      struct TypeDescription{
          Identifier         name; 
          RepositoryId       id; 
          RepositoryId       defined_in; 
          VersionSpec        version; 
          TypeCode           type; 
       };

      interface StructDef:TypedefDef{
                   attribute StructMemberSeq members; 
      };

      interface UnionDef:TypedefDef{
          readonly attribute TypeCode discriminator_type; 
                   attribute IDLType  discriminator_type_def; 
                   attribute UnionMemberSeq members; 
      };

      interface EnumDef:TypedefDef{
                   attribute EnumMemberSeq members; 
      };
      
      interface AliasDef:TypedefDef{
                   attribute IDLType original_type_def; 
      };
      
      interface PrimitiveDef:IDLType{
          readonly attribute PrimitiveKind kind; 
      };
      
      interface StringDef:IDLType{
                   attribute unsigned long bound; 
      };
   
      interface WstringDef:IDLType{
                   attribute unsigned long bound;
      };

      interface SequenceDef:IDLType{
                   attribute unsigned long bound; 
          readonly attribute TypeCode element_type; 
                   attribute IDLType  element_type_def; 
      };
      
      interface ArrayDef:IDLType{
                   attribute unsigned long length; 
          readonly attribute TypeCode element_type; 
                   attribute IDLType  element_type_def; 
      };
      
      interface ExceptionDef:Contained{
          readonly attribute TypeCode type; 
                   attribute StructMemberSeq members; 
      };

      struct ExceptionDescription{
          Identifier      name; 
          RepositoryId    id; 
          RepositoryId    defined_in; 
          VersionSpec     version; 
          TypeCode        type; 
      };

      enum AttributeMode{ATTR_NORMAL,ATTR_READONLY};

      interface AttributeDef:Contained{
          readonly attribute TypeCode type; 
                   attribute IDLType  type_def; 
                   attribute AttributeMode mode; 
      };

      struct AttributeDescription{
          Identifier      name; 
          RepositoryId    id; 
          RepositoryId    defined_in; 
          VersionSpec     version; 
          TypeCode        type; 
          AttributeMode   mode; 
      };

      enum OperationMode{OP_NORMAL,OP_ONEWAY};
   
      enum ParameterMode{PARAM_IN,PARAM_OUT,PARAM_INOUT};

      struct ParameterDescription{
          Identifier      name; 
          TypeCode        type; 
          IDLType         type_def; 
          ParameterMode   mode; 
      };
      
      typedef sequence<ParameterDescription>ParDescriptionSeq; 
      typedef Identifier ContextIdentifier; 
      typedef sequence<ContextIdentifier>ContextIdSeq; 
      
      typedef sequence<ExceptionDef>ExceptionDefSeq; 
      typedef sequence<ExceptionDescription>ExcDescriptionSeq; 

      interface OperationDef:Contained{
          readonly attribute TypeCode result; 
                   attribute IDLType  result_def; 
                   attribute ParDescriptionSeq params; 
                   attribute OperationMode mode; 
                   attribute ContextIdSeq contexts; 
                   attribute ExceptionDefSeq exceptions; 
      };
      
      struct OperationDescription{
          Identifier      name; 
          RepositoryId    id; 
          RepositoryId    defined_in; 
          VersionSpec     version; 
          TypeCode        result; 
          OperationMode   mode; 
          ContextIdSeq    contexts; 
          ParDescriptionSeq parameters; 
          ExcDescriptionSeq exceptions; 
      };
   
      typedef sequence<RepositoryId>RepositoryIdSeq; 
      typedef sequence<OperationDescription>OpDescriptionSeq; 
      typedef sequence<AttributeDescription>AttrDescriptionSeq; 

      interface InterfaceDef:Container,Contained,IDLType{
          // read/write interface
          attribute InterfaceDefSeq base_interfaces; 

          // read interface
          boolean is_a(in RepositoryId interface_id);   // (注)

          struct FullInterfaceDescription{
              Identifier      name; 
              RepositoryId    id; 
              RepositoryId    defined_in; 
              VersionSpec     version; 
              OpDescriptionSeq operations; 
              AttrDescriptionSeq attributes; 
              RepositoryIdSeq base_interfaces; 
              TypeCode        type; 
          };
          FullInterfaceDescription describe_interface();

          // write interface

          AttributeDef create_attribute(
              in RepositoryId id, 
              in Identifier name, 
              in VersionSpec version, 
              in IDLType type, 
              in AttributeMode mode
          ); 

          OperationDef create_operation(
              in RepositoryId id, 
              in Identifier name, 
              in VersionSpec version, 
              in IDLType result, 
              in OperationMode mode, 
              in ParDescriptionSeq params, 
              in ExceptionDefSeq exceptions, 
              in ContextIdSeq contexts
          ); 
      };

      struct InterfaceDescription{
          Identifier      name; 
          RepositoryId    id; 
          RepositoryId    defined_in; 
          VersionSpec     version; 
          RepositoryIdSeq base_interfaces; 
      };

      interface InterfaceRep{
          // write interface
          Repository   create_repository();
          boolean      create_primitives();
      };
  };

注) OOCOBOLで使用する場合、メソッド名はIDL-IS_Aです。