pragma Style_Checks ("NM32766");

---------------------------------------------------
--  This file has been generated automatically from
--  /wrkdirs/usr/ports/net/polyorb/work/polyorb-2.9.0/idls/cos/notification/CosNotifyChannelAdmin.idl
--  by IAC (IDL to Ada Compiler) 2.9.0 (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 PolyORB.Any;
with PolyORB.Requests;
with PolyORB.Types;
with CORBA.Object;
with CosNotifyChannelAdmin.Helper;
with PolyORB.CORBA_P.Interceptors_Hooks;
with PolyORB.CORBA_P.Exceptions;
with CORBA.Object.Helper;
with CosNotifyChannelAdmin.EventChannel.Helper;
with CosNotifyFilter.MappingFilter.Helper;
with CORBA.ExceptionList;
with CosNotifyChannelAdmin.ProxySupplier.Helper;
with CosNotification.Helper;
with CosNotifyComm.Helper;
with CosNotifyFilter.Filter.Helper;
with CosNotifyFilter.Helper;
with CosEventChannelAdmin.ProxyPushSupplier.Helper;
with CosEventChannelAdmin.ProxyPullSupplier.Helper;
with CosNotifyComm.NotifySubscribe;
with CosNotifyFilter.FilterAdmin;
with CosEventChannelAdmin.ConsumerAdmin;

package body CosNotifyChannelAdmin.ConsumerAdmin is

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

   -----------------------
   -- get_MyID_Result_Ü --
   -----------------------

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

   --------------
   -- get_MyID --
   --------------

   function get_MyID
     (Self : Ref)
     return CosNotifyChannelAdmin.AdminID
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.AdminID;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Long
              (Result_Ü)'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_MyID_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_MyID",
         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_MyID;

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

   ----------------------------
   -- get_MyChannel_Result_Ü --
   ----------------------------

   function get_MyChannel_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_MyChannel_Result_Ü);
   begin
      return (Name => get_MyChannel_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.EventChannel.Helper.TC_EventChannel),
      Arg_Modes => 0);
   end get_MyChannel_Result_Ü;

   -------------------
   -- get_MyChannel --
   -------------------

   function get_MyChannel
     (Self : Ref)
     return CosNotifyChannelAdmin.EventChannel_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.EventChannel_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_MyChannel_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_MyChannel",
         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_MyChannel;

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

   -----------------------------
   -- get_MyOperator_Result_Ü --
   -----------------------------

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

   --------------------
   -- get_MyOperator --
   --------------------

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

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

   ----------------------------------
   -- get_priority_filter_Result_Ü --
   ----------------------------------

   function get_priority_filter_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_priority_filter_Result_Ü);
   begin
      return (Name => get_priority_filter_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyFilter.MappingFilter.Helper.TC_MappingFilter),
      Arg_Modes => 0);
   end get_priority_filter_Result_Ü;

   -------------------------
   -- get_priority_filter --
   -------------------------

   function get_priority_filter
     (Self : Ref)
     return CosNotifyFilter.MappingFilter.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyFilter.MappingFilter.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_priority_filter_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_priority_filter",
         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_priority_filter;

   set_priority_filter_Arg_Name_To_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("To");

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

   ----------------------------------
   -- set_priority_filter_Result_Ü --
   ----------------------------------

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

   -------------------------
   -- set_priority_filter --
   -------------------------

   procedure set_priority_filter
     (Self : Ref;
      To : CosNotifyFilter.MappingFilter.Ref)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Arg_CC_To_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (To)'Unrestricted_Access);
      Arg_Any_To_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyFilter.MappingFilter.Helper.TC_MappingFilter,
            Arg_CC_To_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        set_priority_filter_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_priority_filter_Arg_Name_To_Ü,
         PolyORB.Any.Any
           (Arg_Any_To_Ü),
         PolyORB.Any.ARG_IN);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "_set_priority_filter",
         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 set_priority_filter;

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

   ----------------------------------
   -- get_lifetime_filter_Result_Ü --
   ----------------------------------

   function get_lifetime_filter_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_lifetime_filter_Result_Ü);
   begin
      return (Name => get_lifetime_filter_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyFilter.MappingFilter.Helper.TC_MappingFilter),
      Arg_Modes => 0);
   end get_lifetime_filter_Result_Ü;

   -------------------------
   -- get_lifetime_filter --
   -------------------------

   function get_lifetime_filter
     (Self : Ref)
     return CosNotifyFilter.MappingFilter.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyFilter.MappingFilter.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_lifetime_filter_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_lifetime_filter",
         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_lifetime_filter;

   set_lifetime_filter_Arg_Name_To_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("To");

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

   ----------------------------------
   -- set_lifetime_filter_Result_Ü --
   ----------------------------------

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

   -------------------------
   -- set_lifetime_filter --
   -------------------------

   procedure set_lifetime_filter
     (Self : Ref;
      To : CosNotifyFilter.MappingFilter.Ref)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Arg_CC_To_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (To)'Unrestricted_Access);
      Arg_Any_To_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyFilter.MappingFilter.Helper.TC_MappingFilter,
            Arg_CC_To_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        set_lifetime_filter_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_lifetime_filter_Arg_Name_To_Ü,
         PolyORB.Any.Any
           (Arg_Any_To_Ü),
         PolyORB.Any.ARG_IN);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "_set_lifetime_filter",
         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 set_lifetime_filter;

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

   ---------------------------------
   -- get_pull_suppliers_Result_Ü --
   ---------------------------------

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

   ------------------------
   -- get_pull_suppliers --
   ------------------------

   function get_pull_suppliers
     (Self : Ref)
     return CosNotifyChannelAdmin.ProxyIDSeq
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.ProxyIDSeq;
      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_ProxyID.Sequence
              (Result_Ü)'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_pull_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 => "_get_pull_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 get_pull_suppliers;

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

   ---------------------------------
   -- get_push_suppliers_Result_Ü --
   ---------------------------------

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

   ------------------------
   -- get_push_suppliers --
   ------------------------

   function get_push_suppliers
     (Self : Ref)
     return CosNotifyChannelAdmin.ProxyIDSeq
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.ProxyIDSeq;
      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_ProxyID.Sequence
              (Result_Ü)'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_push_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 => "_get_push_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 get_push_suppliers;

   get_proxy_supplier_Arg_Name_proxy_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("proxy_id");

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

   ---------------------------------
   -- get_proxy_supplier_Result_Ü --
   ---------------------------------

   function get_proxy_supplier_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_proxy_supplier_Result_Ü);
   begin
      return (Name => get_proxy_supplier_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.ProxySupplier.Helper.TC_ProxySupplier),
      Arg_Modes => 0);
   end get_proxy_supplier_Result_Ü;

   ------------------------
   -- get_proxy_supplier --
   ------------------------

   function get_proxy_supplier
     (Self : Ref;
      proxy_id : CosNotifyChannelAdmin.ProxyID)
     return CosNotifyChannelAdmin.ProxySupplier.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.ProxySupplier.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_proxy_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Long
              (proxy_id)'Unrestricted_Access);
      Arg_Any_proxy_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyChannelAdmin.Helper.TC_ProxyID,
            Arg_CC_proxy_id_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Exception_List_Ü : CORBA.ExceptionList.Ref;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_proxy_supplier_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_proxy_supplier_Arg_Name_proxy_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_proxy_id_Ü),
         PolyORB.Any.ARG_IN);
      --  Create the Exception list
      CORBA.ExceptionList.Create_List
        (Exception_List_Ü);
      CORBA.ExceptionList.Add
        (Exception_List_Ü,
         CosNotifyChannelAdmin.Helper.TC_ProxyNotFound);
      --  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_proxy_supplier",
         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_proxy_supplier;

   obtain_notification_pull_supplier_Arg_Name_ctype_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("ctype");

   obtain_notification_pull_supplier_Arg_Name_proxy_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("proxy_id");

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

   ------------------------------------------------
   -- obtain_notification_pull_supplier_Result_Ü --
   ------------------------------------------------

   function obtain_notification_pull_supplier_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (obtain_notification_pull_supplier_Result_Ü);
   begin
      return (Name => obtain_notification_pull_supplier_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.ProxySupplier.Helper.TC_ProxySupplier),
      Arg_Modes => 0);
   end obtain_notification_pull_supplier_Result_Ü;

   ---------------------------------------
   -- obtain_notification_pull_supplier --
   ---------------------------------------

   procedure obtain_notification_pull_supplier
     (Self : Ref;
      ctype : CosNotifyChannelAdmin.ClientType;
      proxy_id : out CosNotifyChannelAdmin.ProxyID;
      Returns : out CosNotifyChannelAdmin.ProxySupplier.Ref)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.ProxySupplier.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_ctype_Ü : aliased PolyORB.Any.Content'Class :=
        CosNotifyChannelAdmin.Helper.Internals.Wrap
           (ctype'Unrestricted_Access);
      Arg_Any_ctype_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyChannelAdmin.Helper.TC_ClientType,
            Arg_CC_ctype_Ü'Unchecked_Access);
      Arg_CC_proxy_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Long
              (proxy_id)'Unrestricted_Access);
      Arg_Any_proxy_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyChannelAdmin.Helper.TC_ProxyID,
            Arg_CC_proxy_id_Ü'Unchecked_Access);
      pragma Warnings (Off, proxy_id);
      pragma Suppress (Validity_Check, proxy_id);
      Request_Ü : aliased PolyORB.Requests.Request;
      Exception_List_Ü : CORBA.ExceptionList.Ref;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        obtain_notification_pull_supplier_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_Ü,
         obtain_notification_pull_supplier_Arg_Name_ctype_Ü,
         PolyORB.Any.Any
           (Arg_Any_ctype_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         obtain_notification_pull_supplier_Arg_Name_proxy_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_proxy_id_Ü),
         PolyORB.Any.ARG_OUT);
      --  Create the Exception list
      CORBA.ExceptionList.Create_List
        (Exception_List_Ü);
      CORBA.ExceptionList.Add
        (Exception_List_Ü,
         CosNotifyChannelAdmin.Helper.TC_AdminLimitExceeded);
      --  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 => "obtain_notification_pull_supplier",
         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 obtain_notification_pull_supplier;

   obtain_notification_push_supplier_Arg_Name_ctype_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("ctype");

   obtain_notification_push_supplier_Arg_Name_proxy_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("proxy_id");

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

   ------------------------------------------------
   -- obtain_notification_push_supplier_Result_Ü --
   ------------------------------------------------

   function obtain_notification_push_supplier_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (obtain_notification_push_supplier_Result_Ü);
   begin
      return (Name => obtain_notification_push_supplier_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyChannelAdmin.ProxySupplier.Helper.TC_ProxySupplier),
      Arg_Modes => 0);
   end obtain_notification_push_supplier_Result_Ü;

   ---------------------------------------
   -- obtain_notification_push_supplier --
   ---------------------------------------

   procedure obtain_notification_push_supplier
     (Self : Ref;
      ctype : CosNotifyChannelAdmin.ClientType;
      proxy_id : out CosNotifyChannelAdmin.ProxyID;
      Returns : out CosNotifyChannelAdmin.ProxySupplier.Ref)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyChannelAdmin.ProxySupplier.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_ctype_Ü : aliased PolyORB.Any.Content'Class :=
        CosNotifyChannelAdmin.Helper.Internals.Wrap
           (ctype'Unrestricted_Access);
      Arg_Any_ctype_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyChannelAdmin.Helper.TC_ClientType,
            Arg_CC_ctype_Ü'Unchecked_Access);
      Arg_CC_proxy_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Long
              (proxy_id)'Unrestricted_Access);
      Arg_Any_proxy_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyChannelAdmin.Helper.TC_ProxyID,
            Arg_CC_proxy_id_Ü'Unchecked_Access);
      pragma Warnings (Off, proxy_id);
      pragma Suppress (Validity_Check, proxy_id);
      Request_Ü : aliased PolyORB.Requests.Request;
      Exception_List_Ü : CORBA.ExceptionList.Ref;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        obtain_notification_push_supplier_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_Ü,
         obtain_notification_push_supplier_Arg_Name_ctype_Ü,
         PolyORB.Any.Any
           (Arg_Any_ctype_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         obtain_notification_push_supplier_Arg_Name_proxy_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_proxy_id_Ü),
         PolyORB.Any.ARG_OUT);
      --  Create the Exception list
      CORBA.ExceptionList.Create_List
        (Exception_List_Ü);
      CORBA.ExceptionList.Add
        (Exception_List_Ü,
         CosNotifyChannelAdmin.Helper.TC_AdminLimitExceeded);
      --  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 => "obtain_notification_push_supplier",
         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 obtain_notification_push_supplier;

   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;

   subscription_change_Arg_Name_added_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("added");

   subscription_change_Arg_Name_removed_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("removed");

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

   ----------------------------------
   -- subscription_change_Result_Ü --
   ----------------------------------

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

   -------------------------
   -- subscription_change --
   -------------------------

   procedure subscription_change
     (Self : Ref;
      added : CosNotification.EventTypeSeq;
      removed : CosNotification.EventTypeSeq)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Arg_CC_added_Ü : aliased PolyORB.Any.Content'Class :=
        CosNotification.Helper.Internals.Wrap
           (CosNotification.IDL_SEQUENCE_CosNotification_EventType.Sequence
              (added)'Unrestricted_Access);
      Arg_Any_added_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotification.Helper.TC_EventTypeSeq,
            Arg_CC_added_Ü'Unchecked_Access);
      Arg_CC_removed_Ü : aliased PolyORB.Any.Content'Class :=
        CosNotification.Helper.Internals.Wrap
           (CosNotification.IDL_SEQUENCE_CosNotification_EventType.Sequence
              (removed)'Unrestricted_Access);
      Arg_Any_removed_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotification.Helper.TC_EventTypeSeq,
            Arg_CC_removed_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Exception_List_Ü : CORBA.ExceptionList.Ref;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        subscription_change_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_Ü,
         subscription_change_Arg_Name_added_Ü,
         PolyORB.Any.Any
           (Arg_Any_added_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         subscription_change_Arg_Name_removed_Ü,
         PolyORB.Any.Any
           (Arg_Any_removed_Ü),
         PolyORB.Any.ARG_IN);
      --  Create the Exception list
      CORBA.ExceptionList.Create_List
        (Exception_List_Ü);
      CORBA.ExceptionList.Add
        (Exception_List_Ü,
         CosNotifyComm.Helper.TC_InvalidEventType);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "subscription_change",
         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 subscription_change;

   add_filter_Arg_Name_new_filter_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("new_filter");

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

   -------------------------
   -- add_filter_Result_Ü --
   -------------------------

   function add_filter_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (add_filter_Result_Ü);
   begin
      return (Name => add_filter_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyFilter.Helper.TC_FilterID),
      Arg_Modes => 0);
   end add_filter_Result_Ü;

   ----------------
   -- add_filter --
   ----------------

   function add_filter
     (Self : Ref;
      new_filter : CosNotifyFilter.Filter.Ref)
     return CosNotifyFilter.FilterID
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyFilter.FilterID;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Long
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_new_filter_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (new_filter)'Unrestricted_Access);
      Arg_Any_new_filter_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyFilter.Filter.Helper.TC_Filter,
            Arg_CC_new_filter_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        add_filter_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_Ü,
         add_filter_Arg_Name_new_filter_Ü,
         PolyORB.Any.Any
           (Arg_Any_new_filter_Ü),
         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 => "add_filter",
         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 add_filter;

   remove_filter_Arg_Name_filter_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("filter");

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

   ----------------------------
   -- remove_filter_Result_Ü --
   ----------------------------

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

   -------------------
   -- remove_filter --
   -------------------

   procedure remove_filter
     (Self : Ref;
      filter : CosNotifyFilter.FilterID)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Arg_CC_filter_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Long
              (filter)'Unrestricted_Access);
      Arg_Any_filter_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyFilter.Helper.TC_FilterID,
            Arg_CC_filter_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Exception_List_Ü : CORBA.ExceptionList.Ref;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        remove_filter_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_Ü,
         remove_filter_Arg_Name_filter_Ü,
         PolyORB.Any.Any
           (Arg_Any_filter_Ü),
         PolyORB.Any.ARG_IN);
      --  Create the Exception list
      CORBA.ExceptionList.Create_List
        (Exception_List_Ü);
      CORBA.ExceptionList.Add
        (Exception_List_Ü,
         CosNotifyFilter.Helper.TC_FilterNotFound);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "remove_filter",
         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 remove_filter;

   get_filter_Arg_Name_filter_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("filter");

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

   -------------------------
   -- get_filter_Result_Ü --
   -------------------------

   function get_filter_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_filter_Result_Ü);
   begin
      return (Name => get_filter_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyFilter.Filter.Helper.TC_Filter),
      Arg_Modes => 0);
   end get_filter_Result_Ü;

   ----------------
   -- get_filter --
   ----------------

   function get_filter
     (Self : Ref;
      filter : CosNotifyFilter.FilterID)
     return CosNotifyFilter.Filter.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosNotifyFilter.Filter.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_filter_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Long
              (filter)'Unrestricted_Access);
      Arg_Any_filter_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosNotifyFilter.Helper.TC_FilterID,
            Arg_CC_filter_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Exception_List_Ü : CORBA.ExceptionList.Ref;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_filter_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_filter_Arg_Name_filter_Ü,
         PolyORB.Any.Any
           (Arg_Any_filter_Ü),
         PolyORB.Any.ARG_IN);
      --  Create the Exception list
      CORBA.ExceptionList.Create_List
        (Exception_List_Ü);
      CORBA.ExceptionList.Add
        (Exception_List_Ü,
         CosNotifyFilter.Helper.TC_FilterNotFound);
      --  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_filter",
         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_filter;

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

   ------------------------------
   -- get_all_filters_Result_Ü --
   ------------------------------

   function get_all_filters_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_all_filters_Result_Ü);
   begin
      return (Name => get_all_filters_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosNotifyFilter.Helper.TC_FilterIDSeq),
      Arg_Modes => 0);
   end get_all_filters_Result_Ü;

   ---------------------
   -- get_all_filters --
   ---------------------

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

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

   ---------------------------------
   -- remove_all_filters_Result_Ü --
   ---------------------------------

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

   ------------------------
   -- remove_all_filters --
   ------------------------

   procedure remove_all_filters
     (Self : Ref)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        remove_all_filters_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 => "remove_all_filters",
         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 remove_all_filters;

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

   -----------------------------------
   -- obtain_push_supplier_Result_Ü --
   -----------------------------------

   function obtain_push_supplier_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (obtain_push_supplier_Result_Ü);
   begin
      return (Name => obtain_push_supplier_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosEventChannelAdmin.ProxyPushSupplier.Helper.TC_ProxyPushSupplier),
      Arg_Modes => 0);
   end obtain_push_supplier_Result_Ü;

   --------------------------
   -- obtain_push_supplier --
   --------------------------

   function obtain_push_supplier
     (Self : Ref)
     return CosEventChannelAdmin.ProxyPushSupplier.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosEventChannelAdmin.ProxyPushSupplier.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 :=
        obtain_push_supplier_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 => "obtain_push_supplier",
         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 obtain_push_supplier;

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

   -----------------------------------
   -- obtain_pull_supplier_Result_Ü --
   -----------------------------------

   function obtain_pull_supplier_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (obtain_pull_supplier_Result_Ü);
   begin
      return (Name => obtain_pull_supplier_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosEventChannelAdmin.ProxyPullSupplier.Helper.TC_ProxyPullSupplier),
      Arg_Modes => 0);
   end obtain_pull_supplier_Result_Ü;

   --------------------------
   -- obtain_pull_supplier --
   --------------------------

   function obtain_pull_supplier
     (Self : Ref)
     return CosEventChannelAdmin.ProxyPullSupplier.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosEventChannelAdmin.ProxyPullSupplier.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 :=
        obtain_pull_supplier_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 => "obtain_pull_supplier",
         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 obtain_pull_supplier;

   ----------
   -- 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.ConsumerAdmin.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,
               CosNotifyComm.NotifySubscribe.Repository_Id))
            or else CORBA.Is_Equivalent
              (Logical_Type_Id,
               CosNotifyFilter.FilterAdmin.Repository_Id))
            or else CORBA.Is_Equivalent
              (Logical_Type_Id,
               CosEventChannelAdmin.ConsumerAdmin.Repository_Id)))
         or else False);
   end Is_A;

end CosNotifyChannelAdmin.ConsumerAdmin;
