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 CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl;
with CosNotifyComm.SequencePushConsumer;
with CORBA;
pragma Elaborate_All (CORBA);
with CORBA.Object.Helper;
with CORBA.Object;
with PolyORB.Any;
with CosNotifyComm.SequencePushConsumer.Helper;
with CORBA.NVList;
with CORBA.ServerRequest;
with CosEventChannelAdmin;
with CosEventChannelAdmin.Helper;
with CosNotifyChannelAdmin.Helper;
with CosNotifyChannelAdmin.ConsumerAdmin.Helper;
with CosNotifyFilter.MappingFilter;
with CosNotifyFilter.MappingFilter.Helper;
with CosNotification;
with CosNotification.Helper;
with CosNotifyFilter.Filter;
with CosNotifyFilter.Filter.Helper;
with CosNotifyFilter;
with CosNotifyFilter.Helper;
with CosNotifyComm;
with CosNotifyComm.Helper;
with PolyORB.CORBA_P.IR_Hooks;
with PolyORB.CORBA_P.Domain_Management;
with CosNotifyChannelAdmin_SequenceProxyPushSupplier_Hash;
with PolyORB.Std;
with PortableServer;
with CORBA.ORB;
with PolyORB.CORBA_P.Exceptions;
with PolyORB.Qos.Exception_Informations;
with PolyORB.Utils.Strings;
with PolyORB.Utils.Strings.Lists;
with PolyORB.Initialization;

