pragma Style_Checks ("NM32766");
pragma Warnings (Off, "use of an anonymous access type allocator");
pragma Warnings (Off, "unnecessary with of ancestor");

---------------------------------------------------
--  This file has been generated automatically from
--  /pbulk/work/net/ada-polyorb/work/PolyORB-25.0/idls/CORBA_IDL/orb.idl
--  by IAC (IDL to Ada Compiler) 25.0w (rev. unknown).
---------------------------------------------------
--  NOTE: If you modify this file by hand, your
--  changes will be lost when you re-run the
--  IDL to Ada compiler.
---------------------------------------------------

with PolyORB.Any.NVList;
with CORBA.Object.Helper;
with CORBA.Object;
with PolyORB.Any;
with PolyORB.Types;
with CORBA.Helper;
with PolyORB.Requests;
with CORBA.Repository_Root.Contained.Helper;
with PolyORB.CORBA_P.Interceptors_Hooks;
with PolyORB.CORBA_P.Exceptions;
with CORBA.Repository_Root.Helper;
with CORBA.Repository_Root.PrimitiveDef.Helper;
with CORBA.Repository_Root.StringDef.Helper;
with CORBA.Repository_Root.WstringDef.Helper;
with CORBA.Repository_Root.IDLType.Helper;
with CORBA.Repository_Root.SequenceDef.Helper;
with CORBA.Repository_Root.ArrayDef.Helper;
with CORBA.Repository_Root.FixedDef.Helper;
with CORBA.Repository_Root.IRObject;

