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/CosNotification.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 Ada.Unchecked_Conversion;
with Ada.Unchecked_Deallocation;
with PolyORB.Exceptions;
with PolyORB.Utils.Strings;
with PolyORB.Utils.Strings.Lists;
with PolyORB.Initialization;

package body CosNotification.Helper is

   
   package body Internals is

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

      function Wrap
        (X : access CosNotification.Istring)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Wrap
           (CORBA.String
              (X.all)'Unrestricted_Access);
      end Wrap;

      Istring_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------
      -- Initialize_Istring --
      ------------------------

      procedure Initialize_Istring is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("Istring");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/Istring:1.0");
      begin
         if not Istring_Initialized
         then
            Istring_Initialized :=
              True;
            CosNotification.Helper.TC_Istring :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.TC_String);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_Istring);
            CORBA.TypeCode.Internals.Freeze
              (TC_Istring);
         end if;
      end Initialize_Istring;

      PropertyName_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_PropertyName --
      -----------------------------

      procedure Initialize_PropertyName is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PropertyName");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/PropertyName:1.0");
      begin
         if not PropertyName_Initialized
         then
            PropertyName_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_Istring;
            CosNotification.Helper.TC_PropertyName :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotification.Helper.TC_Istring);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_PropertyName);
            CORBA.TypeCode.Internals.Freeze
              (TC_PropertyName);
         end if;
      end Initialize_PropertyName;

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

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

      PropertyValue_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_PropertyValue --
      ------------------------------

      procedure Initialize_PropertyValue is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PropertyValue");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/PropertyValue:1.0");
      begin
         if not PropertyValue_Initialized
         then
            PropertyValue_Initialized :=
              True;
            CosNotification.Helper.TC_PropertyValue :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.TC_Any);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_PropertyValue);
            CORBA.TypeCode.Internals.Freeze
              (TC_PropertyValue);
         end if;
      end Initialize_PropertyValue;

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

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_Property;
         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_Ü_Property)
        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_Ü_Property;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

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

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

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

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

      function Clone
        (Acc : Content_Ü_Property;
         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_Ü_Property)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_Property
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_Property;
            Content_Ü_Property
              (Target.all).V :=
              new CosNotification.Property'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_Property)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotification.Property,
               Ptr_Ü_Property);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      Property_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------
      -- Initialize_Property --
      -------------------------

      procedure Initialize_Property is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("Property");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/Property: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 Property_Initialized
         then
            Property_Initialized :=
              True;
            CosNotification.Helper.TC_Property :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_Property,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_Property,
               CORBA.To_Any
                 (Id_Ü));
            CosNotification.Helper.Internals.Initialize_PropertyName;
            CORBA.Internals.Add_Parameter
              (TC_Property,
               CORBA.To_Any
                 (CosNotification.Helper.TC_PropertyName));
            CORBA.Internals.Add_Parameter
              (TC_Property,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CosNotification.Helper.Internals.Initialize_PropertyValue;
            CORBA.Internals.Add_Parameter
              (TC_Property,
               CORBA.To_Any
                 (CosNotification.Helper.TC_PropertyValue));
            CORBA.Internals.Add_Parameter
              (TC_Property,
               CORBA.To_Any
                 (Argument_Name_Ü_value));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_Property);
            CORBA.TypeCode.Internals.Freeze
              (TC_Property);
         end if;
      end Initialize_Property;

      --------------------------------------------------------
      -- IDL_SEQUENCE_CosNotification_Property_Element_Wrap --
      --------------------------------------------------------

      function IDL_SEQUENCE_CosNotification_Property_Element_Wrap
        (X : access CosNotification.Property)
        return PolyORB.Any.Content'Class
      is
      begin
         return CosNotification.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CosNotification_Property_Element_Wrap;

      function Wrap
        (X : access CosNotification.IDL_SEQUENCE_CosNotification_Property.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotification_Property_Helper.Wrap;

      IDL_SEQUENCE_CosNotification_Property_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotification_Property --
      ------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotification_Property is
      begin
         if not IDL_SEQUENCE_CosNotification_Property_Initialized
         then
            IDL_SEQUENCE_CosNotification_Property_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_Property;
            CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_Property :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotification.Helper.TC_Property,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_Property);
            IDL_SEQUENCE_CosNotification_Property_Helper.Initialize
              (Element_TC => CosNotification.Helper.TC_Property,
               Sequence_TC => CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_Property);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotification_Property);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotification_Property;

      PropertySeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------
      -- Initialize_PropertySeq --
      ----------------------------

      procedure Initialize_PropertySeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PropertySeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/PropertySeq:1.0");
      begin
         if not PropertySeq_Initialized
         then
            PropertySeq_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotification_Property;
            CosNotification.Helper.TC_PropertySeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_Property);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_PropertySeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_PropertySeq);
         end if;
      end Initialize_PropertySeq;

      OptionalHeaderFields_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------
      -- Initialize_OptionalHeaderFields --
      -------------------------------------

      procedure Initialize_OptionalHeaderFields is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("OptionalHeaderFields");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/OptionalHeaderFields:1.0");
      begin
         if not OptionalHeaderFields_Initialized
         then
            OptionalHeaderFields_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_PropertySeq;
            CosNotification.Helper.TC_OptionalHeaderFields :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotification.Helper.TC_PropertySeq);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_OptionalHeaderFields);
            CORBA.TypeCode.Internals.Freeze
              (TC_OptionalHeaderFields);
         end if;
      end Initialize_OptionalHeaderFields;

      FilterableEventBody_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------------
      -- Initialize_FilterableEventBody --
      ------------------------------------

      procedure Initialize_FilterableEventBody is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("FilterableEventBody");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/FilterableEventBody:1.0");
      begin
         if not FilterableEventBody_Initialized
         then
            FilterableEventBody_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_PropertySeq;
            CosNotification.Helper.TC_FilterableEventBody :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotification.Helper.TC_PropertySeq);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_FilterableEventBody);
            CORBA.TypeCode.Internals.Freeze
              (TC_FilterableEventBody);
         end if;
      end Initialize_FilterableEventBody;

      QoSProperties_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_QoSProperties --
      ------------------------------

      procedure Initialize_QoSProperties is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("QoSProperties");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/QoSProperties:1.0");
      begin
         if not QoSProperties_Initialized
         then
            QoSProperties_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_PropertySeq;
            CosNotification.Helper.TC_QoSProperties :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotification.Helper.TC_PropertySeq);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_QoSProperties);
            CORBA.TypeCode.Internals.Freeze
              (TC_QoSProperties);
         end if;
      end Initialize_QoSProperties;

      AdminProperties_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------
      -- Initialize_AdminProperties --
      --------------------------------

      procedure Initialize_AdminProperties is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AdminProperties");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/AdminProperties:1.0");
      begin
         if not AdminProperties_Initialized
         then
            AdminProperties_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_PropertySeq;
            CosNotification.Helper.TC_AdminProperties :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotification.Helper.TC_PropertySeq);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AdminProperties);
            CORBA.TypeCode.Internals.Freeze
              (TC_AdminProperties);
         end if;
      end Initialize_AdminProperties;

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

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_EventType;
         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
                 (Acc.V.domain_name'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (Acc.V.type_name'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_Ü_EventType)
        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_Ü_EventType;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

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

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

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

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

      function Clone
        (Acc : Content_Ü_EventType;
         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_Ü_EventType)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_EventType
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_EventType;
            Content_Ü_EventType
              (Target.all).V :=
              new CosNotification.EventType'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_EventType)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotification.EventType,
               Ptr_Ü_EventType);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      EventType_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------
      -- Initialize_EventType --
      --------------------------

      procedure Initialize_EventType is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("EventType");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/EventType:1.0");
         Argument_Name_Ü_domain_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("domain_name");
         Argument_Name_Ü_type_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("type_name");
      begin
         if not EventType_Initialized
         then
            EventType_Initialized :=
              True;
            CosNotification.Helper.TC_EventType :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_EventType,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_EventType,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_EventType,
               CORBA.To_Any
                 (CORBA.TC_String));
            CORBA.Internals.Add_Parameter
              (TC_EventType,
               CORBA.To_Any
                 (Argument_Name_Ü_domain_name));
            CORBA.Internals.Add_Parameter
              (TC_EventType,
               CORBA.To_Any
                 (CORBA.TC_String));
            CORBA.Internals.Add_Parameter
              (TC_EventType,
               CORBA.To_Any
                 (Argument_Name_Ü_type_name));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_EventType);
            CORBA.TypeCode.Internals.Freeze
              (TC_EventType);
         end if;
      end Initialize_EventType;

      ---------------------------------------------------------
      -- IDL_SEQUENCE_CosNotification_EventType_Element_Wrap --
      ---------------------------------------------------------

      function IDL_SEQUENCE_CosNotification_EventType_Element_Wrap
        (X : access CosNotification.EventType)
        return PolyORB.Any.Content'Class
      is
      begin
         return CosNotification.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CosNotification_EventType_Element_Wrap;

      function Wrap
        (X : access CosNotification.IDL_SEQUENCE_CosNotification_EventType.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotification_EventType_Helper.Wrap;

      IDL_SEQUENCE_CosNotification_EventType_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotification_EventType --
      -------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotification_EventType is
      begin
         if not IDL_SEQUENCE_CosNotification_EventType_Initialized
         then
            IDL_SEQUENCE_CosNotification_EventType_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_EventType;
            CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_EventType :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotification.Helper.TC_EventType,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_EventType);
            IDL_SEQUENCE_CosNotification_EventType_Helper.Initialize
              (Element_TC => CosNotification.Helper.TC_EventType,
               Sequence_TC => CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_EventType);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotification_EventType);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotification_EventType;

      EventTypeSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_EventTypeSeq --
      -----------------------------

      procedure Initialize_EventTypeSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("EventTypeSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/EventTypeSeq:1.0");
      begin
         if not EventTypeSeq_Initialized
         then
            EventTypeSeq_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotification_EventType;
            CosNotification.Helper.TC_EventTypeSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_EventType);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_EventTypeSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_EventTypeSeq);
         end if;
      end Initialize_EventTypeSeq;

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

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_PropertyRange;
         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.Any
                    (Acc.V.low_val)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.Any
                    (Acc.V.high_val)'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_Ü_PropertyRange)
        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_Ü_PropertyRange;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

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

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

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

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

      function Clone
        (Acc : Content_Ü_PropertyRange;
         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_Ü_PropertyRange)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_PropertyRange
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_PropertyRange;
            Content_Ü_PropertyRange
              (Target.all).V :=
              new CosNotification.PropertyRange'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_PropertyRange)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotification.PropertyRange,
               Ptr_Ü_PropertyRange);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      PropertyRange_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_PropertyRange --
      ------------------------------

      procedure Initialize_PropertyRange is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PropertyRange");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/PropertyRange:1.0");
         Argument_Name_Ü_low_val : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("low_val");
         Argument_Name_Ü_high_val : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("high_val");
      begin
         if not PropertyRange_Initialized
         then
            PropertyRange_Initialized :=
              True;
            CosNotification.Helper.TC_PropertyRange :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_PropertyRange,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PropertyRange,
               CORBA.To_Any
                 (Id_Ü));
            CosNotification.Helper.Internals.Initialize_PropertyValue;
            CORBA.Internals.Add_Parameter
              (TC_PropertyRange,
               CORBA.To_Any
                 (CosNotification.Helper.TC_PropertyValue));
            CORBA.Internals.Add_Parameter
              (TC_PropertyRange,
               CORBA.To_Any
                 (Argument_Name_Ü_low_val));
            CosNotification.Helper.Internals.Initialize_PropertyValue;
            CORBA.Internals.Add_Parameter
              (TC_PropertyRange,
               CORBA.To_Any
                 (CosNotification.Helper.TC_PropertyValue));
            CORBA.Internals.Add_Parameter
              (TC_PropertyRange,
               CORBA.To_Any
                 (Argument_Name_Ü_high_val));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_PropertyRange);
            CORBA.TypeCode.Internals.Freeze
              (TC_PropertyRange);
         end if;
      end Initialize_PropertyRange;

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

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_NamedPropertyRange;
         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 CosNotification.Helper.Internals.Wrap
                 (Acc.V.IDL_range'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_Ü_NamedPropertyRange)
        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_Ü_NamedPropertyRange;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

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

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

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

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

      function Clone
        (Acc : Content_Ü_NamedPropertyRange;
         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_Ü_NamedPropertyRange)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_NamedPropertyRange
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_NamedPropertyRange;
            Content_Ü_NamedPropertyRange
              (Target.all).V :=
              new CosNotification.NamedPropertyRange'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_NamedPropertyRange)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotification.NamedPropertyRange,
               Ptr_Ü_NamedPropertyRange);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      NamedPropertyRange_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------
      -- Initialize_NamedPropertyRange --
      -----------------------------------

      procedure Initialize_NamedPropertyRange is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("NamedPropertyRange");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/NamedPropertyRange:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_IDL_range : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL_range");
      begin
         if not NamedPropertyRange_Initialized
         then
            NamedPropertyRange_Initialized :=
              True;
            CosNotification.Helper.TC_NamedPropertyRange :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_NamedPropertyRange,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_NamedPropertyRange,
               CORBA.To_Any
                 (Id_Ü));
            CosNotification.Helper.Internals.Initialize_PropertyName;
            CORBA.Internals.Add_Parameter
              (TC_NamedPropertyRange,
               CORBA.To_Any
                 (CosNotification.Helper.TC_PropertyName));
            CORBA.Internals.Add_Parameter
              (TC_NamedPropertyRange,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CosNotification.Helper.Internals.Initialize_PropertyRange;
            CORBA.Internals.Add_Parameter
              (TC_NamedPropertyRange,
               CORBA.To_Any
                 (CosNotification.Helper.TC_PropertyRange));
            CORBA.Internals.Add_Parameter
              (TC_NamedPropertyRange,
               CORBA.To_Any
                 (Argument_Name_Ü_IDL_range));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_NamedPropertyRange);
            CORBA.TypeCode.Internals.Freeze
              (TC_NamedPropertyRange);
         end if;
      end Initialize_NamedPropertyRange;

      ------------------------------------------------------------------
      -- IDL_SEQUENCE_CosNotification_NamedPropertyRange_Element_Wrap --
      ------------------------------------------------------------------

      function IDL_SEQUENCE_CosNotification_NamedPropertyRange_Element_Wrap
        (X : access CosNotification.NamedPropertyRange)
        return PolyORB.Any.Content'Class
      is
      begin
         return CosNotification.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CosNotification_NamedPropertyRange_Element_Wrap;

      function Wrap
        (X : access CosNotification.IDL_SEQUENCE_CosNotification_NamedPropertyRange.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotification_NamedPropertyRange_Helper.Wrap;

      IDL_SEQUENCE_CosNotification_NamedPropertyRange_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotification_NamedPropertyRange --
      ----------------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotification_NamedPropertyRange is
      begin
         if not IDL_SEQUENCE_CosNotification_NamedPropertyRange_Initialized
         then
            IDL_SEQUENCE_CosNotification_NamedPropertyRange_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_NamedPropertyRange;
            CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_NamedPropertyRange :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotification.Helper.TC_NamedPropertyRange,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_NamedPropertyRange);
            IDL_SEQUENCE_CosNotification_NamedPropertyRange_Helper.Initialize
              (Element_TC => CosNotification.Helper.TC_NamedPropertyRange,
               Sequence_TC => CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_NamedPropertyRange);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotification_NamedPropertyRange);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotification_NamedPropertyRange;

      NamedPropertyRangeSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------
      -- Initialize_NamedPropertyRangeSeq --
      --------------------------------------

      procedure Initialize_NamedPropertyRangeSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("NamedPropertyRangeSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/NamedPropertyRangeSeq:1.0");
      begin
         if not NamedPropertyRangeSeq_Initialized
         then
            NamedPropertyRangeSeq_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotification_NamedPropertyRange;
            CosNotification.Helper.TC_NamedPropertyRangeSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_NamedPropertyRange);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_NamedPropertyRangeSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_NamedPropertyRangeSeq);
         end if;
      end Initialize_NamedPropertyRangeSeq;

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

      function From_Any
        (C : PolyORB.Any.Any_Container'Class)
        return CosNotification.QoSError_code
      is
      begin
         return CosNotification.QoSError_code'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_Ü_QoSError_code;
         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 :=
           CosNotification.QoSError_code'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_Ü_QoSError_code;
         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 :=
           CosNotification.QoSError_code'Val
              (PolyORB.Types.Unsigned_Long'
                 (PolyORB.Any.From_Any
                    (From_C)));
      end Set_Aggregate_Element;

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

      function Get_Aggregate_Count
        (Acc : Content_Ü_QoSError_code)
        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_Ü_QoSError_code;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

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

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

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

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

      function Clone
        (Acc : Content_Ü_QoSError_code;
         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_Ü_QoSError_code)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_QoSError_code
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_QoSError_code;
            Content_Ü_QoSError_code
              (Target.all).V :=
              new CosNotification.QoSError_code'
                 (Acc.V.all);
         end if;
         Content_Ü_QoSError_code
           (Target.all).Repr_Cache :=
           Acc.Repr_Cache;
         return Target;
      end Clone;

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_QoSError_code)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotification.QoSError_code,
               Ptr_Ü_QoSError_code);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      QoSError_code_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_QoSError_code --
      ------------------------------

      procedure Initialize_QoSError_code is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("QoSError_code");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/QoSError_code:1.0");
         UNSUPPORTED_PROPERTY_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("UNSUPPORTED_PROPERTY");
         UNAVAILABLE_PROPERTY_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("UNAVAILABLE_PROPERTY");
         UNSUPPORTED_VALUE_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("UNSUPPORTED_VALUE");
         UNAVAILABLE_VALUE_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("UNAVAILABLE_VALUE");
         BAD_PROPERTY_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("BAD_PROPERTY");
         BAD_TYPE_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("BAD_TYPE");
         BAD_VALUE_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("BAD_VALUE");
      begin
         if not QoSError_code_Initialized
         then
            QoSError_code_Initialized :=
              True;
            CosNotification.Helper.TC_QoSError_code :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Enum);
            CORBA.Internals.Add_Parameter
              (TC_QoSError_code,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_QoSError_code,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_QoSError_code,
               CORBA.To_Any
                 (UNSUPPORTED_PROPERTY_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_QoSError_code,
               CORBA.To_Any
                 (UNAVAILABLE_PROPERTY_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_QoSError_code,
               CORBA.To_Any
                 (UNSUPPORTED_VALUE_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_QoSError_code,
               CORBA.To_Any
                 (UNAVAILABLE_VALUE_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_QoSError_code,
               CORBA.To_Any
                 (BAD_PROPERTY_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_QoSError_code,
               CORBA.To_Any
                 (BAD_TYPE_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_QoSError_code,
               CORBA.To_Any
                 (BAD_VALUE_Name_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_QoSError_code);
            CORBA.TypeCode.Internals.Freeze
              (TC_QoSError_code);
         end if;
      end Initialize_QoSError_code;

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

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_PropertyError;
         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 CosNotification.Helper.Internals.Wrap
                 (Acc.V.code'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 2 =>
               return CosNotification.Helper.Internals.Wrap
                 (Acc.V.available_range'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_Ü_PropertyError)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 3;
      end Get_Aggregate_Count;

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

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

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

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

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

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

      function Clone
        (Acc : Content_Ü_PropertyError;
         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_Ü_PropertyError)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_PropertyError
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_PropertyError;
            Content_Ü_PropertyError
              (Target.all).V :=
              new CosNotification.PropertyError'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_PropertyError)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotification.PropertyError,
               Ptr_Ü_PropertyError);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      PropertyError_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_PropertyError --
      ------------------------------

      procedure Initialize_PropertyError is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PropertyError");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/PropertyError:1.0");
         Argument_Name_Ü_code : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("code");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_available_range : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("available_range");
      begin
         if not PropertyError_Initialized
         then
            PropertyError_Initialized :=
              True;
            CosNotification.Helper.TC_PropertyError :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_PropertyError,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PropertyError,
               CORBA.To_Any
                 (Id_Ü));
            CosNotification.Helper.Internals.Initialize_QoSError_code;
            CORBA.Internals.Add_Parameter
              (TC_PropertyError,
               CORBA.To_Any
                 (CosNotification.Helper.TC_QoSError_code));
            CORBA.Internals.Add_Parameter
              (TC_PropertyError,
               CORBA.To_Any
                 (Argument_Name_Ü_code));
            CosNotification.Helper.Internals.Initialize_PropertyName;
            CORBA.Internals.Add_Parameter
              (TC_PropertyError,
               CORBA.To_Any
                 (CosNotification.Helper.TC_PropertyName));
            CORBA.Internals.Add_Parameter
              (TC_PropertyError,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CosNotification.Helper.Internals.Initialize_PropertyRange;
            CORBA.Internals.Add_Parameter
              (TC_PropertyError,
               CORBA.To_Any
                 (CosNotification.Helper.TC_PropertyRange));
            CORBA.Internals.Add_Parameter
              (TC_PropertyError,
               CORBA.To_Any
                 (Argument_Name_Ü_available_range));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_PropertyError);
            CORBA.TypeCode.Internals.Freeze
              (TC_PropertyError);
         end if;
      end Initialize_PropertyError;

      -------------------------------------------------------------
      -- IDL_SEQUENCE_CosNotification_PropertyError_Element_Wrap --
      -------------------------------------------------------------

      function IDL_SEQUENCE_CosNotification_PropertyError_Element_Wrap
        (X : access CosNotification.PropertyError)
        return PolyORB.Any.Content'Class
      is
      begin
         return CosNotification.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CosNotification_PropertyError_Element_Wrap;

      function Wrap
        (X : access CosNotification.IDL_SEQUENCE_CosNotification_PropertyError.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotification_PropertyError_Helper.Wrap;

      IDL_SEQUENCE_CosNotification_PropertyError_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotification_PropertyError --
      -----------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotification_PropertyError is
      begin
         if not IDL_SEQUENCE_CosNotification_PropertyError_Initialized
         then
            IDL_SEQUENCE_CosNotification_PropertyError_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_PropertyError;
            CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_PropertyError :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotification.Helper.TC_PropertyError,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_PropertyError);
            IDL_SEQUENCE_CosNotification_PropertyError_Helper.Initialize
              (Element_TC => CosNotification.Helper.TC_PropertyError,
               Sequence_TC => CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_PropertyError);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotification_PropertyError);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotification_PropertyError;

      PropertyErrorSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------------
      -- Initialize_PropertyErrorSeq --
      ---------------------------------

      procedure Initialize_PropertyErrorSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PropertyErrorSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/PropertyErrorSeq:1.0");
      begin
         if not PropertyErrorSeq_Initialized
         then
            PropertyErrorSeq_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotification_PropertyError;
            CosNotification.Helper.TC_PropertyErrorSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_PropertyError);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_PropertyErrorSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_PropertyErrorSeq);
         end if;
      end Initialize_PropertyErrorSeq;

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

      pragma No_Return (Raise_UnsupportedQoS_From_Any);

      -----------------------------------
      -- Raise_UnsupportedQoS_From_Any --
      -----------------------------------

      procedure Raise_UnsupportedQoS_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotification.UnsupportedQoS_Members :=
           CosNotification.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (UnsupportedQoS'Identity,
            Members,
            Message);
      end Raise_UnsupportedQoS_From_Any;

      UnsupportedQoS_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------
      -- Initialize_UnsupportedQoS --
      -------------------------------

      procedure Initialize_UnsupportedQoS is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("UnsupportedQoS_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/UnsupportedQoS:1.0");
         Arg_Name_qos_err : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("qos_err");
      begin
         if not UnsupportedQoS_Initialized
         then
            UnsupportedQoS_Initialized :=
              True;
            CosNotification.Helper.TC_UnsupportedQoS :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_UnsupportedQoS,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_UnsupportedQoS,
               CORBA.To_Any
                 (Id_Ü));
            CosNotification.Helper.Internals.Initialize_PropertyErrorSeq;
            CORBA.Internals.Add_Parameter
              (TC_UnsupportedQoS,
               CORBA.To_Any
                 (CosNotification.Helper.TC_PropertyErrorSeq));
            CORBA.Internals.Add_Parameter
              (TC_UnsupportedQoS,
               CORBA.To_Any
                 (Arg_Name_qos_err));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_UnsupportedQoS),
               Raise_UnsupportedQoS_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_UnsupportedQoS);
            CORBA.TypeCode.Internals.Freeze
              (TC_UnsupportedQoS);
         end if;
      end Initialize_UnsupportedQoS;

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

      pragma No_Return (Raise_UnsupportedAdmin_From_Any);

      -------------------------------------
      -- Raise_UnsupportedAdmin_From_Any --
      -------------------------------------

      procedure Raise_UnsupportedAdmin_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotification.UnsupportedAdmin_Members :=
           CosNotification.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (UnsupportedAdmin'Identity,
            Members,
            Message);
      end Raise_UnsupportedAdmin_From_Any;

      UnsupportedAdmin_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------------
      -- Initialize_UnsupportedAdmin --
      ---------------------------------

      procedure Initialize_UnsupportedAdmin is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("UnsupportedAdmin_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/UnsupportedAdmin:1.0");
         Arg_Name_admin_err : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("admin_err");
      begin
         if not UnsupportedAdmin_Initialized
         then
            UnsupportedAdmin_Initialized :=
              True;
            CosNotification.Helper.TC_UnsupportedAdmin :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_UnsupportedAdmin,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_UnsupportedAdmin,
               CORBA.To_Any
                 (Id_Ü));
            CosNotification.Helper.Internals.Initialize_PropertyErrorSeq;
            CORBA.Internals.Add_Parameter
              (TC_UnsupportedAdmin,
               CORBA.To_Any
                 (CosNotification.Helper.TC_PropertyErrorSeq));
            CORBA.Internals.Add_Parameter
              (TC_UnsupportedAdmin,
               CORBA.To_Any
                 (Arg_Name_admin_err));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_UnsupportedAdmin),
               Raise_UnsupportedAdmin_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_UnsupportedAdmin);
            CORBA.TypeCode.Internals.Freeze
              (TC_UnsupportedAdmin);
         end if;
      end Initialize_UnsupportedAdmin;

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

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_FixedEventHeader;
         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 CosNotification.Helper.Internals.Wrap
                 (Acc.V.event_type'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (Acc.V.event_name'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_Ü_FixedEventHeader)
        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_Ü_FixedEventHeader;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

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

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

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

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

      function Clone
        (Acc : Content_Ü_FixedEventHeader;
         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_Ü_FixedEventHeader)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_FixedEventHeader
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_FixedEventHeader;
            Content_Ü_FixedEventHeader
              (Target.all).V :=
              new CosNotification.FixedEventHeader'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_FixedEventHeader)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotification.FixedEventHeader,
               Ptr_Ü_FixedEventHeader);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      FixedEventHeader_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------------
      -- Initialize_FixedEventHeader --
      ---------------------------------

      procedure Initialize_FixedEventHeader is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("FixedEventHeader");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/FixedEventHeader:1.0");
         Argument_Name_Ü_event_type : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("event_type");
         Argument_Name_Ü_event_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("event_name");
      begin
         if not FixedEventHeader_Initialized
         then
            FixedEventHeader_Initialized :=
              True;
            CosNotification.Helper.TC_FixedEventHeader :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_FixedEventHeader,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_FixedEventHeader,
               CORBA.To_Any
                 (Id_Ü));
            CosNotification.Helper.Internals.Initialize_EventType;
            CORBA.Internals.Add_Parameter
              (TC_FixedEventHeader,
               CORBA.To_Any
                 (CosNotification.Helper.TC_EventType));
            CORBA.Internals.Add_Parameter
              (TC_FixedEventHeader,
               CORBA.To_Any
                 (Argument_Name_Ü_event_type));
            CORBA.Internals.Add_Parameter
              (TC_FixedEventHeader,
               CORBA.To_Any
                 (CORBA.TC_String));
            CORBA.Internals.Add_Parameter
              (TC_FixedEventHeader,
               CORBA.To_Any
                 (Argument_Name_Ü_event_name));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_FixedEventHeader);
            CORBA.TypeCode.Internals.Freeze
              (TC_FixedEventHeader);
         end if;
      end Initialize_FixedEventHeader;

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

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_EventHeader;
         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 CosNotification.Helper.Internals.Wrap
                 (Acc.V.fixed_header'Unrestricted_Access);
            when 1 =>
               return CosNotification.Helper.Internals.Wrap
                 (CosNotification.IDL_SEQUENCE_CosNotification_Property.Sequence
                    (Acc.V.variable_header)'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_Ü_EventHeader)
        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_Ü_EventHeader;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

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

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

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

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

      function Clone
        (Acc : Content_Ü_EventHeader;
         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_Ü_EventHeader)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_EventHeader
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_EventHeader;
            Content_Ü_EventHeader
              (Target.all).V :=
              new CosNotification.EventHeader'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_EventHeader)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotification.EventHeader,
               Ptr_Ü_EventHeader);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      EventHeader_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------
      -- Initialize_EventHeader --
      ----------------------------

      procedure Initialize_EventHeader is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("EventHeader");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/EventHeader:1.0");
         Argument_Name_Ü_fixed_header : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("fixed_header");
         Argument_Name_Ü_variable_header : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("variable_header");
      begin
         if not EventHeader_Initialized
         then
            EventHeader_Initialized :=
              True;
            CosNotification.Helper.TC_EventHeader :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_EventHeader,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_EventHeader,
               CORBA.To_Any
                 (Id_Ü));
            CosNotification.Helper.Internals.Initialize_FixedEventHeader;
            CORBA.Internals.Add_Parameter
              (TC_EventHeader,
               CORBA.To_Any
                 (CosNotification.Helper.TC_FixedEventHeader));
            CORBA.Internals.Add_Parameter
              (TC_EventHeader,
               CORBA.To_Any
                 (Argument_Name_Ü_fixed_header));
            CosNotification.Helper.Internals.Initialize_OptionalHeaderFields;
            CORBA.Internals.Add_Parameter
              (TC_EventHeader,
               CORBA.To_Any
                 (CosNotification.Helper.TC_OptionalHeaderFields));
            CORBA.Internals.Add_Parameter
              (TC_EventHeader,
               CORBA.To_Any
                 (Argument_Name_Ü_variable_header));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_EventHeader);
            CORBA.TypeCode.Internals.Freeze
              (TC_EventHeader);
         end if;
      end Initialize_EventHeader;

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

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_StructuredEvent;
         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 CosNotification.Helper.Internals.Wrap
                 (Acc.V.header'Unrestricted_Access);
            when 1 =>
               return CosNotification.Helper.Internals.Wrap
                 (CosNotification.IDL_SEQUENCE_CosNotification_Property.Sequence
                    (Acc.V.filterable_data)'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (Acc.V.remainder_of_body'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_Ü_StructuredEvent)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 3;
      end Get_Aggregate_Count;

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

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

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

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

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

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

      function Clone
        (Acc : Content_Ü_StructuredEvent;
         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_Ü_StructuredEvent)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_StructuredEvent
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_StructuredEvent;
            Content_Ü_StructuredEvent
              (Target.all).V :=
              new CosNotification.StructuredEvent'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_StructuredEvent)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotification.StructuredEvent,
               Ptr_Ü_StructuredEvent);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      StructuredEvent_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------
      -- Initialize_StructuredEvent --
      --------------------------------

      procedure Initialize_StructuredEvent is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("StructuredEvent");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/StructuredEvent:1.0");
         Argument_Name_Ü_header : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("header");
         Argument_Name_Ü_filterable_data : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("filterable_data");
         Argument_Name_Ü_remainder_of_body : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("remainder_of_body");
      begin
         if not StructuredEvent_Initialized
         then
            StructuredEvent_Initialized :=
              True;
            CosNotification.Helper.TC_StructuredEvent :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_StructuredEvent,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_StructuredEvent,
               CORBA.To_Any
                 (Id_Ü));
            CosNotification.Helper.Internals.Initialize_EventHeader;
            CORBA.Internals.Add_Parameter
              (TC_StructuredEvent,
               CORBA.To_Any
                 (CosNotification.Helper.TC_EventHeader));
            CORBA.Internals.Add_Parameter
              (TC_StructuredEvent,
               CORBA.To_Any
                 (Argument_Name_Ü_header));
            CosNotification.Helper.Internals.Initialize_FilterableEventBody;
            CORBA.Internals.Add_Parameter
              (TC_StructuredEvent,
               CORBA.To_Any
                 (CosNotification.Helper.TC_FilterableEventBody));
            CORBA.Internals.Add_Parameter
              (TC_StructuredEvent,
               CORBA.To_Any
                 (Argument_Name_Ü_filterable_data));
            CORBA.Internals.Add_Parameter
              (TC_StructuredEvent,
               CORBA.To_Any
                 (CORBA.TC_Any));
            CORBA.Internals.Add_Parameter
              (TC_StructuredEvent,
               CORBA.To_Any
                 (Argument_Name_Ü_remainder_of_body));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_StructuredEvent);
            CORBA.TypeCode.Internals.Freeze
              (TC_StructuredEvent);
         end if;
      end Initialize_StructuredEvent;

      ---------------------------------------------------------------
      -- IDL_SEQUENCE_CosNotification_StructuredEvent_Element_Wrap --
      ---------------------------------------------------------------

      function IDL_SEQUENCE_CosNotification_StructuredEvent_Element_Wrap
        (X : access CosNotification.StructuredEvent)
        return PolyORB.Any.Content'Class
      is
      begin
         return CosNotification.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CosNotification_StructuredEvent_Element_Wrap;

      function Wrap
        (X : access CosNotification.IDL_SEQUENCE_CosNotification_StructuredEvent.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotification_StructuredEvent_Helper.Wrap;

      IDL_SEQUENCE_CosNotification_StructuredEvent_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotification_StructuredEvent --
      -------------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotification_StructuredEvent is
      begin
         if not IDL_SEQUENCE_CosNotification_StructuredEvent_Initialized
         then
            IDL_SEQUENCE_CosNotification_StructuredEvent_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_StructuredEvent;
            CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_StructuredEvent :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotification.Helper.TC_StructuredEvent,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_StructuredEvent);
            IDL_SEQUENCE_CosNotification_StructuredEvent_Helper.Initialize
              (Element_TC => CosNotification.Helper.TC_StructuredEvent,
               Sequence_TC => CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_StructuredEvent);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotification_StructuredEvent);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotification_StructuredEvent;

      EventBatch_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------
      -- Initialize_EventBatch --
      ---------------------------

      procedure Initialize_EventBatch is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("EventBatch");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotification/EventBatch:1.0");
      begin
         if not EventBatch_Initialized
         then
            EventBatch_Initialized :=
              True;
            CosNotification.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotification_StructuredEvent;
            CosNotification.Helper.TC_EventBatch :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotification.Helper.TC_IDL_SEQUENCE_CosNotification_StructuredEvent);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_EventBatch);
            CORBA.TypeCode.Internals.Freeze
              (TC_EventBatch);
         end if;
      end Initialize_EventBatch;

   end Internals;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.Istring
   is
      Result : constant CORBA.String :=
        CORBA.From_Any
           (Item);
   begin
      return CosNotification.Istring
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotification.Istring)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.To_Any
           (CORBA.String
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_Istring);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.PropertyName
   is
      Result : constant CosNotification.Istring :=
        CosNotification.Helper.From_Any
           (Item);
   begin
      return CosNotification.PropertyName
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotification.PropertyName)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotification.Helper.To_Any
           (CosNotification.Istring
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_PropertyName);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.PropertyValue
   is
      Result : constant CORBA.Any :=
        CORBA.From_Any
           (Item);
   begin
      return CosNotification.PropertyValue
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotification.PropertyValue)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.To_Any
           (CORBA.Any
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_PropertyValue);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.Property
   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 : CosNotification.Property)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_Property);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CosNotification.Helper.Internals.Wrap
              (new CosNotification.Property'
                 (Item))),
         False);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.IDL_SEQUENCE_CosNotification_Property.Sequence
     renames CosNotification.Helper.Internals.IDL_SEQUENCE_CosNotification_Property_Helper.From_Any;

   function To_Any
     (Item : CosNotification.IDL_SEQUENCE_CosNotification_Property.Sequence)
     return CORBA.Any
     renames CosNotification.Helper.Internals.IDL_SEQUENCE_CosNotification_Property_Helper.To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.PropertySeq
   is
      Result : constant CosNotification.IDL_SEQUENCE_CosNotification_Property.Sequence :=
        CosNotification.Helper.From_Any
           (Item);
   begin
      return CosNotification.PropertySeq
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotification.PropertySeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotification.Helper.To_Any
           (CosNotification.IDL_SEQUENCE_CosNotification_Property.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_PropertySeq);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.OptionalHeaderFields
   is
      Result : constant CosNotification.PropertySeq :=
        CosNotification.Helper.From_Any
           (Item);
   begin
      return CosNotification.OptionalHeaderFields
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotification.OptionalHeaderFields)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotification.Helper.To_Any
           (CosNotification.PropertySeq
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_OptionalHeaderFields);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.FilterableEventBody
   is
      Result : constant CosNotification.PropertySeq :=
        CosNotification.Helper.From_Any
           (Item);
   begin
      return CosNotification.FilterableEventBody
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotification.FilterableEventBody)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotification.Helper.To_Any
           (CosNotification.PropertySeq
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_FilterableEventBody);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.QoSProperties
   is
      Result : constant CosNotification.PropertySeq :=
        CosNotification.Helper.From_Any
           (Item);
   begin
      return CosNotification.QoSProperties
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotification.QoSProperties)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotification.Helper.To_Any
           (CosNotification.PropertySeq
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_QoSProperties);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.AdminProperties
   is
      Result : constant CosNotification.PropertySeq :=
        CosNotification.Helper.From_Any
           (Item);
   begin
      return CosNotification.AdminProperties
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotification.AdminProperties)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotification.Helper.To_Any
           (CosNotification.PropertySeq
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_AdminProperties);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.EventType
   is
   begin
      return (domain_name => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_String,
            0)),
      type_name => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_String,
            1)));
   end From_Any;

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

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.IDL_SEQUENCE_CosNotification_EventType.Sequence
     renames CosNotification.Helper.Internals.IDL_SEQUENCE_CosNotification_EventType_Helper.From_Any;

   function To_Any
     (Item : CosNotification.IDL_SEQUENCE_CosNotification_EventType.Sequence)
     return CORBA.Any
     renames CosNotification.Helper.Internals.IDL_SEQUENCE_CosNotification_EventType_Helper.To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.EventTypeSeq
   is
      Result : constant CosNotification.IDL_SEQUENCE_CosNotification_EventType.Sequence :=
        CosNotification.Helper.From_Any
           (Item);
   begin
      return CosNotification.EventTypeSeq
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotification.EventTypeSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotification.Helper.To_Any
           (CosNotification.IDL_SEQUENCE_CosNotification_EventType.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_EventTypeSeq);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.PropertyRange
   is
   begin
      return (low_val => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_PropertyValue,
            0)),
      high_val => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_PropertyValue,
            1)));
   end From_Any;

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

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

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.NamedPropertyRange
   is
   begin
      return (name => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_PropertyName,
            0)),
      IDL_range => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_PropertyRange,
            1)));
   end From_Any;

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

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.IDL_SEQUENCE_CosNotification_NamedPropertyRange.Sequence
     renames CosNotification.Helper.Internals.IDL_SEQUENCE_CosNotification_NamedPropertyRange_Helper.From_Any;

   function To_Any
     (Item : CosNotification.IDL_SEQUENCE_CosNotification_NamedPropertyRange.Sequence)
     return CORBA.Any
     renames CosNotification.Helper.Internals.IDL_SEQUENCE_CosNotification_NamedPropertyRange_Helper.To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.NamedPropertyRangeSeq
   is
      Result : constant CosNotification.IDL_SEQUENCE_CosNotification_NamedPropertyRange.Sequence :=
        CosNotification.Helper.From_Any
           (Item);
   begin
      return CosNotification.NamedPropertyRangeSeq
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotification.NamedPropertyRangeSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotification.Helper.To_Any
           (CosNotification.IDL_SEQUENCE_CosNotification_NamedPropertyRange.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_NamedPropertyRangeSeq);
      return Result;
   end To_Any;

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

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

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

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

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.PropertyError
   is
   begin
      return (code => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_QoSError_code,
            0)),
      name => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_PropertyName,
            1)),
      available_range => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_PropertyRange,
            2)));
   end From_Any;

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

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.IDL_SEQUENCE_CosNotification_PropertyError.Sequence
     renames CosNotification.Helper.Internals.IDL_SEQUENCE_CosNotification_PropertyError_Helper.From_Any;

   function To_Any
     (Item : CosNotification.IDL_SEQUENCE_CosNotification_PropertyError.Sequence)
     return CORBA.Any
     renames CosNotification.Helper.Internals.IDL_SEQUENCE_CosNotification_PropertyError_Helper.To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.PropertyErrorSeq
   is
      Result : constant CosNotification.IDL_SEQUENCE_CosNotification_PropertyError.Sequence :=
        CosNotification.Helper.From_Any
           (Item);
   begin
      return CosNotification.PropertyErrorSeq
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotification.PropertyErrorSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotification.Helper.To_Any
           (CosNotification.IDL_SEQUENCE_CosNotification_PropertyError.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_PropertyErrorSeq);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.UnsupportedQoS_Members
   is
   begin
      return (qos_err => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_PropertyErrorSeq,
            0)));
   end From_Any;

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

   function To_Any
     (Item : CosNotification.UnsupportedQoS_Members)
     return CORBA.Any
   is
      Result_Ü : CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotification.Helper.TC_UnsupportedQoS);
   begin
      CORBA.Internals.Add_Aggregate_Element
        (Result_Ü,
         CosNotification.Helper.To_Any
           (Item.qos_err));
      return Result_Ü;
   end To_Any;

   --------------------------
   -- Raise_UnsupportedQoS --
   --------------------------

   procedure Raise_UnsupportedQoS
     (Members : CosNotification.UnsupportedQoS_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (UnsupportedQoS'Identity,
         Members);
   end Raise_UnsupportedQoS;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.UnsupportedAdmin_Members
   is
   begin
      return (admin_err => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_PropertyErrorSeq,
            0)));
   end From_Any;

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

   function To_Any
     (Item : CosNotification.UnsupportedAdmin_Members)
     return CORBA.Any
   is
      Result_Ü : CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotification.Helper.TC_UnsupportedAdmin);
   begin
      CORBA.Internals.Add_Aggregate_Element
        (Result_Ü,
         CosNotification.Helper.To_Any
           (Item.admin_err));
      return Result_Ü;
   end To_Any;

   ----------------------------
   -- Raise_UnsupportedAdmin --
   ----------------------------

   procedure Raise_UnsupportedAdmin
     (Members : CosNotification.UnsupportedAdmin_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (UnsupportedAdmin'Identity,
         Members);
   end Raise_UnsupportedAdmin;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.FixedEventHeader
   is
   begin
      return (event_type => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_EventType,
            0)),
      event_name => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_String,
            1)));
   end From_Any;

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

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

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.EventHeader
   is
   begin
      return (fixed_header => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_FixedEventHeader,
            0)),
      variable_header => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_OptionalHeaderFields,
            1)));
   end From_Any;

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

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

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.StructuredEvent
   is
   begin
      return (header => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_EventHeader,
            0)),
      filterable_data => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_FilterableEventBody,
            1)),
      remainder_of_body => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_Any,
            2)));
   end From_Any;

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

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.IDL_SEQUENCE_CosNotification_StructuredEvent.Sequence
     renames CosNotification.Helper.Internals.IDL_SEQUENCE_CosNotification_StructuredEvent_Helper.From_Any;

   function To_Any
     (Item : CosNotification.IDL_SEQUENCE_CosNotification_StructuredEvent.Sequence)
     return CORBA.Any
     renames CosNotification.Helper.Internals.IDL_SEQUENCE_CosNotification_StructuredEvent_Helper.To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotification.EventBatch
   is
      Result : constant CosNotification.IDL_SEQUENCE_CosNotification_StructuredEvent.Sequence :=
        CosNotification.Helper.From_Any
           (Item);
   begin
      return CosNotification.EventBatch
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotification.EventBatch)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotification.Helper.To_Any
           (CosNotification.IDL_SEQUENCE_CosNotification_StructuredEvent.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_EventBatch);
      return Result;
   end To_Any;

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

   procedure Deferred_Initialization is
   begin
      CosNotification.Helper.Internals.Initialize_Istring;
      CosNotification.Helper.Internals.Initialize_PropertyName;
      CosNotification.Helper.Internals.Initialize_PropertyValue;
      CosNotification.Helper.Internals.Initialize_Property;
      CosNotification.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotification_Property;
      CosNotification.Helper.Internals.Initialize_PropertySeq;
      CosNotification.Helper.Internals.Initialize_OptionalHeaderFields;
      CosNotification.Helper.Internals.Initialize_FilterableEventBody;
      CosNotification.Helper.Internals.Initialize_QoSProperties;
      CosNotification.Helper.Internals.Initialize_AdminProperties;
      CosNotification.Helper.Internals.Initialize_EventType;
      CosNotification.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotification_EventType;
      CosNotification.Helper.Internals.Initialize_EventTypeSeq;
      CosNotification.Helper.Internals.Initialize_PropertyRange;
      CosNotification.Helper.Internals.Initialize_NamedPropertyRange;
      CosNotification.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotification_NamedPropertyRange;
      CosNotification.Helper.Internals.Initialize_NamedPropertyRangeSeq;
      CosNotification.Helper.Internals.Initialize_QoSError_code;
      CosNotification.Helper.Internals.Initialize_PropertyError;
      CosNotification.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotification_PropertyError;
      CosNotification.Helper.Internals.Initialize_PropertyErrorSeq;
      CosNotification.Helper.Internals.Initialize_UnsupportedQoS;
      CosNotification.Helper.Internals.Initialize_UnsupportedAdmin;
      CosNotification.Helper.Internals.Initialize_FixedEventHeader;
      CosNotification.Helper.Internals.Initialize_EventHeader;
      CosNotification.Helper.Internals.Initialize_StructuredEvent;
      CosNotification.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotification_StructuredEvent;
      CosNotification.Helper.Internals.Initialize_EventBatch;
   end Deferred_Initialization;

begin
   declare
      use PolyORB.Utils.Strings;
      use PolyORB.Utils.Strings.Lists;
   begin
      PolyORB.Initialization.Register_Module
        (PolyORB.Initialization.Module_Info'
           (Name => +"CosNotification.Helper",
            Conflicts => PolyORB.Utils.Strings.Lists.Empty,
            Depends => +"any"
               & "corba"
               & "exceptions",
            Provides => PolyORB.Utils.Strings.Lists.Empty,
            Implicit => False,
            Init => Deferred_Initialization'Access,
            Shutdown => null));
   end;
end CosNotification.Helper;