package body CosNotifyChannelAdmin.SequenceProxyPushSupplier.Skel is

   connect_sequence_push_consumer_Arg_Name_push_consumer_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("push_consumer");

   set_priority_filter_Arg_Name_To_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("To");

   set_lifetime_filter_Arg_Name_To_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("To");

   obtain_offered_types_Arg_Name_mode_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("mode");

   validate_event_qos_Arg_Name_required_qos_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("required_qos");

   validate_event_qos_Arg_Name_available_qos_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("available_qos");

   set_qos_Arg_Name_qos_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("qos");

   validate_qos_Arg_Name_required_qos_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("required_qos");

   validate_qos_Arg_Name_available_qos_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("available_qos");

   add_filter_Arg_Name_new_filter_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("new_filter");

   remove_filter_Arg_Name_filter_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("filter");

   get_filter_Arg_Name_filter_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("filter");

   subscription_change_Arg_Name_added_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("added");

   subscription_change_Arg_Name_removed_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("removed");

   N_Operations : constant PolyORB.Std.Natural :=
     26;

   type String_Ptr is
     access PolyORB.Std.String;

   Invoke_Db : array (0 .. (N_Operations
      - 1)) of String_Ptr :=
     (others => null);

   procedure Register_Procedure
     (Operation_Name : PolyORB.Std.String);

   ------------------------
   -- Register_Procedure --
   ------------------------

   procedure Register_Procedure
     (Operation_Name : PolyORB.Std.String)
   is
      Index_Ü : PolyORB.Std.Natural;
      Invoke_Name_Access : String_Ptr;
   begin
      Index_Ü :=
        CosNotifyChannelAdmin_SequenceProxyPushSupplier_Hash.Hash
           (Operation_Name);
      if (Invoke_Db
        (Index_Ü)
         /= null)
      then
         raise Program_Error;
      end if;
      Invoke_Name_Access :=
        new PolyORB.Std.String'
           (Operation_Name);
      Invoke_Db
        (Index_Ü) :=
        Invoke_Name_Access;
   end Register_Procedure;

   procedure Invoke
     (Self : PortableServer.Servant;
      Request : CORBA.ServerRequest.Object_Ptr);

   ------------
   -- Invoke --
   ------------

   procedure Invoke
     (Self : PortableServer.Servant;
      Request : CORBA.ServerRequest.Object_Ptr)
   is
      Operation_Ü : constant PolyORB.Std.String :=
        CORBA.To_Standard_String
           (CORBA.ServerRequest.Operation
              (Request.all));
      Argument_List_Ü : CORBA.NVList.Ref;
      Index_Ü : PolyORB.Std.Natural;
      Invoke_Name_Access : String_Ptr;

      procedure Invoke_connect_sequence_push_consumer;

      -------------------------------------------
      -- Invoke_connect_sequence_push_consumer --
      -------------------------------------------

      procedure Invoke_connect_sequence_push_consumer is
         Argument_push_consumer_Ü : CosNotifyComm.SequencePushConsumer.Ref;
         pragma Warnings (Off, Argument_push_consumer_Ü);
         pragma Suppress (Validity_Check, Argument_push_consumer_Ü);
         Arg_CC_push_consumer_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Argument_push_consumer_Ü)'Unrestricted_Access);
         Arg_Any_push_consumer_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyComm.SequencePushConsumer.Helper.TC_SequencePushConsumer,
               Arg_CC_push_consumer_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            connect_sequence_push_consumer_Arg_Name_push_consumer_Ü,
            Arg_Any_push_consumer_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         begin
            --  Call Implementation
            CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.connect_sequence_push_consumer
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access,
               Argument_push_consumer_Ü);
         exception
            when E : CosEventChannelAdmin.AlreadyConnected =>
               declare
                  Members : CosEventChannelAdmin.AlreadyConnected_Members;
               begin
                  CosEventChannelAdmin.Get_Members
                    (E,
                     Members);
                  CORBA.ServerRequest.Set_Exception
                    (Request,
                     CosEventChannelAdmin.Helper.To_Any
                       (Members));
                  return;
               end;
            when E : CosEventChannelAdmin.TypeError =>
               declare
                  Members : CosEventChannelAdmin.TypeError_Members;
               begin
                  CosEventChannelAdmin.Get_Members
                    (E,
                     Members);
                  CORBA.ServerRequest.Set_Exception
                    (Request,
                     CosEventChannelAdmin.Helper.To_Any
                       (Members));
                  return;
               end;
         end;
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_connect_sequence_push_consumer;

      procedure Invoke_suspend_connection;

      -------------------------------
      -- Invoke_suspend_connection --
      -------------------------------

      procedure Invoke_suspend_connection is
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         begin
            --  Call Implementation
            CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.suspend_connection
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access);
         exception
            when E : CosNotifyChannelAdmin.ConnectionAlreadyInactive =>
               declare
                  Members : CosNotifyChannelAdmin.ConnectionAlreadyInactive_Members;
               begin
                  CosNotifyChannelAdmin.Get_Members
                    (E,
                     Members);
                  CORBA.ServerRequest.Set_Exception
                    (Request,
                     CosNotifyChannelAdmin.Helper.To_Any
                       (Members));
                  return;
               end;
            when E : CosNotifyChannelAdmin.NotConnected =>
               declare
                  Members : CosNotifyChannelAdmin.NotConnected_Members;
               begin
                  CosNotifyChannelAdmin.Get_Members
                    (E,
                     Members);
                  CORBA.ServerRequest.Set_Exception
                    (Request,
                     CosNotifyChannelAdmin.Helper.To_Any
                       (Members));
                  return;
               end;
         end;
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_suspend_connection;

      procedure Invoke_resume_connection;

      ------------------------------
      -- Invoke_resume_connection --
      ------------------------------

      procedure Invoke_resume_connection is
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         begin
            --  Call Implementation
            CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.resume_connection
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access);
         exception
            when E : CosNotifyChannelAdmin.ConnectionAlreadyActive =>
               declare
                  Members : CosNotifyChannelAdmin.ConnectionAlreadyActive_Members;
               begin
                  CosNotifyChannelAdmin.Get_Members
                    (E,
                     Members);
                  CORBA.ServerRequest.Set_Exception
                    (Request,
                     CosNotifyChannelAdmin.Helper.To_Any
                       (Members));
                  return;
               end;
            when E : CosNotifyChannelAdmin.NotConnected =>
               declare
                  Members : CosNotifyChannelAdmin.NotConnected_Members;
               begin
                  CosNotifyChannelAdmin.Get_Members
                    (E,
                     Members);
                  CORBA.ServerRequest.Set_Exception
                    (Request,
                     CosNotifyChannelAdmin.Helper.To_Any
                       (Members));
                  return;
               end;
         end;
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_resume_connection;

      procedure Invoke_Uget_MyType;

      ------------------------
      -- Invoke_Uget_MyType --
      ------------------------

      procedure Invoke_Uget_MyType is
         Result_Ü : CosNotifyChannelAdmin.ProxyType;
         pragma Warnings (Off, Result_Ü);
         pragma Suppress (Validity_Check, Result_Ü);
         Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
           CosNotifyChannelAdmin.Helper.Internals.Wrap
              (Result_Ü'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyChannelAdmin.Helper.TC_ProxyType,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.get_MyType
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_MyType;

      procedure Invoke_Uget_MyAdmin;

      -------------------------
      -- Invoke_Uget_MyAdmin --
      -------------------------

      procedure Invoke_Uget_MyAdmin is
         Result_Ü : CosNotifyChannelAdmin.ConsumerAdmin_Forward.Ref;
         pragma Warnings (Off, Result_Ü);
         pragma Suppress (Validity_Check, Result_Ü);
         Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Result_Ü)'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyChannelAdmin.ConsumerAdmin.Helper.TC_ConsumerAdmin,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.get_MyAdmin
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_MyAdmin;

      procedure Invoke_Uget_priority_filter;

      ---------------------------------
      -- Invoke_Uget_priority_filter --
      ---------------------------------

      procedure Invoke_Uget_priority_filter is
         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);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyFilter.MappingFilter.Helper.TC_MappingFilter,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.get_priority_filter
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_priority_filter;

      procedure Invoke_Uset_priority_filter;

      ---------------------------------
      -- Invoke_Uset_priority_filter --
      ---------------------------------

      procedure Invoke_Uset_priority_filter is
         Argument_To_Ü : CosNotifyFilter.MappingFilter.Ref;
         pragma Warnings (Off, Argument_To_Ü);
         pragma Suppress (Validity_Check, Argument_To_Ü);
         Arg_CC_To_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Argument_To_Ü)'Unrestricted_Access);
         Arg_Any_To_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyFilter.MappingFilter.Helper.TC_MappingFilter,
               Arg_CC_To_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            set_priority_filter_Arg_Name_To_Ü,
            Arg_Any_To_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.set_priority_filter
           (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
              (Self.all)'Access,
            Argument_To_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uset_priority_filter;

      procedure Invoke_Uget_lifetime_filter;

      ---------------------------------
      -- Invoke_Uget_lifetime_filter --
      ---------------------------------

      procedure Invoke_Uget_lifetime_filter is
         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);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyFilter.MappingFilter.Helper.TC_MappingFilter,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.get_lifetime_filter
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_lifetime_filter;

      procedure Invoke_Uset_lifetime_filter;

      ---------------------------------
      -- Invoke_Uset_lifetime_filter --
      ---------------------------------

      procedure Invoke_Uset_lifetime_filter is
         Argument_To_Ü : CosNotifyFilter.MappingFilter.Ref;
         pragma Warnings (Off, Argument_To_Ü);
         pragma Suppress (Validity_Check, Argument_To_Ü);
         Arg_CC_To_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Argument_To_Ü)'Unrestricted_Access);
         Arg_Any_To_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyFilter.MappingFilter.Helper.TC_MappingFilter,
               Arg_CC_To_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            set_lifetime_filter_Arg_Name_To_Ü,
            Arg_Any_To_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.set_lifetime_filter
           (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
              (Self.all)'Access,
            Argument_To_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uset_lifetime_filter;

      procedure Invoke_obtain_offered_types;

      ---------------------------------
      -- Invoke_obtain_offered_types --
      ---------------------------------

      procedure Invoke_obtain_offered_types is
         Argument_mode_Ü : CosNotifyChannelAdmin.ObtainInfoMode;
         pragma Warnings (Off, Argument_mode_Ü);
         pragma Suppress (Validity_Check, Argument_mode_Ü);
         Arg_CC_mode_Ü : aliased PolyORB.Any.Content'Class :=
           CosNotifyChannelAdmin.Helper.Internals.Wrap
              (Argument_mode_Ü'Unrestricted_Access);
         Arg_Any_mode_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyChannelAdmin.Helper.TC_ObtainInfoMode,
               Arg_CC_mode_Ü'Unchecked_Access);
         Result_Ü : CosNotification.EventTypeSeq;
         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_EventType.Sequence
                 (Result_Ü)'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotification.Helper.TC_EventTypeSeq,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            obtain_offered_types_Arg_Name_mode_Ü,
            Arg_Any_mode_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.obtain_offered_types
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access,
               Argument_mode_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_obtain_offered_types;

      procedure Invoke_validate_event_qos;

      -------------------------------
      -- Invoke_validate_event_qos --
      -------------------------------

      procedure Invoke_validate_event_qos is
         Argument_required_qos_Ü : CosNotification.QoSProperties;
         pragma Warnings (Off, Argument_required_qos_Ü);
         pragma Suppress (Validity_Check, Argument_required_qos_Ü);
         Arg_CC_required_qos_Ü : aliased PolyORB.Any.Content'Class :=
           CosNotification.Helper.Internals.Wrap
              (CosNotification.IDL_SEQUENCE_CosNotification_Property.Sequence
                 (Argument_required_qos_Ü)'Unrestricted_Access);
         Arg_Any_required_qos_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotification.Helper.TC_QoSProperties,
               Arg_CC_required_qos_Ü'Unchecked_Access);
         Argument_available_qos_Ü : CosNotification.NamedPropertyRangeSeq;
         pragma Warnings (Off, Argument_available_qos_Ü);
         pragma Suppress (Validity_Check, Argument_available_qos_Ü);
         Arg_CC_available_qos_Ü : aliased PolyORB.Any.Content'Class :=
           CosNotification.Helper.Internals.Wrap
              (CosNotification.IDL_SEQUENCE_CosNotification_NamedPropertyRange.Sequence
                 (Argument_available_qos_Ü)'Unrestricted_Access);
         Arg_Any_available_qos_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotification.Helper.TC_NamedPropertyRangeSeq,
               Arg_CC_available_qos_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            validate_event_qos_Arg_Name_required_qos_Ü,
            Arg_Any_required_qos_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            validate_event_qos_Arg_Name_available_qos_Ü,
            Arg_Any_available_qos_Ü,
            CORBA.ARG_OUT);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         begin
            --  Call Implementation
            CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.validate_event_qos
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access,
               Argument_required_qos_Ü,
               Argument_available_qos_Ü);
         exception
            when E : CosNotification.UnsupportedQoS =>
               declare
                  Members : CosNotification.UnsupportedQoS_Members;
               begin
                  CosNotification.Get_Members
                    (E,
                     Members);
                  CORBA.ServerRequest.Set_Exception
                    (Request,
                     CosNotification.Helper.To_Any
                       (Members));
                  return;
               end;
         end;
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_validate_event_qos;

      procedure Invoke_get_qos;

      --------------------
      -- Invoke_get_qos --
      --------------------

      procedure Invoke_get_qos is
         Result_Ü : CosNotification.QoSProperties;
         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);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotification.Helper.TC_QoSProperties,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.get_qos
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_get_qos;

      procedure Invoke_set_qos;

      --------------------
      -- Invoke_set_qos --
      --------------------

      procedure Invoke_set_qos is
         Argument_qos_Ü : CosNotification.QoSProperties;
         pragma Warnings (Off, Argument_qos_Ü);
         pragma Suppress (Validity_Check, Argument_qos_Ü);
         Arg_CC_qos_Ü : aliased PolyORB.Any.Content'Class :=
           CosNotification.Helper.Internals.Wrap
              (CosNotification.IDL_SEQUENCE_CosNotification_Property.Sequence
                 (Argument_qos_Ü)'Unrestricted_Access);
         Arg_Any_qos_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotification.Helper.TC_QoSProperties,
               Arg_CC_qos_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            set_qos_Arg_Name_qos_Ü,
            Arg_Any_qos_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         begin
            --  Call Implementation
            CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.set_qos
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access,
               Argument_qos_Ü);
         exception
            when E : CosNotification.UnsupportedQoS =>
               declare
                  Members : CosNotification.UnsupportedQoS_Members;
               begin
                  CosNotification.Get_Members
                    (E,
                     Members);
                  CORBA.ServerRequest.Set_Exception
                    (Request,
                     CosNotification.Helper.To_Any
                       (Members));
                  return;
               end;
         end;
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_set_qos;

      procedure Invoke_validate_qos;

      -------------------------
      -- Invoke_validate_qos --
      -------------------------

      procedure Invoke_validate_qos is
         Argument_required_qos_Ü : CosNotification.QoSProperties;
         pragma Warnings (Off, Argument_required_qos_Ü);
         pragma Suppress (Validity_Check, Argument_required_qos_Ü);
         Arg_CC_required_qos_Ü : aliased PolyORB.Any.Content'Class :=
           CosNotification.Helper.Internals.Wrap
              (CosNotification.IDL_SEQUENCE_CosNotification_Property.Sequence
                 (Argument_required_qos_Ü)'Unrestricted_Access);
         Arg_Any_required_qos_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotification.Helper.TC_QoSProperties,
               Arg_CC_required_qos_Ü'Unchecked_Access);
         Argument_available_qos_Ü : CosNotification.NamedPropertyRangeSeq;
         pragma Warnings (Off, Argument_available_qos_Ü);
         pragma Suppress (Validity_Check, Argument_available_qos_Ü);
         Arg_CC_available_qos_Ü : aliased PolyORB.Any.Content'Class :=
           CosNotification.Helper.Internals.Wrap
              (CosNotification.IDL_SEQUENCE_CosNotification_NamedPropertyRange.Sequence
                 (Argument_available_qos_Ü)'Unrestricted_Access);
         Arg_Any_available_qos_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotification.Helper.TC_NamedPropertyRangeSeq,
               Arg_CC_available_qos_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            validate_qos_Arg_Name_required_qos_Ü,
            Arg_Any_required_qos_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            validate_qos_Arg_Name_available_qos_Ü,
            Arg_Any_available_qos_Ü,
            CORBA.ARG_OUT);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         begin
            --  Call Implementation
            CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.validate_qos
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access,
               Argument_required_qos_Ü,
               Argument_available_qos_Ü);
         exception
            when E : CosNotification.UnsupportedQoS =>
               declare
                  Members : CosNotification.UnsupportedQoS_Members;
               begin
                  CosNotification.Get_Members
                    (E,
                     Members);
                  CORBA.ServerRequest.Set_Exception
                    (Request,
                     CosNotification.Helper.To_Any
                       (Members));
                  return;
               end;
         end;
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_validate_qos;

      procedure Invoke_add_filter;

      -----------------------
      -- Invoke_add_filter --
      -----------------------

      procedure Invoke_add_filter is
         Argument_new_filter_Ü : CosNotifyFilter.Filter.Ref;
         pragma Warnings (Off, Argument_new_filter_Ü);
         pragma Suppress (Validity_Check, Argument_new_filter_Ü);
         Arg_CC_new_filter_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyFilter.Helper.TC_FilterID,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            add_filter_Arg_Name_new_filter_Ü,
            Arg_Any_new_filter_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.add_filter
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access,
               Argument_new_filter_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_add_filter;

      procedure Invoke_remove_filter;

      --------------------------
      -- Invoke_remove_filter --
      --------------------------

      procedure Invoke_remove_filter is
         Argument_filter_Ü : CosNotifyFilter.FilterID;
         pragma Warnings (Off, Argument_filter_Ü);
         pragma Suppress (Validity_Check, Argument_filter_Ü);
         Arg_CC_filter_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.Long
                 (Argument_filter_Ü)'Unrestricted_Access);
         Arg_Any_filter_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyFilter.Helper.TC_FilterID,
               Arg_CC_filter_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            remove_filter_Arg_Name_filter_Ü,
            Arg_Any_filter_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         begin
            --  Call Implementation
            CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.remove_filter
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access,
               Argument_filter_Ü);
         exception
            when E : CosNotifyFilter.FilterNotFound =>
               declare
                  Members : CosNotifyFilter.FilterNotFound_Members;
               begin
                  CosNotifyFilter.Get_Members
                    (E,
                     Members);
                  CORBA.ServerRequest.Set_Exception
                    (Request,
                     CosNotifyFilter.Helper.To_Any
                       (Members));
                  return;
               end;
         end;
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_remove_filter;

      procedure Invoke_get_filter;

      -----------------------
      -- Invoke_get_filter --
      -----------------------

      procedure Invoke_get_filter is
         Argument_filter_Ü : CosNotifyFilter.FilterID;
         pragma Warnings (Off, Argument_filter_Ü);
         pragma Suppress (Validity_Check, Argument_filter_Ü);
         Arg_CC_filter_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.Long
                 (Argument_filter_Ü)'Unrestricted_Access);
         Arg_Any_filter_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyFilter.Helper.TC_FilterID,
               Arg_CC_filter_Ü'Unchecked_Access);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyFilter.Filter.Helper.TC_Filter,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            get_filter_Arg_Name_filter_Ü,
            Arg_Any_filter_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         begin
            --  Call Implementation
            Result_Ü :=
              CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.get_filter
                 (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                    (Self.all)'Access,
                  Argument_filter_Ü);
         exception
            when E : CosNotifyFilter.FilterNotFound =>
               declare
                  Members : CosNotifyFilter.FilterNotFound_Members;
               begin
                  CosNotifyFilter.Get_Members
                    (E,
                     Members);
                  CORBA.ServerRequest.Set_Exception
                    (Request,
                     CosNotifyFilter.Helper.To_Any
                       (Members));
                  return;
               end;
         end;
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_get_filter;

      procedure Invoke_get_all_filters;

      ----------------------------
      -- Invoke_get_all_filters --
      ----------------------------

      procedure Invoke_get_all_filters is
         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);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotifyFilter.Helper.TC_FilterIDSeq,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.get_all_filters
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_get_all_filters;

      procedure Invoke_remove_all_filters;

      -------------------------------
      -- Invoke_remove_all_filters --
      -------------------------------

      procedure Invoke_remove_all_filters is
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.remove_all_filters
           (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
              (Self.all)'Access);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_remove_all_filters;

      procedure Invoke_disconnect_sequence_push_supplier;

      ----------------------------------------------
      -- Invoke_disconnect_sequence_push_supplier --
      ----------------------------------------------

      procedure Invoke_disconnect_sequence_push_supplier is
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.disconnect_sequence_push_supplier
           (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
              (Self.all)'Access);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_disconnect_sequence_push_supplier;

      procedure Invoke_subscription_change;

      --------------------------------
      -- Invoke_subscription_change --
      --------------------------------

      procedure Invoke_subscription_change is
         Argument_added_Ü : CosNotification.EventTypeSeq;
         pragma Warnings (Off, Argument_added_Ü);
         pragma Suppress (Validity_Check, Argument_added_Ü);
         Arg_CC_added_Ü : aliased PolyORB.Any.Content'Class :=
           CosNotification.Helper.Internals.Wrap
              (CosNotification.IDL_SEQUENCE_CosNotification_EventType.Sequence
                 (Argument_added_Ü)'Unrestricted_Access);
         Arg_Any_added_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotification.Helper.TC_EventTypeSeq,
               Arg_CC_added_Ü'Unchecked_Access);
         Argument_removed_Ü : CosNotification.EventTypeSeq;
         pragma Warnings (Off, Argument_removed_Ü);
         pragma Suppress (Validity_Check, Argument_removed_Ü);
         Arg_CC_removed_Ü : aliased PolyORB.Any.Content'Class :=
           CosNotification.Helper.Internals.Wrap
              (CosNotification.IDL_SEQUENCE_CosNotification_EventType.Sequence
                 (Argument_removed_Ü)'Unrestricted_Access);
         Arg_Any_removed_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CosNotification.Helper.TC_EventTypeSeq,
               Arg_CC_removed_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            subscription_change_Arg_Name_added_Ü,
            Arg_Any_added_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            subscription_change_Arg_Name_removed_Ü,
            Arg_Any_removed_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         begin
            --  Call Implementation
            CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.subscription_change
              (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class
                 (Self.all)'Access,
               Argument_added_Ü,
               Argument_removed_Ü);
         exception
            when E : CosNotifyComm.InvalidEventType =>
               declare
                  Members : CosNotifyComm.InvalidEventType_Members;
               begin
                  CosNotifyComm.Get_Members
                    (E,
                     Members);
                  CORBA.ServerRequest.Set_Exception
                    (Request,
                     CosNotifyComm.Helper.To_Any
                       (Members));
                  return;
               end;
         end;
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_subscription_change;

      procedure Invoke_Uis_a;

      ------------------
      -- Invoke_Uis_a --
      ------------------

      procedure Invoke_Uis_a is
         Type_Id_Ü : CORBA.String;
         Arg_Name_Type_Id_Ü : constant CORBA.Identifier :=
           CORBA.To_CORBA_String
              ("Type_Id_Ü");
         Argument_Type_Id_Ü : constant CORBA.Any :=
           CORBA.To_Any
              (Type_Id_Ü);
         Result_Ü : CORBA.Boolean;
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            Arg_Name_Type_Id_Ü,
            Argument_Type_Id_Ü,
            CORBA.ARG_IN);
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         Type_Id_Ü :=
           CORBA.From_Any
              (Argument_Type_Id_Ü);
         Result_Ü :=
           Is_A
              (CORBA.To_Standard_String
                 (Type_Id_Ü));
         CORBA.ServerRequest.Set_Result
           (Request,
            CORBA.To_Any
              (Result_Ü));
      end Invoke_Uis_a;

      procedure Invoke_Uinterface;

      -----------------------
      -- Invoke_Uinterface --
      -----------------------

      procedure Invoke_Uinterface is
      begin
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         CORBA.ServerRequest.Set_Result
           (Request,
            CORBA.Object.Helper.To_Any
              (CORBA.Object.Ref
                 (PolyORB.CORBA_P.IR_Hooks.Get_Interface_Definition
                    (CORBA.To_CORBA_String
                       (Repository_Id)))));
      end Invoke_Uinterface;

      procedure Invoke_Udomain_managers;

      -----------------------------
      -- Invoke_Udomain_managers --
      -----------------------------

      procedure Invoke_Udomain_managers is
      begin
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         CORBA.ServerRequest.Set_Result
           (Request,
            PolyORB.CORBA_P.Domain_Management.Get_Domain_Managers
              (Self));
      end Invoke_Udomain_managers;

      procedure Invoke_Unon_existent;

      --------------------------
      -- Invoke_Unon_existent --
      --------------------------

      procedure Invoke_Unon_existent is
      begin
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         CORBA.ServerRequest.Set_Result
           (Request,
            CORBA.To_Any
              (CORBA.Boolean'
                 (False)));
      end Invoke_Unon_existent;

      procedure Dispatch;

      --------------
      -- Dispatch --
      --------------

      procedure Dispatch is
      begin
         case Index_Ü is
            when 0 =>
               Invoke_connect_sequence_push_consumer;
            when 1 =>
               Invoke_suspend_connection;
            when 2 =>
               Invoke_resume_connection;
            when 3 =>
               Invoke_Uget_MyType;
            when 4 =>
               Invoke_Uget_MyAdmin;
            when 5 =>
               Invoke_Uget_priority_filter;
            when 6 =>
               Invoke_Uset_priority_filter;
            when 7 =>
               Invoke_Uget_lifetime_filter;
            when 8 =>
               Invoke_Uset_lifetime_filter;
            when 9 =>
               Invoke_obtain_offered_types;
            when 10 =>
               Invoke_validate_event_qos;
            when 11 =>
               Invoke_get_qos;
            when 12 =>
               Invoke_set_qos;
            when 13 =>
               Invoke_validate_qos;
            when 14 =>
               Invoke_add_filter;
            when 15 =>
               Invoke_remove_filter;
            when 16 =>
               Invoke_get_filter;
            when 17 =>
               Invoke_get_all_filters;
            when 18 =>
               Invoke_remove_all_filters;
            when 19 =>
               Invoke_disconnect_sequence_push_supplier;
            when 20 =>
               Invoke_subscription_change;
            when 22 =>
               Invoke_Uinterface;
            when 23 =>
               Invoke_Udomain_managers;
            when 24
               | 25 =>
               Invoke_Unon_existent;
            when 21 =>
               Invoke_Uis_a;
            pragma Warnings (Off);
            when others =>
               raise Program_Error;
            pragma Warnings (On);

         end case;
      end Dispatch;

   begin
      CORBA.ORB.Create_List
        (0,
         Argument_List_Ü);
      Index_Ü :=
        CosNotifyChannelAdmin_SequenceProxyPushSupplier_Hash.Hash
           (Operation_Ü);
      Invoke_Name_Access :=
        Invoke_Db
           (Index_Ü);
      begin
         if (Operation_Ü
            = Invoke_Name_Access.all)
         then
            Dispatch;
         else
            CORBA.Raise_Bad_Operation
              (CORBA.Default_Sys_Member);
         end if;
      exception
         when E : others =>
            CORBA.ServerRequest.Set_Exception
              (Request,
               PolyORB.CORBA_P.Exceptions.System_Exception_To_Any
                 (E));
            PolyORB.Qos.Exception_Informations.Set_Exception_Information
              (Request.all,
               E);
      end;
   end Invoke;

   function Servant_Is_A
     (Obj : PortableServer.Servant)
     return Boolean;

   ------------------
   -- Servant_Is_A --
   ------------------

   function Servant_Is_A
     (Obj : PortableServer.Servant)
     return Boolean
   is
   begin
      return (Obj.all
         in CosNotifyChannelAdmin.SequenceProxyPushSupplier.Impl.Object'Class);
   end Servant_Is_A;

   -----------------------------
   -- Deferred_Initialization --
   -----------------------------

   procedure Deferred_Initialization is
   begin
      PortableServer.Internals.Register_Skeleton
        (CosNotifyChannelAdmin.SequenceProxyPushSupplier.Repository_Id,
         Servant_Is_A'Access,
         Is_A'Access,
         Invoke'Access);
      Register_Procedure
        ("connect_sequence_push_consumer");
      Register_Procedure
        ("suspend_connection");
      Register_Procedure
        ("resume_connection");
      Register_Procedure
        ("_get_MyType");
      Register_Procedure
        ("_get_MyAdmin");
      Register_Procedure
        ("_get_priority_filter");
      Register_Procedure
        ("_set_priority_filter");
      Register_Procedure
        ("_get_lifetime_filter");
      Register_Procedure
        ("_set_lifetime_filter");
      Register_Procedure
        ("obtain_offered_types");
      Register_Procedure
        ("validate_event_qos");
      Register_Procedure
        ("get_qos");
      Register_Procedure
        ("set_qos");
      Register_Procedure
        ("validate_qos");
      Register_Procedure
        ("add_filter");
      Register_Procedure
        ("remove_filter");
      Register_Procedure
        ("get_filter");
      Register_Procedure
        ("get_all_filters");
      Register_Procedure
        ("remove_all_filters");
      Register_Procedure
        ("disconnect_sequence_push_supplier");
      Register_Procedure
        ("subscription_change");
      Register_Procedure
        ("_is_a");
      Register_Procedure
        ("_interface");
      Register_Procedure
        ("_domain_managers");
      Register_Procedure
        ("_non_existent");
      Register_Procedure
        ("_not_existent");
   end Deferred_Initialization;

begin
   declare
      use PolyORB.Utils.Strings;
      use PolyORB.Utils.Strings.Lists;
   begin
      PolyORB.Initialization.Register_Module
        (PolyORB.Initialization.Module_Info'
           (Name => +"CosNotifyChannelAdmin.SequenceProxyPushSupplier.Skel",
            Conflicts => PolyORB.Utils.Strings.Lists.Empty,
            Depends => PolyORB.Utils.Strings.Lists.Empty
               & "CosNotifyChannelAdmin.ProxySupplier.Skel?"
               & "CosNotifyComm.SequencePushSupplier.Skel?",
            Provides => PolyORB.Utils.Strings.Lists.Empty,
            Implicit => False,
            Init => Deferred_Initialization'Access,
            Shutdown => null));
   end;
end CosNotifyChannelAdmin.SequenceProxyPushSupplier.Skel;