package body CORBA.Repository_Root.Repository is

   lookup_id_Arg_Name_search_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("search_id");

   lookup_id_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ------------------------
   -- lookup_id_Result_Ü --
   ------------------------

   function lookup_id_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (lookup_id_Result_Ü);
   begin
      return (Name => lookup_id_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.Contained.Helper.TC_Contained),
      Arg_Modes => 0);
   end lookup_id_Result_Ü;

   ---------------
   -- lookup_id --
   ---------------

   function lookup_id
     (Self : Ref;
      search_id : CORBA.RepositoryId)
     return CORBA.Repository_Root.Contained.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.Contained.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_search_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (search_id)'Unrestricted_Access);
      Arg_Any_search_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_search_id_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        lookup_id_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         lookup_id_Arg_Name_search_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_search_id_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "lookup_id",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end lookup_id;

   get_canonical_typecode_Arg_Name_tc_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("tc");

   get_canonical_typecode_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   -------------------------------------
   -- get_canonical_typecode_Result_Ü --
   -------------------------------------

   function get_canonical_typecode_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_canonical_typecode_Result_Ü);
   begin
      return (Name => get_canonical_typecode_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.TC_TypeCode),
      Arg_Modes => 0);
   end get_canonical_typecode_Result_Ü;

   ----------------------------
   -- get_canonical_typecode --
   ----------------------------

   function get_canonical_typecode
     (Self : Ref;
      tc : CORBA.TypeCode.Object)
     return CORBA.TypeCode.Object
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.TypeCode.Object;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (Result_Ü'Unrestricted_Access);
      Arg_CC_tc_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (tc'Unrestricted_Access);
      Arg_Any_tc_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_TypeCode,
            Arg_CC_tc_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_canonical_typecode_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         get_canonical_typecode_Arg_Name_tc_Ü,
         PolyORB.Any.Any
           (Arg_Any_tc_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "get_canonical_typecode",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end get_canonical_typecode;

   get_primitive_Arg_Name_kind_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("kind");

   get_primitive_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ----------------------------
   -- get_primitive_Result_Ü --
   ----------------------------

   function get_primitive_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_primitive_Result_Ü);
   begin
      return (Name => get_primitive_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.PrimitiveDef.Helper.TC_PrimitiveDef),
      Arg_Modes => 0);
   end get_primitive_Result_Ü;

   -------------------
   -- get_primitive --
   -------------------

   function get_primitive
     (Self : Ref;
      kind : CORBA.Repository_Root.PrimitiveKind)
     return CORBA.Repository_Root.PrimitiveDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.PrimitiveDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_kind_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (kind'Unrestricted_Access);
      Arg_Any_kind_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_PrimitiveKind,
            Arg_CC_kind_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_primitive_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         get_primitive_Arg_Name_kind_Ü,
         PolyORB.Any.Any
           (Arg_Any_kind_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "get_primitive",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end get_primitive;

   create_string_Arg_Name_bound_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("bound");

   create_string_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ----------------------------
   -- create_string_Result_Ü --
   ----------------------------

   function create_string_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_string_Result_Ü);
   begin
      return (Name => create_string_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.StringDef.Helper.TC_StringDef),
      Arg_Modes => 0);
   end create_string_Result_Ü;

   -------------------
   -- create_string --
   -------------------

   function create_string
     (Self : Ref;
      bound : CORBA.Unsigned_Long)
     return CORBA.Repository_Root.StringDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.StringDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_bound_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (bound'Unrestricted_Access);
      Arg_Any_bound_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Unsigned_Long,
            Arg_CC_bound_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_string_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_string_Arg_Name_bound_Ü,
         PolyORB.Any.Any
           (Arg_Any_bound_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_string",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_string;

   create_wstring_Arg_Name_bound_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("bound");

   create_wstring_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   -----------------------------
   -- create_wstring_Result_Ü --
   -----------------------------

   function create_wstring_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_wstring_Result_Ü);
   begin
      return (Name => create_wstring_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.WstringDef.Helper.TC_WstringDef),
      Arg_Modes => 0);
   end create_wstring_Result_Ü;

   --------------------
   -- create_wstring --
   --------------------

   function create_wstring
     (Self : Ref;
      bound : CORBA.Unsigned_Long)
     return CORBA.Repository_Root.WstringDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.WstringDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_bound_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (bound'Unrestricted_Access);
      Arg_Any_bound_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Unsigned_Long,
            Arg_CC_bound_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_wstring_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_wstring_Arg_Name_bound_Ü,
         PolyORB.Any.Any
           (Arg_Any_bound_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_wstring",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_wstring;

   create_sequence_Arg_Name_bound_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("bound");

   create_sequence_Arg_Name_element_type_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("element_type");

   create_sequence_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ------------------------------
   -- create_sequence_Result_Ü --
   ------------------------------

   function create_sequence_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_sequence_Result_Ü);
   begin
      return (Name => create_sequence_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.SequenceDef.Helper.TC_SequenceDef),
      Arg_Modes => 0);
   end create_sequence_Result_Ü;

   ---------------------
   -- create_sequence --
   ---------------------

   function create_sequence
     (Self : Ref;
      bound : CORBA.Unsigned_Long;
      element_type : CORBA.Repository_Root.IDLType.Ref)
     return CORBA.Repository_Root.SequenceDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.SequenceDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_bound_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (bound'Unrestricted_Access);
      Arg_Any_bound_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Unsigned_Long,
            Arg_CC_bound_Ü'Unchecked_Access);
      Arg_CC_element_type_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (element_type)'Unrestricted_Access);
      Arg_Any_element_type_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.IDLType.Helper.TC_IDLType,
            Arg_CC_element_type_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_sequence_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_sequence_Arg_Name_bound_Ü,
         PolyORB.Any.Any
           (Arg_Any_bound_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_sequence_Arg_Name_element_type_Ü,
         PolyORB.Any.Any
           (Arg_Any_element_type_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_sequence",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_sequence;

   create_array_Arg_Name_length_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("length");

   create_array_Arg_Name_element_type_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("element_type");

   create_array_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ---------------------------
   -- create_array_Result_Ü --
   ---------------------------

   function create_array_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_array_Result_Ü);
   begin
      return (Name => create_array_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.ArrayDef.Helper.TC_ArrayDef),
      Arg_Modes => 0);
   end create_array_Result_Ü;

   ------------------
   -- create_array --
   ------------------

   function create_array
     (Self : Ref;
      length : CORBA.Unsigned_Long;
      element_type : CORBA.Repository_Root.IDLType.Ref)
     return CORBA.Repository_Root.ArrayDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.ArrayDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_length_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (length'Unrestricted_Access);
      Arg_Any_length_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Unsigned_Long,
            Arg_CC_length_Ü'Unchecked_Access);
      Arg_CC_element_type_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (element_type)'Unrestricted_Access);
      Arg_Any_element_type_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.IDLType.Helper.TC_IDLType,
            Arg_CC_element_type_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_array_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_array_Arg_Name_length_Ü,
         PolyORB.Any.Any
           (Arg_Any_length_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_array_Arg_Name_element_type_Ü,
         PolyORB.Any.Any
           (Arg_Any_element_type_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_array",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_array;

   create_fixed_Arg_Name_IDL_digits_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("IDL_digits");

   create_fixed_Arg_Name_scale_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("scale");

   create_fixed_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ---------------------------
   -- create_fixed_Result_Ü --
   ---------------------------

   function create_fixed_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_fixed_Result_Ü);
   begin
      return (Name => create_fixed_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.FixedDef.Helper.TC_FixedDef),
      Arg_Modes => 0);
   end create_fixed_Result_Ü;

   ------------------
   -- create_fixed --
   ------------------

   function create_fixed
     (Self : Ref;
      IDL_digits : CORBA.Unsigned_Short;
      scale : CORBA.Short)
     return CORBA.Repository_Root.FixedDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.FixedDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_IDL_digits_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (IDL_digits'Unrestricted_Access);
      Arg_Any_IDL_digits_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Unsigned_Short,
            Arg_CC_IDL_digits_Ü'Unchecked_Access);
      Arg_CC_scale_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (scale'Unrestricted_Access);
      Arg_Any_scale_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Short,
            Arg_CC_scale_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_fixed_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_fixed_Arg_Name_IDL_digits_Ü,
         PolyORB.Any.Any
           (Arg_Any_IDL_digits_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_fixed_Arg_Name_scale_Ü,
         PolyORB.Any.Any
           (Arg_Any_scale_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_fixed",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_fixed;

   ----------
   -- Is_A --
   ----------

   function Is_A
     (Self : Ref;
      Logical_Type_Id : PolyORB.Std.String)
     return CORBA.Boolean
   is
   begin
      return (False
         or else (Is_A
           (Logical_Type_Id)
            or else CORBA.Object.Is_A
              (CORBA.Object.Ref
                 (Self),
               Logical_Type_Id)));
   end Is_A;

   ----------
   -- Is_A --
   ----------

   function Is_A
     (Logical_Type_Id : PolyORB.Std.String)
     return CORBA.Boolean
   is
   begin
      return (((CORBA.Is_Equivalent
        (Logical_Type_Id,
         CORBA.Repository_Root.Repository.Repository_Id)
         or else CORBA.Is_Equivalent
           (Logical_Type_Id,
            "IDL:omg.org/CORBA/Object:1.0"))
         or else (CORBA.Is_Equivalent
           (Logical_Type_Id,
            CORBA.Repository_Root.Container.Repository_Id)
            or else CORBA.Is_Equivalent
              (Logical_Type_Id,
               CORBA.Repository_Root.IRObject.Repository_Id)))
         or else False);
   end Is_A;

end CORBA.Repository_Root.Repository;
