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/cos/notification/CosNotifyChannelAdmin.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.Requests;
with PolyORB.Types;
with CosNotifyChannelAdmin.EventChannelFactory.Helper;
with PolyORB.CORBA_P.Interceptors_Hooks;
with PolyORB.CORBA_P.Exceptions;
with CosNotifyChannelAdmin.ConsumerAdmin.Helper;
with CosNotifyChannelAdmin.SupplierAdmin.Helper;
with CosNotifyFilter.FilterFactory.Helper;
with CosNotifyChannelAdmin.Helper;
with CORBA.ExceptionList;
with CosNotification.Helper;
with CosEventChannelAdmin.ConsumerAdmin.Helper;
with CosEventChannelAdmin.SupplierAdmin.Helper;
with CosNotification.AdminPropertiesAdmin;
with CosEventChannelAdmin.EventChannel;

package body CosNotifyChannelAdmin.EventChannel is

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

   ----------------------------
   -- get_MyFactory_Result_Ü --
   ----------------------------

   function get_MyFactory_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_MyFactory_Result_Ü);
   begin
      return (Name => get_MyFactory_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.EventChannelFactory.Helper.TC_EventChannelFactory),
      Arg_Modes => 0);
   end get_MyFactory_Result_Ü;

   -------------------
   -- get_MyFactory --
   -------------------

   function get_MyFactory
     (Self : Ref)
     return CosNotifyChannelAdmin.EventChannelFactory_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.EventChannelFactory_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);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_MyFactory_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_Ü);
      --  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_MyFactory",
         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_MyFactory;

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

   -----------------------------------------
   -- get_default_consumer_admin_Result_Ü --
   -----------------------------------------

   function get_default_consumer_admin_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_default_consumer_admin_Result_Ü);
   begin
      return (Name => get_default_consumer_admin_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.ConsumerAdmin.Helper.TC_ConsumerAdmin),
      Arg_Modes => 0);
   end get_default_consumer_admin_Result_Ü;

   --------------------------------
   -- get_default_consumer_admin --
   --------------------------------

   function get_default_consumer_admin
     (Self : Ref)
     return CosNotifyChannelAdmin.ConsumerAdmin.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.ConsumerAdmin.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);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_default_consumer_admin_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_Ü);
      --  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_default_consumer_admin",
         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_default_consumer_admin;

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

   -----------------------------------------
   -- get_default_supplier_admin_Result_Ü --
   -----------------------------------------

   function get_default_supplier_admin_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_default_supplier_admin_Result_Ü);
   begin
      return (Name => get_default_supplier_admin_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.SupplierAdmin.Helper.TC_SupplierAdmin),
      Arg_Modes => 0);
   end get_default_supplier_admin_Result_Ü;

   --------------------------------
   -- get_default_supplier_admin --
   --------------------------------

   function get_default_supplier_admin
     (Self : Ref)
     return CosNotifyChannelAdmin.SupplierAdmin.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.SupplierAdmin.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);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_default_supplier_admin_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_Ü);
      --  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_default_supplier_admin",
         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_default_supplier_admin;

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

   -----------------------------------------
   -- get_default_filter_factory_Result_Ü --
   -----------------------------------------

   function get_default_filter_factory_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_default_filter_factory_Result_Ü);
   begin
      return (Name => get_default_filter_factory_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyFilter.FilterFactory.Helper.TC_FilterFactory),
      Arg_Modes => 0);
   end get_default_filter_factory_Result_Ü;

   --------------------------------
   -- get_default_filter_factory --
   --------------------------------

   function get_default_filter_factory
     (Self : Ref)
     return CosNotifyFilter.FilterFactory.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyFilter.FilterFactory.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);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_default_filter_factory_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_Ü);
      --  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_default_filter_factory",
         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_default_filter_factory;

   new_for_consumers_Arg_Name_op_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("op");

   new_for_consumers_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

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

   --------------------------------
   -- new_for_consumers_Result_Ü --
   --------------------------------

   function new_for_consumers_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (new_for_consumers_Result_Ü);
   begin
      return (Name => new_for_consumers_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.ConsumerAdmin.Helper.TC_ConsumerAdmin),
      Arg_Modes => 0);
   end new_for_consumers_Result_Ü;

   -----------------------
   -- new_for_consumers --
   -----------------------

   procedure new_for_consumers
     (Self : Ref;
      op : CosNotifyChannelAdmin.InterFilterGroupOperator;
      id : out CosNotifyChannelAdmin.AdminID;
      Returns : out CosNotifyChannelAdmin.ConsumerAdmin.Ref)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.ConsumerAdmin.Ref
        renames Returns;
      pragma Warnings (Off, Returns);
      pragma Suppress (Validity_Check, Returns);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_op_Ü : aliased PolyORB.Any.Content'Class :=
        CosNotifyChannelAdmin.Helper.Internals.Wrap
           (op'Unrestricted_Access);
      Arg_Any_op_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyChannelAdmin.Helper.TC_InterFilterGroupOperator,
            Arg_CC_op_Ü'Unchecked_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Long
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyChannelAdmin.Helper.TC_AdminID,
            Arg_CC_id_Ü'Unchecked_Access);
      pragma Warnings (Off, id);
      pragma Suppress (Validity_Check, id);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        new_for_consumers_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_Ü,
         new_for_consumers_Arg_Name_op_Ü,
         PolyORB.Any.Any
           (Arg_Any_op_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         new_for_consumers_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_OUT);
      --  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 => "new_for_consumers",
         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_Ü);
   end new_for_consumers;

   new_for_suppliers_Arg_Name_op_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("op");

   new_for_suppliers_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

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

   --------------------------------
   -- new_for_suppliers_Result_Ü --
   --------------------------------

   function new_for_suppliers_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (new_for_suppliers_Result_Ü);
   begin
      return (Name => new_for_suppliers_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.SupplierAdmin.Helper.TC_SupplierAdmin),
      Arg_Modes => 0);
   end new_for_suppliers_Result_Ü;

   -----------------------
   -- new_for_suppliers --
   -----------------------

   procedure new_for_suppliers
     (Self : Ref;
      op : CosNotifyChannelAdmin.InterFilterGroupOperator;
      id : out CosNotifyChannelAdmin.AdminID;
      Returns : out CosNotifyChannelAdmin.SupplierAdmin.Ref)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.SupplierAdmin.Ref
        renames Returns;
      pragma Warnings (Off, Returns);
      pragma Suppress (Validity_Check, Returns);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_op_Ü : aliased PolyORB.Any.Content'Class :=
        CosNotifyChannelAdmin.Helper.Internals.Wrap
           (op'Unrestricted_Access);
      Arg_Any_op_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyChannelAdmin.Helper.TC_InterFilterGroupOperator,
            Arg_CC_op_Ü'Unchecked_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Long
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyChannelAdmin.Helper.TC_AdminID,
            Arg_CC_id_Ü'Unchecked_Access);
      pragma Warnings (Off, id);
      pragma Suppress (Validity_Check, id);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        new_for_suppliers_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_Ü,
         new_for_suppliers_Arg_Name_op_Ü,
         PolyORB.Any.Any
           (Arg_Any_op_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         new_for_suppliers_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_OUT);
      --  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 => "new_for_suppliers",
         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_Ü);
   end new_for_suppliers;

   get_consumeradmin_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

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

   --------------------------------
   -- get_consumeradmin_Result_Ü --
   --------------------------------

   function get_consumeradmin_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_consumeradmin_Result_Ü);
   begin
      return (Name => get_consumeradmin_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.ConsumerAdmin.Helper.TC_ConsumerAdmin),
      Arg_Modes => 0);
   end get_consumeradmin_Result_Ü;

   -----------------------
   -- get_consumeradmin --
   -----------------------

   function get_consumeradmin
     (Self : Ref;
      id : CosNotifyChannelAdmin.AdminID)
     return CosNotifyChannelAdmin.ConsumerAdmin.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.ConsumerAdmin.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_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Long
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyChannelAdmin.Helper.TC_AdminID,
            Arg_CC_id_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Exception_List_Ü : CORBA.ExceptionList.Ref;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_consumeradmin_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_consumeradmin_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      --  Create the Exception list
      CORBA.ExceptionList.Create_List
        (Exception_List_Ü);
      CORBA.ExceptionList.Add
        (Exception_List_Ü,
         CosNotifyChannelAdmin.Helper.TC_AdminNotFound);
      --  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_consumeradmin",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü,
         Exc_List => CORBA.ExceptionList.Internals.To_PolyORB_Ref
           (Exception_List_Ü));
      --  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_consumeradmin;

   get_supplieradmin_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

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

   --------------------------------
   -- get_supplieradmin_Result_Ü --
   --------------------------------

   function get_supplieradmin_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_supplieradmin_Result_Ü);
   begin
      return (Name => get_supplieradmin_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.SupplierAdmin.Helper.TC_SupplierAdmin),
      Arg_Modes => 0);
   end get_supplieradmin_Result_Ü;

   -----------------------
   -- get_supplieradmin --
   -----------------------

   function get_supplieradmin
     (Self : Ref;
      id : CosNotifyChannelAdmin.AdminID)
     return CosNotifyChannelAdmin.SupplierAdmin.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.SupplierAdmin.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_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Long
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyChannelAdmin.Helper.TC_AdminID,
            Arg_CC_id_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Exception_List_Ü : CORBA.ExceptionList.Ref;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_supplieradmin_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_supplieradmin_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      --  Create the Exception list
      CORBA.ExceptionList.Create_List
        (Exception_List_Ü);
      CORBA.ExceptionList.Add
        (Exception_List_Ü,
         CosNotifyChannelAdmin.Helper.TC_AdminNotFound);
      --  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_supplieradmin",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü,
         Exc_List => CORBA.ExceptionList.Internals.To_PolyORB_Ref
           (Exception_List_Ü));
      --  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_supplieradmin;

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

   -------------------------------------
   -- get_all_consumeradmins_Result_Ü --
   -------------------------------------

   function get_all_consumeradmins_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_all_consumeradmins_Result_Ü);
   begin
      return (Name => get_all_consumeradmins_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.Helper.TC_AdminIDSeq),
      Arg_Modes => 0);
   end get_all_consumeradmins_Result_Ü;

   ----------------------------
   -- get_all_consumeradmins --
   ----------------------------

   function get_all_consumeradmins
     (Self : Ref)
     return CosNotifyChannelAdmin.AdminIDSeq
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.AdminIDSeq;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CosNotifyChannelAdmin.Helper.Internals.Wrap
           (CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID.Sequence
              (Result_Ü)'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_all_consumeradmins_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_Ü);
      --  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_all_consumeradmins",
         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_all_consumeradmins;

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

   -------------------------------------
   -- get_all_supplieradmins_Result_Ü --
   -------------------------------------

   function get_all_supplieradmins_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_all_supplieradmins_Result_Ü);
   begin
      return (Name => get_all_supplieradmins_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.Helper.TC_AdminIDSeq),
      Arg_Modes => 0);
   end get_all_supplieradmins_Result_Ü;

   ----------------------------
   -- get_all_supplieradmins --
   ----------------------------

   function get_all_supplieradmins
     (Self : Ref)
     return CosNotifyChannelAdmin.AdminIDSeq
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.AdminIDSeq;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CosNotifyChannelAdmin.Helper.Internals.Wrap
           (CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID.Sequence
              (Result_Ü)'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_all_supplieradmins_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_Ü);
      --  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_all_supplieradmins",
         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_all_supplieradmins;

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

   ------------------------
   -- get_admin_Result_Ü --
   ------------------------

   function get_admin_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_admin_Result_Ü);
   begin
      return (Name => get_admin_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotification.Helper.TC_AdminProperties),
      Arg_Modes => 0);
   end get_admin_Result_Ü;

   ---------------
   -- get_admin --
   ---------------

   function get_admin
     (Self : Ref)
     return CosNotification.AdminProperties
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotification.AdminProperties;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CosNotification.Helper.Internals.Wrap
           (CosNotification.IDL_SEQUENCE_CosNotification_Property.Sequence
              (Result_Ü)'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_admin_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_Ü);
      --  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_admin",
         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_admin;

   set_admin_Arg_Name_admin_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("admin");

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

   ------------------------
   -- set_admin_Result_Ü --
   ------------------------

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

   ---------------
   -- set_admin --
   ---------------

   procedure set_admin
     (Self : Ref;
      admin : CosNotification.AdminProperties)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Arg_CC_admin_Ü : aliased PolyORB.Any.Content'Class :=
        CosNotification.Helper.Internals.Wrap
           (CosNotification.IDL_SEQUENCE_CosNotification_Property.Sequence
              (admin)'Unrestricted_Access);
      Arg_Any_admin_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotification.Helper.TC_AdminProperties,
            Arg_CC_admin_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Exception_List_Ü : CORBA.ExceptionList.Ref;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        set_admin_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_Ü,
         set_admin_Arg_Name_admin_Ü,
         PolyORB.Any.Any
           (Arg_Any_admin_Ü),
         PolyORB.Any.ARG_IN);
      --  Create the Exception list
      CORBA.ExceptionList.Create_List
        (Exception_List_Ü);
      CORBA.ExceptionList.Add
        (Exception_List_Ü,
         CosNotification.Helper.TC_UnsupportedAdmin);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "set_admin",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü,
         Exc_List => CORBA.ExceptionList.Internals.To_PolyORB_Ref
           (Exception_List_Ü));
      --  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_Ü);
   end set_admin;

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

   ----------------------------
   -- for_consumers_Result_Ü --
   ----------------------------

   function for_consumers_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (for_consumers_Result_Ü);
   begin
      return (Name => for_consumers_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosEventChannelAdmin.ConsumerAdmin.Helper.TC_ConsumerAdmin),
      Arg_Modes => 0);
   end for_consumers_Result_Ü;

   -------------------
   -- for_consumers --
   -------------------

   function for_consumers
     (Self : Ref)
     return CosEventChannelAdmin.ConsumerAdmin.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosEventChannelAdmin.ConsumerAdmin.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);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        for_consumers_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_Ü);
      --  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 => "for_consumers",
         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 for_consumers;

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

   ----------------------------
   -- for_suppliers_Result_Ü --
   ----------------------------

   function for_suppliers_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (for_suppliers_Result_Ü);
   begin
      return (Name => for_suppliers_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosEventChannelAdmin.SupplierAdmin.Helper.TC_SupplierAdmin),
      Arg_Modes => 0);
   end for_suppliers_Result_Ü;

   -------------------
   -- for_suppliers --
   -------------------

   function for_suppliers
     (Self : Ref)
     return CosEventChannelAdmin.SupplierAdmin.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosEventChannelAdmin.SupplierAdmin.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);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        for_suppliers_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_Ü);
      --  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 => "for_suppliers",
         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 for_suppliers;

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

   ----------------------
   -- destroy_Result_Ü --
   ----------------------

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

   -------------
   -- destroy --
   -------------

   procedure destroy
     (Self : Ref)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        destroy_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_Ü);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "destroy",
         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_Ü);
   end destroy;

   ----------
   -- 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,
         CosNotifyChannelAdmin.EventChannel.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,
            CosNotification.QoSAdmin.Repository_Id)
            or else CORBA.Is_Equivalent
              (Logical_Type_Id,
               CosNotification.AdminPropertiesAdmin.Repository_Id))
            or else CORBA.Is_Equivalent
              (Logical_Type_Id,
               CosEventChannelAdmin.EventChannel.Repository_Id)))
         or else False);
   end Is_A;

end CosNotifyChannelAdmin.EventChannel;
