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

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

with PolyORB.Std;
with PolyORB.Exceptions;
with Ada.Unchecked_Conversion;
with Ada.Unchecked_Deallocation;
with CosNotification.Helper;
with CORBA.Object.Helper;
with PolyORB.Utils.Strings;
with PolyORB.Utils.Strings.Lists;
with PolyORB.Initialization;

package body CosNotifyChannelAdmin.Helper is

   
   package body Internals is

      procedure Raise_ConnectionAlreadyActive_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String);

      pragma No_Return (Raise_ConnectionAlreadyActive_From_Any);

      --------------------------------------------
      -- Raise_ConnectionAlreadyActive_From_Any --
      --------------------------------------------

      procedure Raise_ConnectionAlreadyActive_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyChannelAdmin.ConnectionAlreadyActive_Members :=
           CosNotifyChannelAdmin.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (ConnectionAlreadyActive'Identity,
            Members,
            Message);
      end Raise_ConnectionAlreadyActive_From_Any;

      ConnectionAlreadyActive_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------------
      -- Initialize_ConnectionAlreadyActive --
      ----------------------------------------

      procedure Initialize_ConnectionAlreadyActive is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ConnectionAlreadyActive_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/ConnectionAlreadyActive:1.0");
      begin
         if not ConnectionAlreadyActive_Initialized
         then
            ConnectionAlreadyActive_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_ConnectionAlreadyActive :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_ConnectionAlreadyActive,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ConnectionAlreadyActive,
               CORBA.To_Any
                 (Id_Ü));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_ConnectionAlreadyActive),
               Raise_ConnectionAlreadyActive_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ConnectionAlreadyActive);
            CORBA.TypeCode.Internals.Freeze
              (TC_ConnectionAlreadyActive);
         end if;
      end Initialize_ConnectionAlreadyActive;

      procedure Raise_ConnectionAlreadyInactive_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String);

      pragma No_Return (Raise_ConnectionAlreadyInactive_From_Any);

      ----------------------------------------------
      -- Raise_ConnectionAlreadyInactive_From_Any --
      ----------------------------------------------

      procedure Raise_ConnectionAlreadyInactive_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyChannelAdmin.ConnectionAlreadyInactive_Members :=
           CosNotifyChannelAdmin.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (ConnectionAlreadyInactive'Identity,
            Members,
            Message);
      end Raise_ConnectionAlreadyInactive_From_Any;

      ConnectionAlreadyInactive_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------------------
      -- Initialize_ConnectionAlreadyInactive --
      ------------------------------------------

      procedure Initialize_ConnectionAlreadyInactive is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ConnectionAlreadyInactive_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/ConnectionAlreadyInactive:1.0");
      begin
         if not ConnectionAlreadyInactive_Initialized
         then
            ConnectionAlreadyInactive_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_ConnectionAlreadyInactive :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_ConnectionAlreadyInactive,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ConnectionAlreadyInactive,
               CORBA.To_Any
                 (Id_Ü));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_ConnectionAlreadyInactive),
               Raise_ConnectionAlreadyInactive_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ConnectionAlreadyInactive);
            CORBA.TypeCode.Internals.Freeze
              (TC_ConnectionAlreadyInactive);
         end if;
      end Initialize_ConnectionAlreadyInactive;

      procedure Raise_NotConnected_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String);

      pragma No_Return (Raise_NotConnected_From_Any);

      ---------------------------------
      -- Raise_NotConnected_From_Any --
      ---------------------------------

      procedure Raise_NotConnected_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyChannelAdmin.NotConnected_Members :=
           CosNotifyChannelAdmin.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (NotConnected'Identity,
            Members,
            Message);
      end Raise_NotConnected_From_Any;

      NotConnected_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_NotConnected --
      -----------------------------

      procedure Initialize_NotConnected is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("NotConnected_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/NotConnected:1.0");
      begin
         if not NotConnected_Initialized
         then
            NotConnected_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_NotConnected :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_NotConnected,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_NotConnected,
               CORBA.To_Any
                 (Id_Ü));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_NotConnected),
               Raise_NotConnected_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_NotConnected);
            CORBA.TypeCode.Internals.Freeze
              (TC_NotConnected);
         end if;
      end Initialize_NotConnected;

      ConsumerAdmin_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_ConsumerAdmin --
      ------------------------------

      procedure Initialize_ConsumerAdmin is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ConsumerAdmin");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/ConsumerAdmin:1.0");
      begin
         if not ConsumerAdmin_Initialized
         then
            ConsumerAdmin_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_ConsumerAdmin :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_ConsumerAdmin,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ConsumerAdmin,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ConsumerAdmin);
            CORBA.TypeCode.Internals.Freeze
              (TC_ConsumerAdmin);
         end if;
      end Initialize_ConsumerAdmin;

      SupplierAdmin_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_SupplierAdmin --
      ------------------------------

      procedure Initialize_SupplierAdmin is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("SupplierAdmin");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/SupplierAdmin:1.0");
      begin
         if not SupplierAdmin_Initialized
         then
            SupplierAdmin_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_SupplierAdmin :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_SupplierAdmin,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_SupplierAdmin,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_SupplierAdmin);
            CORBA.TypeCode.Internals.Freeze
              (TC_SupplierAdmin);
         end if;
      end Initialize_SupplierAdmin;

      EventChannel_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_EventChannel --
      -----------------------------

      procedure Initialize_EventChannel is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("EventChannel");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/EventChannel:1.0");
      begin
         if not EventChannel_Initialized
         then
            EventChannel_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_EventChannel :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_EventChannel,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_EventChannel,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_EventChannel);
            CORBA.TypeCode.Internals.Freeze
              (TC_EventChannel);
         end if;
      end Initialize_EventChannel;

      EventChannelFactory_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------------
      -- Initialize_EventChannelFactory --
      ------------------------------------

      procedure Initialize_EventChannelFactory is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("EventChannelFactory");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/EventChannelFactory:1.0");
      begin
         if not EventChannelFactory_Initialized
         then
            EventChannelFactory_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_EventChannelFactory :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_EventChannelFactory,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_EventChannelFactory,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_EventChannelFactory);
            CORBA.TypeCode.Internals.Freeze
              (TC_EventChannelFactory);
         end if;
      end Initialize_EventChannelFactory;

      --------------
      -- From_Any --
      --------------

      function From_Any
        (C : PolyORB.Any.Any_Container'Class)
        return CosNotifyChannelAdmin.ProxyType
      is
      begin
         return CosNotifyChannelAdmin.ProxyType'Val
           (PolyORB.Types.Unsigned_Long'
              (PolyORB.Any.Get_Aggregate_Element
                 (C,
                  0)));
      end From_Any;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_ProxyType;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc, Index);
      begin
         Acc.Repr_Cache :=
           CosNotifyChannelAdmin.ProxyType'Pos
              (Acc.V.all);
         Mech.all :=
           PolyORB.Any.By_Value;
         return PolyORB.Any.Wrap
           (Acc.Repr_Cache'Unrestricted_Access);
      end Get_Aggregate_Element;

      ---------------------------
      -- Set_Aggregate_Element --
      ---------------------------

      procedure Set_Aggregate_Element
        (Acc : in out Content_Ü_ProxyType;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         From_C : in out PolyORB.Any.Any_Container'Class)
      is
         use type PolyORB.Types.Unsigned_Long;
         pragma Assert ((Index
            = 0));
         pragma Unreferenced (Tc);
      begin
         Acc.V.all :=
           CosNotifyChannelAdmin.ProxyType'Val
              (PolyORB.Types.Unsigned_Long'
                 (PolyORB.Any.From_Any
                    (From_C)));
      end Set_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_ProxyType)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 1;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_ProxyType;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_ProxyType)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_ProxyType,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_ProxyType;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_ProxyType)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_ProxyType
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_ProxyType;
            Content_Ü_ProxyType
              (Target.all).V :=
              new CosNotifyChannelAdmin.ProxyType'
                 (Acc.V.all);
         end if;
         Content_Ü_ProxyType
           (Target.all).Repr_Cache :=
           Acc.Repr_Cache;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_ProxyType)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotifyChannelAdmin.ProxyType,
               Ptr_Ü_ProxyType);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CosNotifyChannelAdmin.ProxyType)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_ProxyType'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_ProxyType'
              (X.all'Unchecked_Access),
            Repr_Cache => 0);
      end Wrap;

      ProxyType_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------
      -- Initialize_ProxyType --
      --------------------------

      procedure Initialize_ProxyType is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ProxyType");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/ProxyType:1.0");
         PUSH_ANY_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PUSH_ANY");
         PULL_ANY_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PULL_ANY");
         PUSH_STRUCTURED_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PUSH_STRUCTURED");
         PULL_STRUCTURED_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PULL_STRUCTURED");
         PUSH_SEQUENCE_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PUSH_SEQUENCE");
         PULL_SEQUENCE_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PULL_SEQUENCE");
         PUSH_TYPED_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PUSH_TYPED");
         PULL_TYPED_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PULL_TYPED");
      begin
         if not ProxyType_Initialized
         then
            ProxyType_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_ProxyType :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Enum);
            CORBA.Internals.Add_Parameter
              (TC_ProxyType,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ProxyType,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ProxyType,
               CORBA.To_Any
                 (PUSH_ANY_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ProxyType,
               CORBA.To_Any
                 (PULL_ANY_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ProxyType,
               CORBA.To_Any
                 (PUSH_STRUCTURED_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ProxyType,
               CORBA.To_Any
                 (PULL_STRUCTURED_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ProxyType,
               CORBA.To_Any
                 (PUSH_SEQUENCE_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ProxyType,
               CORBA.To_Any
                 (PULL_SEQUENCE_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ProxyType,
               CORBA.To_Any
                 (PUSH_TYPED_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ProxyType,
               CORBA.To_Any
                 (PULL_TYPED_Name_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ProxyType);
            CORBA.TypeCode.Internals.Freeze
              (TC_ProxyType);
         end if;
      end Initialize_ProxyType;

      --------------
      -- From_Any --
      --------------

      function From_Any
        (C : PolyORB.Any.Any_Container'Class)
        return CosNotifyChannelAdmin.ObtainInfoMode
      is
      begin
         return CosNotifyChannelAdmin.ObtainInfoMode'Val
           (PolyORB.Types.Unsigned_Long'
              (PolyORB.Any.Get_Aggregate_Element
                 (C,
                  0)));
      end From_Any;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_ObtainInfoMode;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc, Index);
      begin
         Acc.Repr_Cache :=
           CosNotifyChannelAdmin.ObtainInfoMode'Pos
              (Acc.V.all);
         Mech.all :=
           PolyORB.Any.By_Value;
         return PolyORB.Any.Wrap
           (Acc.Repr_Cache'Unrestricted_Access);
      end Get_Aggregate_Element;

      ---------------------------
      -- Set_Aggregate_Element --
      ---------------------------

      procedure Set_Aggregate_Element
        (Acc : in out Content_Ü_ObtainInfoMode;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         From_C : in out PolyORB.Any.Any_Container'Class)
      is
         use type PolyORB.Types.Unsigned_Long;
         pragma Assert ((Index
            = 0));
         pragma Unreferenced (Tc);
      begin
         Acc.V.all :=
           CosNotifyChannelAdmin.ObtainInfoMode'Val
              (PolyORB.Types.Unsigned_Long'
                 (PolyORB.Any.From_Any
                    (From_C)));
      end Set_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_ObtainInfoMode)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 1;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_ObtainInfoMode;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_ObtainInfoMode)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_ObtainInfoMode,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_ObtainInfoMode;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_ObtainInfoMode)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_ObtainInfoMode
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_ObtainInfoMode;
            Content_Ü_ObtainInfoMode
              (Target.all).V :=
              new CosNotifyChannelAdmin.ObtainInfoMode'
                 (Acc.V.all);
         end if;
         Content_Ü_ObtainInfoMode
           (Target.all).Repr_Cache :=
           Acc.Repr_Cache;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_ObtainInfoMode)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotifyChannelAdmin.ObtainInfoMode,
               Ptr_Ü_ObtainInfoMode);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CosNotifyChannelAdmin.ObtainInfoMode)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_ObtainInfoMode'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_ObtainInfoMode'
              (X.all'Unchecked_Access),
            Repr_Cache => 0);
      end Wrap;

      ObtainInfoMode_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------
      -- Initialize_ObtainInfoMode --
      -------------------------------

      procedure Initialize_ObtainInfoMode is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ObtainInfoMode");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/ObtainInfoMode:1.0");
         ALL_NOW_UPDATES_OFF_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ALL_NOW_UPDATES_OFF");
         ALL_NOW_UPDATES_ON_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ALL_NOW_UPDATES_ON");
         NONE_NOW_UPDATES_OFF_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("NONE_NOW_UPDATES_OFF");
         NONE_NOW_UPDATES_ON_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("NONE_NOW_UPDATES_ON");
      begin
         if not ObtainInfoMode_Initialized
         then
            ObtainInfoMode_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_ObtainInfoMode :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Enum);
            CORBA.Internals.Add_Parameter
              (TC_ObtainInfoMode,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ObtainInfoMode,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ObtainInfoMode,
               CORBA.To_Any
                 (ALL_NOW_UPDATES_OFF_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ObtainInfoMode,
               CORBA.To_Any
                 (ALL_NOW_UPDATES_ON_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ObtainInfoMode,
               CORBA.To_Any
                 (NONE_NOW_UPDATES_OFF_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ObtainInfoMode,
               CORBA.To_Any
                 (NONE_NOW_UPDATES_ON_Name_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ObtainInfoMode);
            CORBA.TypeCode.Internals.Freeze
              (TC_ObtainInfoMode);
         end if;
      end Initialize_ObtainInfoMode;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CosNotifyChannelAdmin.ProxyID)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Wrap
           (CORBA.Long
              (X.all)'Unrestricted_Access);
      end Wrap;

      ProxyID_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------
      -- Initialize_ProxyID --
      ------------------------

      procedure Initialize_ProxyID is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ProxyID");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/ProxyID:1.0");
      begin
         if not ProxyID_Initialized
         then
            ProxyID_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_ProxyID :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.TC_Long);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ProxyID);
            CORBA.TypeCode.Internals.Freeze
              (TC_ProxyID);
         end if;
      end Initialize_ProxyID;

      -------------------------------------------------------------
      -- IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID_Element_Wrap --
      -------------------------------------------------------------

      function IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID_Element_Wrap
        (X : access CosNotifyChannelAdmin.ProxyID)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Wrap
           (CORBA.Long
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID_Element_Wrap;

      function Wrap
        (X : access CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID_Helper.Wrap;

      IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID --
      -----------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID is
      begin
         if not IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID_Initialized
         then
            IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.Internals.Initialize_ProxyID;
            CosNotifyChannelAdmin.Helper.TC_IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotifyChannelAdmin.Helper.TC_ProxyID,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotifyChannelAdmin.Helper.TC_IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID);
            IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID_Helper.Initialize
              (Element_TC => CosNotifyChannelAdmin.Helper.TC_ProxyID,
               Sequence_TC => CosNotifyChannelAdmin.Helper.TC_IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID;

      ProxyIDSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------
      -- Initialize_ProxyIDSeq --
      ---------------------------

      procedure Initialize_ProxyIDSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ProxyIDSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/ProxyIDSeq:1.0");
      begin
         if not ProxyIDSeq_Initialized
         then
            ProxyIDSeq_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID;
            CosNotifyChannelAdmin.Helper.TC_ProxyIDSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotifyChannelAdmin.Helper.TC_IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ProxyIDSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ProxyIDSeq);
         end if;
      end Initialize_ProxyIDSeq;

      --------------
      -- From_Any --
      --------------

      function From_Any
        (C : PolyORB.Any.Any_Container'Class)
        return CosNotifyChannelAdmin.ClientType
      is
      begin
         return CosNotifyChannelAdmin.ClientType'Val
           (PolyORB.Types.Unsigned_Long'
              (PolyORB.Any.Get_Aggregate_Element
                 (C,
                  0)));
      end From_Any;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_ClientType;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc, Index);
      begin
         Acc.Repr_Cache :=
           CosNotifyChannelAdmin.ClientType'Pos
              (Acc.V.all);
         Mech.all :=
           PolyORB.Any.By_Value;
         return PolyORB.Any.Wrap
           (Acc.Repr_Cache'Unrestricted_Access);
      end Get_Aggregate_Element;

      ---------------------------
      -- Set_Aggregate_Element --
      ---------------------------

      procedure Set_Aggregate_Element
        (Acc : in out Content_Ü_ClientType;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         From_C : in out PolyORB.Any.Any_Container'Class)
      is
         use type PolyORB.Types.Unsigned_Long;
         pragma Assert ((Index
            = 0));
         pragma Unreferenced (Tc);
      begin
         Acc.V.all :=
           CosNotifyChannelAdmin.ClientType'Val
              (PolyORB.Types.Unsigned_Long'
                 (PolyORB.Any.From_Any
                    (From_C)));
      end Set_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_ClientType)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 1;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_ClientType;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_ClientType)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_ClientType,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_ClientType;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_ClientType)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_ClientType
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_ClientType;
            Content_Ü_ClientType
              (Target.all).V :=
              new CosNotifyChannelAdmin.ClientType'
                 (Acc.V.all);
         end if;
         Content_Ü_ClientType
           (Target.all).Repr_Cache :=
           Acc.Repr_Cache;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_ClientType)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotifyChannelAdmin.ClientType,
               Ptr_Ü_ClientType);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CosNotifyChannelAdmin.ClientType)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_ClientType'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_ClientType'
              (X.all'Unchecked_Access),
            Repr_Cache => 0);
      end Wrap;

      ClientType_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------
      -- Initialize_ClientType --
      ---------------------------

      procedure Initialize_ClientType is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ClientType");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/ClientType:1.0");
         ANY_EVENT_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ANY_EVENT");
         STRUCTURED_EVENT_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("STRUCTURED_EVENT");
         SEQUENCE_EVENT_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("SEQUENCE_EVENT");
      begin
         if not ClientType_Initialized
         then
            ClientType_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_ClientType :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Enum);
            CORBA.Internals.Add_Parameter
              (TC_ClientType,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ClientType,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ClientType,
               CORBA.To_Any
                 (ANY_EVENT_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ClientType,
               CORBA.To_Any
                 (STRUCTURED_EVENT_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ClientType,
               CORBA.To_Any
                 (SEQUENCE_EVENT_Name_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ClientType);
            CORBA.TypeCode.Internals.Freeze
              (TC_ClientType);
         end if;
      end Initialize_ClientType;

      --------------
      -- From_Any --
      --------------

      function From_Any
        (C : PolyORB.Any.Any_Container'Class)
        return CosNotifyChannelAdmin.InterFilterGroupOperator
      is
      begin
         return CosNotifyChannelAdmin.InterFilterGroupOperator'Val
           (PolyORB.Types.Unsigned_Long'
              (PolyORB.Any.Get_Aggregate_Element
                 (C,
                  0)));
      end From_Any;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_InterFilterGroupOperator;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc, Index);
      begin
         Acc.Repr_Cache :=
           CosNotifyChannelAdmin.InterFilterGroupOperator'Pos
              (Acc.V.all);
         Mech.all :=
           PolyORB.Any.By_Value;
         return PolyORB.Any.Wrap
           (Acc.Repr_Cache'Unrestricted_Access);
      end Get_Aggregate_Element;

      ---------------------------
      -- Set_Aggregate_Element --
      ---------------------------

      procedure Set_Aggregate_Element
        (Acc : in out Content_Ü_InterFilterGroupOperator;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         From_C : in out PolyORB.Any.Any_Container'Class)
      is
         use type PolyORB.Types.Unsigned_Long;
         pragma Assert ((Index
            = 0));
         pragma Unreferenced (Tc);
      begin
         Acc.V.all :=
           CosNotifyChannelAdmin.InterFilterGroupOperator'Val
              (PolyORB.Types.Unsigned_Long'
                 (PolyORB.Any.From_Any
                    (From_C)));
      end Set_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_InterFilterGroupOperator)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 1;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_InterFilterGroupOperator;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_InterFilterGroupOperator)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_InterFilterGroupOperator,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_InterFilterGroupOperator;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_InterFilterGroupOperator)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_InterFilterGroupOperator
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_InterFilterGroupOperator;
            Content_Ü_InterFilterGroupOperator
              (Target.all).V :=
              new CosNotifyChannelAdmin.InterFilterGroupOperator'
                 (Acc.V.all);
         end if;
         Content_Ü_InterFilterGroupOperator
           (Target.all).Repr_Cache :=
           Acc.Repr_Cache;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_InterFilterGroupOperator)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotifyChannelAdmin.InterFilterGroupOperator,
               Ptr_Ü_InterFilterGroupOperator);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CosNotifyChannelAdmin.InterFilterGroupOperator)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_InterFilterGroupOperator'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_InterFilterGroupOperator'
              (X.all'Unchecked_Access),
            Repr_Cache => 0);
      end Wrap;

      InterFilterGroupOperator_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------
      -- Initialize_InterFilterGroupOperator --
      -----------------------------------------

      procedure Initialize_InterFilterGroupOperator is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("InterFilterGroupOperator");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/InterFilterGroupOperator:1.0");
         AND_OP_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AND_OP");
         OR_OP_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("OR_OP");
      begin
         if not InterFilterGroupOperator_Initialized
         then
            InterFilterGroupOperator_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_InterFilterGroupOperator :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Enum);
            CORBA.Internals.Add_Parameter
              (TC_InterFilterGroupOperator,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_InterFilterGroupOperator,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_InterFilterGroupOperator,
               CORBA.To_Any
                 (AND_OP_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_InterFilterGroupOperator,
               CORBA.To_Any
                 (OR_OP_Name_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_InterFilterGroupOperator);
            CORBA.TypeCode.Internals.Freeze
              (TC_InterFilterGroupOperator);
         end if;
      end Initialize_InterFilterGroupOperator;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CosNotifyChannelAdmin.AdminID)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Wrap
           (CORBA.Long
              (X.all)'Unrestricted_Access);
      end Wrap;

      AdminID_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------
      -- Initialize_AdminID --
      ------------------------

      procedure Initialize_AdminID is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AdminID");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/AdminID:1.0");
      begin
         if not AdminID_Initialized
         then
            AdminID_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_AdminID :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.TC_Long);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AdminID);
            CORBA.TypeCode.Internals.Freeze
              (TC_AdminID);
         end if;
      end Initialize_AdminID;

      -------------------------------------------------------------
      -- IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID_Element_Wrap --
      -------------------------------------------------------------

      function IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID_Element_Wrap
        (X : access CosNotifyChannelAdmin.AdminID)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Wrap
           (CORBA.Long
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID_Element_Wrap;

      function Wrap
        (X : access CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID_Helper.Wrap;

      IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID --
      -----------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID is
      begin
         if not IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID_Initialized
         then
            IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.Internals.Initialize_AdminID;
            CosNotifyChannelAdmin.Helper.TC_IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotifyChannelAdmin.Helper.TC_AdminID,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotifyChannelAdmin.Helper.TC_IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID);
            IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID_Helper.Initialize
              (Element_TC => CosNotifyChannelAdmin.Helper.TC_AdminID,
               Sequence_TC => CosNotifyChannelAdmin.Helper.TC_IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID;

      AdminIDSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------
      -- Initialize_AdminIDSeq --
      ---------------------------

      procedure Initialize_AdminIDSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AdminIDSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/AdminIDSeq:1.0");
      begin
         if not AdminIDSeq_Initialized
         then
            AdminIDSeq_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID;
            CosNotifyChannelAdmin.Helper.TC_AdminIDSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotifyChannelAdmin.Helper.TC_IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AdminIDSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_AdminIDSeq);
         end if;
      end Initialize_AdminIDSeq;

      procedure Raise_AdminNotFound_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String);

      pragma No_Return (Raise_AdminNotFound_From_Any);

      ----------------------------------
      -- Raise_AdminNotFound_From_Any --
      ----------------------------------

      procedure Raise_AdminNotFound_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyChannelAdmin.AdminNotFound_Members :=
           CosNotifyChannelAdmin.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (AdminNotFound'Identity,
            Members,
            Message);
      end Raise_AdminNotFound_From_Any;

      AdminNotFound_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_AdminNotFound --
      ------------------------------

      procedure Initialize_AdminNotFound is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AdminNotFound_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/AdminNotFound:1.0");
      begin
         if not AdminNotFound_Initialized
         then
            AdminNotFound_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_AdminNotFound :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_AdminNotFound,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_AdminNotFound,
               CORBA.To_Any
                 (Id_Ü));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_AdminNotFound),
               Raise_AdminNotFound_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AdminNotFound);
            CORBA.TypeCode.Internals.Freeze
              (TC_AdminNotFound);
         end if;
      end Initialize_AdminNotFound;

      procedure Raise_ProxyNotFound_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String);

      pragma No_Return (Raise_ProxyNotFound_From_Any);

      ----------------------------------
      -- Raise_ProxyNotFound_From_Any --
      ----------------------------------

      procedure Raise_ProxyNotFound_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyChannelAdmin.ProxyNotFound_Members :=
           CosNotifyChannelAdmin.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (ProxyNotFound'Identity,
            Members,
            Message);
      end Raise_ProxyNotFound_From_Any;

      ProxyNotFound_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_ProxyNotFound --
      ------------------------------

      procedure Initialize_ProxyNotFound is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ProxyNotFound_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/ProxyNotFound:1.0");
      begin
         if not ProxyNotFound_Initialized
         then
            ProxyNotFound_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_ProxyNotFound :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_ProxyNotFound,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ProxyNotFound,
               CORBA.To_Any
                 (Id_Ü));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_ProxyNotFound),
               Raise_ProxyNotFound_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ProxyNotFound);
            CORBA.TypeCode.Internals.Freeze
              (TC_ProxyNotFound);
         end if;
      end Initialize_ProxyNotFound;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_AdminLimit;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.Any
                    (Acc.V.value)'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_AdminLimit)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 2;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_AdminLimit;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_AdminLimit)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_AdminLimit,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_AdminLimit;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_AdminLimit)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_AdminLimit
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_AdminLimit;
            Content_Ü_AdminLimit
              (Target.all).V :=
              new CosNotifyChannelAdmin.AdminLimit'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_AdminLimit)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotifyChannelAdmin.AdminLimit,
               Ptr_Ü_AdminLimit);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CosNotifyChannelAdmin.AdminLimit)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_AdminLimit'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_AdminLimit'
              (X.all'Unchecked_Access));
      end Wrap;

      AdminLimit_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------
      -- Initialize_AdminLimit --
      ---------------------------

      procedure Initialize_AdminLimit is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AdminLimit");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/AdminLimit:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_value : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("value");
      begin
         if not AdminLimit_Initialized
         then
            AdminLimit_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_AdminLimit :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_AdminLimit,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_AdminLimit,
               CORBA.To_Any
                 (Id_Ü));
            CosNotification.Helper.Internals.Initialize_PropertyName;
            CORBA.Internals.Add_Parameter
              (TC_AdminLimit,
               CORBA.To_Any
                 (CosNotification.Helper.TC_PropertyName));
            CORBA.Internals.Add_Parameter
              (TC_AdminLimit,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CosNotification.Helper.Internals.Initialize_PropertyValue;
            CORBA.Internals.Add_Parameter
              (TC_AdminLimit,
               CORBA.To_Any
                 (CosNotification.Helper.TC_PropertyValue));
            CORBA.Internals.Add_Parameter
              (TC_AdminLimit,
               CORBA.To_Any
                 (Argument_Name_Ü_value));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AdminLimit);
            CORBA.TypeCode.Internals.Freeze
              (TC_AdminLimit);
         end if;
      end Initialize_AdminLimit;

      procedure Raise_AdminLimitExceeded_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String);

      pragma No_Return (Raise_AdminLimitExceeded_From_Any);

      ---------------------------------------
      -- Raise_AdminLimitExceeded_From_Any --
      ---------------------------------------

      procedure Raise_AdminLimitExceeded_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyChannelAdmin.AdminLimitExceeded_Members :=
           CosNotifyChannelAdmin.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (AdminLimitExceeded'Identity,
            Members,
            Message);
      end Raise_AdminLimitExceeded_From_Any;

      AdminLimitExceeded_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------
      -- Initialize_AdminLimitExceeded --
      -----------------------------------

      procedure Initialize_AdminLimitExceeded is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AdminLimitExceeded_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/AdminLimitExceeded:1.0");
         Arg_Name_admin_property_err : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("admin_property_err");
      begin
         if not AdminLimitExceeded_Initialized
         then
            AdminLimitExceeded_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_AdminLimitExceeded :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_AdminLimitExceeded,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_AdminLimitExceeded,
               CORBA.To_Any
                 (Id_Ü));
            CosNotifyChannelAdmin.Helper.Internals.Initialize_AdminLimit;
            CORBA.Internals.Add_Parameter
              (TC_AdminLimitExceeded,
               CORBA.To_Any
                 (CosNotifyChannelAdmin.Helper.TC_AdminLimit));
            CORBA.Internals.Add_Parameter
              (TC_AdminLimitExceeded,
               CORBA.To_Any
                 (Arg_Name_admin_property_err));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_AdminLimitExceeded),
               Raise_AdminLimitExceeded_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AdminLimitExceeded);
            CORBA.TypeCode.Internals.Freeze
              (TC_AdminLimitExceeded);
         end if;
      end Initialize_AdminLimitExceeded;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CosNotifyChannelAdmin.ChannelID)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Wrap
           (CORBA.Long
              (X.all)'Unrestricted_Access);
      end Wrap;

      ChannelID_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------
      -- Initialize_ChannelID --
      --------------------------

      procedure Initialize_ChannelID is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ChannelID");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/ChannelID:1.0");
      begin
         if not ChannelID_Initialized
         then
            ChannelID_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_ChannelID :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.TC_Long);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ChannelID);
            CORBA.TypeCode.Internals.Freeze
              (TC_ChannelID);
         end if;
      end Initialize_ChannelID;

      ---------------------------------------------------------------
      -- IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID_Element_Wrap --
      ---------------------------------------------------------------

      function IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID_Element_Wrap
        (X : access CosNotifyChannelAdmin.ChannelID)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Wrap
           (CORBA.Long
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID_Element_Wrap;

      function Wrap
        (X : access CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID_Helper.Wrap;

      IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID --
      -------------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID is
      begin
         if not IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID_Initialized
         then
            IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.Internals.Initialize_ChannelID;
            CosNotifyChannelAdmin.Helper.TC_IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotifyChannelAdmin.Helper.TC_ChannelID,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotifyChannelAdmin.Helper.TC_IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID);
            IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID_Helper.Initialize
              (Element_TC => CosNotifyChannelAdmin.Helper.TC_ChannelID,
               Sequence_TC => CosNotifyChannelAdmin.Helper.TC_IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID;

      ChannelIDSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_ChannelIDSeq --
      -----------------------------

      procedure Initialize_ChannelIDSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ChannelIDSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/ChannelIDSeq:1.0");
      begin
         if not ChannelIDSeq_Initialized
         then
            ChannelIDSeq_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID;
            CosNotifyChannelAdmin.Helper.TC_ChannelIDSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotifyChannelAdmin.Helper.TC_IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ChannelIDSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ChannelIDSeq);
         end if;
      end Initialize_ChannelIDSeq;

      procedure Raise_ChannelNotFound_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String);

      pragma No_Return (Raise_ChannelNotFound_From_Any);

      ------------------------------------
      -- Raise_ChannelNotFound_From_Any --
      ------------------------------------

      procedure Raise_ChannelNotFound_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyChannelAdmin.ChannelNotFound_Members :=
           CosNotifyChannelAdmin.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (ChannelNotFound'Identity,
            Members,
            Message);
      end Raise_ChannelNotFound_From_Any;

      ChannelNotFound_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------
      -- Initialize_ChannelNotFound --
      --------------------------------

      procedure Initialize_ChannelNotFound is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ChannelNotFound_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyChannelAdmin/ChannelNotFound:1.0");
      begin
         if not ChannelNotFound_Initialized
         then
            ChannelNotFound_Initialized :=
              True;
            CosNotifyChannelAdmin.Helper.TC_ChannelNotFound :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_ChannelNotFound,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ChannelNotFound,
               CORBA.To_Any
                 (Id_Ü));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_ChannelNotFound),
               Raise_ChannelNotFound_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ChannelNotFound);
            CORBA.TypeCode.Internals.Freeze
              (TC_ChannelNotFound);
         end if;
      end Initialize_ChannelNotFound;

   end Internals;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.ConnectionAlreadyActive_Members
   is
      Result_Ü : CosNotifyChannelAdmin.ConnectionAlreadyActive_Members;
      pragma Warnings (Off);
      pragma Unreferenced (Item);
      pragma Warnings (On);
   begin
      return Result_Ü;
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.ConnectionAlreadyActive_Members)
     return CORBA.Any
   is
      Result_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotifyChannelAdmin.Helper.TC_ConnectionAlreadyActive);
      pragma Warnings (Off);
      pragma Unreferenced (Item);
      pragma Warnings (On);
   begin
      return Result_Ü;
   end To_Any;

   -----------------------------------
   -- Raise_ConnectionAlreadyActive --
   -----------------------------------

   procedure Raise_ConnectionAlreadyActive
     (Members : CosNotifyChannelAdmin.ConnectionAlreadyActive_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (ConnectionAlreadyActive'Identity,
         Members);
   end Raise_ConnectionAlreadyActive;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.ConnectionAlreadyInactive_Members
   is
      Result_Ü : CosNotifyChannelAdmin.ConnectionAlreadyInactive_Members;
      pragma Warnings (Off);
      pragma Unreferenced (Item);
      pragma Warnings (On);
   begin
      return Result_Ü;
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.ConnectionAlreadyInactive_Members)
     return CORBA.Any
   is
      Result_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotifyChannelAdmin.Helper.TC_ConnectionAlreadyInactive);
      pragma Warnings (Off);
      pragma Unreferenced (Item);
      pragma Warnings (On);
   begin
      return Result_Ü;
   end To_Any;

   -------------------------------------
   -- Raise_ConnectionAlreadyInactive --
   -------------------------------------

   procedure Raise_ConnectionAlreadyInactive
     (Members : CosNotifyChannelAdmin.ConnectionAlreadyInactive_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (ConnectionAlreadyInactive'Identity,
         Members);
   end Raise_ConnectionAlreadyInactive;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.NotConnected_Members
   is
      Result_Ü : CosNotifyChannelAdmin.NotConnected_Members;
      pragma Warnings (Off);
      pragma Unreferenced (Item);
      pragma Warnings (On);
   begin
      return Result_Ü;
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.NotConnected_Members)
     return CORBA.Any
   is
      Result_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotifyChannelAdmin.Helper.TC_NotConnected);
      pragma Warnings (Off);
      pragma Unreferenced (Item);
      pragma Warnings (On);
   begin
      return Result_Ü;
   end To_Any;

   ------------------------
   -- Raise_NotConnected --
   ------------------------

   procedure Raise_NotConnected
     (Members : CosNotifyChannelAdmin.NotConnected_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (NotConnected'Identity,
         Members);
   end Raise_NotConnected;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.ConsumerAdmin_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.ConsumerAdmin_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CosNotifyChannelAdmin.ConsumerAdmin_Forward.Ref
   is
      Result : CosNotifyChannelAdmin.ConsumerAdmin_Forward.Ref;
   begin
      CosNotifyChannelAdmin.ConsumerAdmin_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CosNotifyChannelAdmin.ConsumerAdmin_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CosNotifyChannelAdmin/ConsumerAdmin:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.SupplierAdmin_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.SupplierAdmin_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CosNotifyChannelAdmin.SupplierAdmin_Forward.Ref
   is
      Result : CosNotifyChannelAdmin.SupplierAdmin_Forward.Ref;
   begin
      CosNotifyChannelAdmin.SupplierAdmin_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CosNotifyChannelAdmin.SupplierAdmin_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CosNotifyChannelAdmin/SupplierAdmin:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.EventChannel_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.EventChannel_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CosNotifyChannelAdmin.EventChannel_Forward.Ref
   is
      Result : CosNotifyChannelAdmin.EventChannel_Forward.Ref;
   begin
      CosNotifyChannelAdmin.EventChannel_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CosNotifyChannelAdmin.EventChannel_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CosNotifyChannelAdmin/EventChannel:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.EventChannelFactory_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.EventChannelFactory_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CosNotifyChannelAdmin.EventChannelFactory_Forward.Ref
   is
      Result : CosNotifyChannelAdmin.EventChannelFactory_Forward.Ref;
   begin
      CosNotifyChannelAdmin.EventChannelFactory_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CosNotifyChannelAdmin.EventChannelFactory_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CosNotifyChannelAdmin/EventChannelFactory:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.ProxyType
   is
   begin
      return CosNotifyChannelAdmin.Helper.Internals.From_Any
        (CORBA.Get_Container
           (Item).all);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.ProxyType)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_ProxyType);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CosNotifyChannelAdmin.Helper.Internals.Wrap
              (new CosNotifyChannelAdmin.ProxyType'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.ObtainInfoMode
   is
   begin
      return CosNotifyChannelAdmin.Helper.Internals.From_Any
        (CORBA.Get_Container
           (Item).all);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.ObtainInfoMode)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_ObtainInfoMode);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CosNotifyChannelAdmin.Helper.Internals.Wrap
              (new CosNotifyChannelAdmin.ObtainInfoMode'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.ProxyID
   is
      Result : constant CORBA.Long :=
        CORBA.From_Any
           (Item);
   begin
      return CosNotifyChannelAdmin.ProxyID
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.ProxyID)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.To_Any
           (CORBA.Long
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ProxyID);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID.Sequence
     renames CosNotifyChannelAdmin.Helper.Internals.IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID_Helper.From_Any;

   function To_Any
     (Item : CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID.Sequence)
     return CORBA.Any
     renames CosNotifyChannelAdmin.Helper.Internals.IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.ProxyIDSeq
   is
      Result : constant CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID.Sequence :=
        CosNotifyChannelAdmin.Helper.From_Any
           (Item);
   begin
      return CosNotifyChannelAdmin.ProxyIDSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.ProxyIDSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotifyChannelAdmin.Helper.To_Any
           (CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ProxyIDSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.ClientType
   is
   begin
      return CosNotifyChannelAdmin.Helper.Internals.From_Any
        (CORBA.Get_Container
           (Item).all);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.ClientType)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_ClientType);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CosNotifyChannelAdmin.Helper.Internals.Wrap
              (new CosNotifyChannelAdmin.ClientType'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.InterFilterGroupOperator
   is
   begin
      return CosNotifyChannelAdmin.Helper.Internals.From_Any
        (CORBA.Get_Container
           (Item).all);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.InterFilterGroupOperator)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_InterFilterGroupOperator);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CosNotifyChannelAdmin.Helper.Internals.Wrap
              (new CosNotifyChannelAdmin.InterFilterGroupOperator'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.AdminID
   is
      Result : constant CORBA.Long :=
        CORBA.From_Any
           (Item);
   begin
      return CosNotifyChannelAdmin.AdminID
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.AdminID)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.To_Any
           (CORBA.Long
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_AdminID);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID.Sequence
     renames CosNotifyChannelAdmin.Helper.Internals.IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID_Helper.From_Any;

   function To_Any
     (Item : CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID.Sequence)
     return CORBA.Any
     renames CosNotifyChannelAdmin.Helper.Internals.IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.AdminIDSeq
   is
      Result : constant CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID.Sequence :=
        CosNotifyChannelAdmin.Helper.From_Any
           (Item);
   begin
      return CosNotifyChannelAdmin.AdminIDSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.AdminIDSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotifyChannelAdmin.Helper.To_Any
           (CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_AdminIDSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.AdminNotFound_Members
   is
      Result_Ü : CosNotifyChannelAdmin.AdminNotFound_Members;
      pragma Warnings (Off);
      pragma Unreferenced (Item);
      pragma Warnings (On);
   begin
      return Result_Ü;
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.AdminNotFound_Members)
     return CORBA.Any
   is
      Result_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotifyChannelAdmin.Helper.TC_AdminNotFound);
      pragma Warnings (Off);
      pragma Unreferenced (Item);
      pragma Warnings (On);
   begin
      return Result_Ü;
   end To_Any;

   -------------------------
   -- Raise_AdminNotFound --
   -------------------------

   procedure Raise_AdminNotFound
     (Members : CosNotifyChannelAdmin.AdminNotFound_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (AdminNotFound'Identity,
         Members);
   end Raise_AdminNotFound;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.ProxyNotFound_Members
   is
      Result_Ü : CosNotifyChannelAdmin.ProxyNotFound_Members;
      pragma Warnings (Off);
      pragma Unreferenced (Item);
      pragma Warnings (On);
   begin
      return Result_Ü;
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.ProxyNotFound_Members)
     return CORBA.Any
   is
      Result_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotifyChannelAdmin.Helper.TC_ProxyNotFound);
      pragma Warnings (Off);
      pragma Unreferenced (Item);
      pragma Warnings (On);
   begin
      return Result_Ü;
   end To_Any;

   -------------------------
   -- Raise_ProxyNotFound --
   -------------------------

   procedure Raise_ProxyNotFound
     (Members : CosNotifyChannelAdmin.ProxyNotFound_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (ProxyNotFound'Identity,
         Members);
   end Raise_ProxyNotFound;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.AdminLimit
   is
   begin
      return (name => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_PropertyName,
            0)),
      value => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_PropertyValue,
            1)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.AdminLimit)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_AdminLimit);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CosNotifyChannelAdmin.Helper.Internals.Wrap
              (new CosNotifyChannelAdmin.AdminLimit'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.AdminLimitExceeded_Members
   is
   begin
      return (admin_property_err => CosNotifyChannelAdmin.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotifyChannelAdmin.Helper.TC_AdminLimit,
            0)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.AdminLimitExceeded_Members)
     return CORBA.Any
   is
      Result_Ü : CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotifyChannelAdmin.Helper.TC_AdminLimitExceeded);
   begin
      CORBA.Internals.Add_Aggregate_Element
        (Result_Ü,
         CosNotifyChannelAdmin.Helper.To_Any
           (Item.admin_property_err));
      return Result_Ü;
   end To_Any;

   ------------------------------
   -- Raise_AdminLimitExceeded --
   ------------------------------

   procedure Raise_AdminLimitExceeded
     (Members : CosNotifyChannelAdmin.AdminLimitExceeded_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (AdminLimitExceeded'Identity,
         Members);
   end Raise_AdminLimitExceeded;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.ChannelID
   is
      Result : constant CORBA.Long :=
        CORBA.From_Any
           (Item);
   begin
      return CosNotifyChannelAdmin.ChannelID
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.ChannelID)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.To_Any
           (CORBA.Long
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ChannelID);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID.Sequence
     renames CosNotifyChannelAdmin.Helper.Internals.IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID_Helper.From_Any;

   function To_Any
     (Item : CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID.Sequence)
     return CORBA.Any
     renames CosNotifyChannelAdmin.Helper.Internals.IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.ChannelIDSeq
   is
      Result : constant CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID.Sequence :=
        CosNotifyChannelAdmin.Helper.From_Any
           (Item);
   begin
      return CosNotifyChannelAdmin.ChannelIDSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.ChannelIDSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotifyChannelAdmin.Helper.To_Any
           (CosNotifyChannelAdmin.IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ChannelIDSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyChannelAdmin.ChannelNotFound_Members
   is
      Result_Ü : CosNotifyChannelAdmin.ChannelNotFound_Members;
      pragma Warnings (Off);
      pragma Unreferenced (Item);
      pragma Warnings (On);
   begin
      return Result_Ü;
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CosNotifyChannelAdmin.ChannelNotFound_Members)
     return CORBA.Any
   is
      Result_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotifyChannelAdmin.Helper.TC_ChannelNotFound);
      pragma Warnings (Off);
      pragma Unreferenced (Item);
      pragma Warnings (On);
   begin
      return Result_Ü;
   end To_Any;

   ---------------------------
   -- Raise_ChannelNotFound --
   ---------------------------

   procedure Raise_ChannelNotFound
     (Members : CosNotifyChannelAdmin.ChannelNotFound_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (ChannelNotFound'Identity,
         Members);
   end Raise_ChannelNotFound;

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

   procedure Deferred_Initialization is
   begin
      CosNotifyChannelAdmin.Helper.Internals.Initialize_ConnectionAlreadyActive;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_ConnectionAlreadyInactive;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_NotConnected;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_ConsumerAdmin;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_SupplierAdmin;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_EventChannel;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_EventChannelFactory;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_ProxyType;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_ObtainInfoMode;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_ProxyID;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_ProxyID;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_ProxyIDSeq;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_ClientType;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_InterFilterGroupOperator;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_AdminID;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_AdminID;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_AdminIDSeq;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_AdminNotFound;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_ProxyNotFound;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_AdminLimit;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_AdminLimitExceeded;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_ChannelID;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyChannelAdmin_ChannelID;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_ChannelIDSeq;
      CosNotifyChannelAdmin.Helper.Internals.Initialize_ChannelNotFound;
   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.Helper",
            Conflicts => PolyORB.Utils.Strings.Lists.Empty,
            Depends => +"any"
               & "exceptions"
               & "corba",
            Provides => PolyORB.Utils.Strings.Lists.Empty,
            Implicit => False,
            Init => Deferred_Initialization'Access,
            Shutdown => null));
   end;
end CosNotifyChannelAdmin.Helper;
