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/CosNotifyFilter.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 CosNotification.Helper;
with CosNotification;
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 CosNotifyFilter.Helper is

   
   package body Internals is

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

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

      ConstraintID_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_ConstraintID --
      -----------------------------

      procedure Initialize_ConstraintID is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ConstraintID");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/ConstraintID:1.0");
      begin
         if not ConstraintID_Initialized
         then
            ConstraintID_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_ConstraintID :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.TC_Long);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ConstraintID);
            CORBA.TypeCode.Internals.Freeze
              (TC_ConstraintID);
         end if;
      end Initialize_ConstraintID;

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

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

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

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

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

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

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

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_ConstraintExp)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotifyFilter.ConstraintExp,
               Ptr_Ü_ConstraintExp);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      ConstraintExp_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_ConstraintExp --
      ------------------------------

      procedure Initialize_ConstraintExp is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ConstraintExp");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/ConstraintExp:1.0");
         Argument_Name_Ü_event_types : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("event_types");
         Argument_Name_Ü_constraint_expr : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("constraint_expr");
      begin
         if not ConstraintExp_Initialized
         then
            ConstraintExp_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_ConstraintExp :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_ConstraintExp,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ConstraintExp,
               CORBA.To_Any
                 (Id_Ü));
            CosNotification.Helper.Internals.Initialize_EventTypeSeq;
            CORBA.Internals.Add_Parameter
              (TC_ConstraintExp,
               CORBA.To_Any
                 (CosNotification.Helper.TC_EventTypeSeq));
            CORBA.Internals.Add_Parameter
              (TC_ConstraintExp,
               CORBA.To_Any
                 (Argument_Name_Ü_event_types));
            CORBA.Internals.Add_Parameter
              (TC_ConstraintExp,
               CORBA.To_Any
                 (CORBA.TC_String));
            CORBA.Internals.Add_Parameter
              (TC_ConstraintExp,
               CORBA.To_Any
                 (Argument_Name_Ü_constraint_expr));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ConstraintExp);
            CORBA.TypeCode.Internals.Freeze
              (TC_ConstraintExp);
         end if;
      end Initialize_ConstraintExp;

      ------------------------------------------------------------
      -- IDL_SEQUENCE_CosNotifyFilter_ConstraintID_Element_Wrap --
      ------------------------------------------------------------

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

      function Wrap
        (X : access CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintID.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotifyFilter_ConstraintID_Helper.Wrap;

      IDL_SEQUENCE_CosNotifyFilter_ConstraintID_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintID --
      ----------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintID is
      begin
         if not IDL_SEQUENCE_CosNotifyFilter_ConstraintID_Initialized
         then
            IDL_SEQUENCE_CosNotifyFilter_ConstraintID_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_ConstraintID;
            CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintID :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotifyFilter.Helper.TC_ConstraintID,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintID);
            IDL_SEQUENCE_CosNotifyFilter_ConstraintID_Helper.Initialize
              (Element_TC => CosNotifyFilter.Helper.TC_ConstraintID,
               Sequence_TC => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintID);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintID);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintID;

      ConstraintIDSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------
      -- Initialize_ConstraintIDSeq --
      --------------------------------

      procedure Initialize_ConstraintIDSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ConstraintIDSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/ConstraintIDSeq:1.0");
      begin
         if not ConstraintIDSeq_Initialized
         then
            ConstraintIDSeq_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintID;
            CosNotifyFilter.Helper.TC_ConstraintIDSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintID);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ConstraintIDSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ConstraintIDSeq);
         end if;
      end Initialize_ConstraintIDSeq;

      -------------------------------------------------------------
      -- IDL_SEQUENCE_CosNotifyFilter_ConstraintExp_Element_Wrap --
      -------------------------------------------------------------

      function IDL_SEQUENCE_CosNotifyFilter_ConstraintExp_Element_Wrap
        (X : access CosNotifyFilter.ConstraintExp)
        return PolyORB.Any.Content'Class
      is
      begin
         return CosNotifyFilter.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CosNotifyFilter_ConstraintExp_Element_Wrap;

      function Wrap
        (X : access CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintExp.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotifyFilter_ConstraintExp_Helper.Wrap;

      IDL_SEQUENCE_CosNotifyFilter_ConstraintExp_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintExp --
      -----------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintExp is
      begin
         if not IDL_SEQUENCE_CosNotifyFilter_ConstraintExp_Initialized
         then
            IDL_SEQUENCE_CosNotifyFilter_ConstraintExp_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_ConstraintExp;
            CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintExp :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotifyFilter.Helper.TC_ConstraintExp,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintExp);
            IDL_SEQUENCE_CosNotifyFilter_ConstraintExp_Helper.Initialize
              (Element_TC => CosNotifyFilter.Helper.TC_ConstraintExp,
               Sequence_TC => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintExp);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintExp);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintExp;

      ConstraintExpSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------------
      -- Initialize_ConstraintExpSeq --
      ---------------------------------

      procedure Initialize_ConstraintExpSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ConstraintExpSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/ConstraintExpSeq:1.0");
      begin
         if not ConstraintExpSeq_Initialized
         then
            ConstraintExpSeq_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintExp;
            CosNotifyFilter.Helper.TC_ConstraintExpSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintExp);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ConstraintExpSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ConstraintExpSeq);
         end if;
      end Initialize_ConstraintExpSeq;

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

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

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

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

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

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

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

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_ConstraintInfo)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotifyFilter.ConstraintInfo,
               Ptr_Ü_ConstraintInfo);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      ConstraintInfo_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------
      -- Initialize_ConstraintInfo --
      -------------------------------

      procedure Initialize_ConstraintInfo is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ConstraintInfo");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/ConstraintInfo:1.0");
         Argument_Name_Ü_constraint_expression : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("constraint_expression");
         Argument_Name_Ü_constraint_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("constraint_id");
      begin
         if not ConstraintInfo_Initialized
         then
            ConstraintInfo_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_ConstraintInfo :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_ConstraintInfo,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ConstraintInfo,
               CORBA.To_Any
                 (Id_Ü));
            CosNotifyFilter.Helper.Internals.Initialize_ConstraintExp;
            CORBA.Internals.Add_Parameter
              (TC_ConstraintInfo,
               CORBA.To_Any
                 (CosNotifyFilter.Helper.TC_ConstraintExp));
            CORBA.Internals.Add_Parameter
              (TC_ConstraintInfo,
               CORBA.To_Any
                 (Argument_Name_Ü_constraint_expression));
            CosNotifyFilter.Helper.Internals.Initialize_ConstraintID;
            CORBA.Internals.Add_Parameter
              (TC_ConstraintInfo,
               CORBA.To_Any
                 (CosNotifyFilter.Helper.TC_ConstraintID));
            CORBA.Internals.Add_Parameter
              (TC_ConstraintInfo,
               CORBA.To_Any
                 (Argument_Name_Ü_constraint_id));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ConstraintInfo);
            CORBA.TypeCode.Internals.Freeze
              (TC_ConstraintInfo);
         end if;
      end Initialize_ConstraintInfo;

      --------------------------------------------------------------
      -- IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo_Element_Wrap --
      --------------------------------------------------------------

      function IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo_Element_Wrap
        (X : access CosNotifyFilter.ConstraintInfo)
        return PolyORB.Any.Content'Class
      is
      begin
         return CosNotifyFilter.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo_Element_Wrap;

      function Wrap
        (X : access CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo_Helper.Wrap;

      IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo --
      ------------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo is
      begin
         if not IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo_Initialized
         then
            IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_ConstraintInfo;
            CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotifyFilter.Helper.TC_ConstraintInfo,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo);
            IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo_Helper.Initialize
              (Element_TC => CosNotifyFilter.Helper.TC_ConstraintInfo,
               Sequence_TC => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo;

      ConstraintInfoSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------
      -- Initialize_ConstraintInfoSeq --
      ----------------------------------

      procedure Initialize_ConstraintInfoSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ConstraintInfoSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/ConstraintInfoSeq:1.0");
      begin
         if not ConstraintInfoSeq_Initialized
         then
            ConstraintInfoSeq_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo;
            CosNotifyFilter.Helper.TC_ConstraintInfoSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ConstraintInfoSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ConstraintInfoSeq);
         end if;
      end Initialize_ConstraintInfoSeq;

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

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

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

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

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

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

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

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_MappingConstraintPair)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotifyFilter.MappingConstraintPair,
               Ptr_Ü_MappingConstraintPair);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      MappingConstraintPair_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------
      -- Initialize_MappingConstraintPair --
      --------------------------------------

      procedure Initialize_MappingConstraintPair is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("MappingConstraintPair");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/MappingConstraintPair:1.0");
         Argument_Name_Ü_constraint_expression : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("constraint_expression");
         Argument_Name_Ü_result_to_set : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("result_to_set");
      begin
         if not MappingConstraintPair_Initialized
         then
            MappingConstraintPair_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_MappingConstraintPair :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintPair,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintPair,
               CORBA.To_Any
                 (Id_Ü));
            CosNotifyFilter.Helper.Internals.Initialize_ConstraintExp;
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintPair,
               CORBA.To_Any
                 (CosNotifyFilter.Helper.TC_ConstraintExp));
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintPair,
               CORBA.To_Any
                 (Argument_Name_Ü_constraint_expression));
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintPair,
               CORBA.To_Any
                 (CORBA.TC_Any));
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintPair,
               CORBA.To_Any
                 (Argument_Name_Ü_result_to_set));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_MappingConstraintPair);
            CORBA.TypeCode.Internals.Freeze
              (TC_MappingConstraintPair);
         end if;
      end Initialize_MappingConstraintPair;

      ---------------------------------------------------------------------
      -- IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair_Element_Wrap --
      ---------------------------------------------------------------------

      function IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair_Element_Wrap
        (X : access CosNotifyFilter.MappingConstraintPair)
        return PolyORB.Any.Content'Class
      is
      begin
         return CosNotifyFilter.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair_Element_Wrap;

      function Wrap
        (X : access CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair_Helper.Wrap;

      IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair --
      -------------------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair is
      begin
         if not IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair_Initialized
         then
            IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_MappingConstraintPair;
            CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotifyFilter.Helper.TC_MappingConstraintPair,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair);
            IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair_Helper.Initialize
              (Element_TC => CosNotifyFilter.Helper.TC_MappingConstraintPair,
               Sequence_TC => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair;

      MappingConstraintPairSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------
      -- Initialize_MappingConstraintPairSeq --
      -----------------------------------------

      procedure Initialize_MappingConstraintPairSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("MappingConstraintPairSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/MappingConstraintPairSeq:1.0");
      begin
         if not MappingConstraintPairSeq_Initialized
         then
            MappingConstraintPairSeq_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair;
            CosNotifyFilter.Helper.TC_MappingConstraintPairSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_MappingConstraintPairSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_MappingConstraintPairSeq);
         end if;
      end Initialize_MappingConstraintPairSeq;

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

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

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

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

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

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

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

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

      procedure Finalize_Value
        (Acc : in out Content_Ü_MappingConstraintInfo)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CosNotifyFilter.MappingConstraintInfo,
               Ptr_Ü_MappingConstraintInfo);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

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

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

      MappingConstraintInfo_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------
      -- Initialize_MappingConstraintInfo --
      --------------------------------------

      procedure Initialize_MappingConstraintInfo is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("MappingConstraintInfo");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/MappingConstraintInfo:1.0");
         Argument_Name_Ü_constraint_expression : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("constraint_expression");
         Argument_Name_Ü_constraint_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("constraint_id");
         Argument_Name_Ü_value : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("value");
      begin
         if not MappingConstraintInfo_Initialized
         then
            MappingConstraintInfo_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_MappingConstraintInfo :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintInfo,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintInfo,
               CORBA.To_Any
                 (Id_Ü));
            CosNotifyFilter.Helper.Internals.Initialize_ConstraintExp;
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintInfo,
               CORBA.To_Any
                 (CosNotifyFilter.Helper.TC_ConstraintExp));
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintInfo,
               CORBA.To_Any
                 (Argument_Name_Ü_constraint_expression));
            CosNotifyFilter.Helper.Internals.Initialize_ConstraintID;
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintInfo,
               CORBA.To_Any
                 (CosNotifyFilter.Helper.TC_ConstraintID));
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintInfo,
               CORBA.To_Any
                 (Argument_Name_Ü_constraint_id));
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintInfo,
               CORBA.To_Any
                 (CORBA.TC_Any));
            CORBA.Internals.Add_Parameter
              (TC_MappingConstraintInfo,
               CORBA.To_Any
                 (Argument_Name_Ü_value));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_MappingConstraintInfo);
            CORBA.TypeCode.Internals.Freeze
              (TC_MappingConstraintInfo);
         end if;
      end Initialize_MappingConstraintInfo;

      ---------------------------------------------------------------------
      -- IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo_Element_Wrap --
      ---------------------------------------------------------------------

      function IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo_Element_Wrap
        (X : access CosNotifyFilter.MappingConstraintInfo)
        return PolyORB.Any.Content'Class
      is
      begin
         return CosNotifyFilter.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo_Element_Wrap;

      function Wrap
        (X : access CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo_Helper.Wrap;

      IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo --
      -------------------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo is
      begin
         if not IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo_Initialized
         then
            IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_MappingConstraintInfo;
            CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotifyFilter.Helper.TC_MappingConstraintInfo,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo);
            IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo_Helper.Initialize
              (Element_TC => CosNotifyFilter.Helper.TC_MappingConstraintInfo,
               Sequence_TC => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo;

      MappingConstraintInfoSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------
      -- Initialize_MappingConstraintInfoSeq --
      -----------------------------------------

      procedure Initialize_MappingConstraintInfoSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("MappingConstraintInfoSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/MappingConstraintInfoSeq:1.0");
      begin
         if not MappingConstraintInfoSeq_Initialized
         then
            MappingConstraintInfoSeq_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo;
            CosNotifyFilter.Helper.TC_MappingConstraintInfoSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_MappingConstraintInfoSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_MappingConstraintInfoSeq);
         end if;
      end Initialize_MappingConstraintInfoSeq;

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

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

      CallbackID_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------
      -- Initialize_CallbackID --
      ---------------------------

      procedure Initialize_CallbackID is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("CallbackID");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/CallbackID:1.0");
      begin
         if not CallbackID_Initialized
         then
            CallbackID_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_CallbackID :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.TC_Long);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_CallbackID);
            CORBA.TypeCode.Internals.Freeze
              (TC_CallbackID);
         end if;
      end Initialize_CallbackID;

      ----------------------------------------------------------
      -- IDL_SEQUENCE_CosNotifyFilter_CallbackID_Element_Wrap --
      ----------------------------------------------------------

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

      function Wrap
        (X : access CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_CallbackID.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotifyFilter_CallbackID_Helper.Wrap;

      IDL_SEQUENCE_CosNotifyFilter_CallbackID_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotifyFilter_CallbackID --
      --------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotifyFilter_CallbackID is
      begin
         if not IDL_SEQUENCE_CosNotifyFilter_CallbackID_Initialized
         then
            IDL_SEQUENCE_CosNotifyFilter_CallbackID_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_CallbackID;
            CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_CallbackID :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotifyFilter.Helper.TC_CallbackID,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_CallbackID);
            IDL_SEQUENCE_CosNotifyFilter_CallbackID_Helper.Initialize
              (Element_TC => CosNotifyFilter.Helper.TC_CallbackID,
               Sequence_TC => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_CallbackID);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotifyFilter_CallbackID);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotifyFilter_CallbackID;

      CallbackIDSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_CallbackIDSeq --
      ------------------------------

      procedure Initialize_CallbackIDSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("CallbackIDSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/CallbackIDSeq:1.0");
      begin
         if not CallbackIDSeq_Initialized
         then
            CallbackIDSeq_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_CallbackID;
            CosNotifyFilter.Helper.TC_CallbackIDSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_CallbackID);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_CallbackIDSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_CallbackIDSeq);
         end if;
      end Initialize_CallbackIDSeq;

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

      pragma No_Return (Raise_UnsupportedFilterableData_From_Any);

      ----------------------------------------------
      -- Raise_UnsupportedFilterableData_From_Any --
      ----------------------------------------------

      procedure Raise_UnsupportedFilterableData_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyFilter.UnsupportedFilterableData_Members :=
           CosNotifyFilter.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (UnsupportedFilterableData'Identity,
            Members,
            Message);
      end Raise_UnsupportedFilterableData_From_Any;

      UnsupportedFilterableData_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------------------
      -- Initialize_UnsupportedFilterableData --
      ------------------------------------------

      procedure Initialize_UnsupportedFilterableData is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("UnsupportedFilterableData_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/UnsupportedFilterableData:1.0");
      begin
         if not UnsupportedFilterableData_Initialized
         then
            UnsupportedFilterableData_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_UnsupportedFilterableData :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_UnsupportedFilterableData,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_UnsupportedFilterableData,
               CORBA.To_Any
                 (Id_Ü));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_UnsupportedFilterableData),
               Raise_UnsupportedFilterableData_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_UnsupportedFilterableData);
            CORBA.TypeCode.Internals.Freeze
              (TC_UnsupportedFilterableData);
         end if;
      end Initialize_UnsupportedFilterableData;

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

      pragma No_Return (Raise_InvalidGrammar_From_Any);

      -----------------------------------
      -- Raise_InvalidGrammar_From_Any --
      -----------------------------------

      procedure Raise_InvalidGrammar_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyFilter.InvalidGrammar_Members :=
           CosNotifyFilter.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (InvalidGrammar'Identity,
            Members,
            Message);
      end Raise_InvalidGrammar_From_Any;

      InvalidGrammar_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------
      -- Initialize_InvalidGrammar --
      -------------------------------

      procedure Initialize_InvalidGrammar is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("InvalidGrammar_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/InvalidGrammar:1.0");
      begin
         if not InvalidGrammar_Initialized
         then
            InvalidGrammar_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_InvalidGrammar :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_InvalidGrammar,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_InvalidGrammar,
               CORBA.To_Any
                 (Id_Ü));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_InvalidGrammar),
               Raise_InvalidGrammar_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_InvalidGrammar);
            CORBA.TypeCode.Internals.Freeze
              (TC_InvalidGrammar);
         end if;
      end Initialize_InvalidGrammar;

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

      pragma No_Return (Raise_InvalidConstraint_From_Any);

      --------------------------------------
      -- Raise_InvalidConstraint_From_Any --
      --------------------------------------

      procedure Raise_InvalidConstraint_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyFilter.InvalidConstraint_Members :=
           CosNotifyFilter.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (InvalidConstraint'Identity,
            Members,
            Message);
      end Raise_InvalidConstraint_From_Any;

      InvalidConstraint_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------
      -- Initialize_InvalidConstraint --
      ----------------------------------

      procedure Initialize_InvalidConstraint is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("InvalidConstraint_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/InvalidConstraint:1.0");
         Arg_Name_constr : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("constr");
      begin
         if not InvalidConstraint_Initialized
         then
            InvalidConstraint_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_InvalidConstraint :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_InvalidConstraint,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_InvalidConstraint,
               CORBA.To_Any
                 (Id_Ü));
            CosNotifyFilter.Helper.Internals.Initialize_ConstraintExp;
            CORBA.Internals.Add_Parameter
              (TC_InvalidConstraint,
               CORBA.To_Any
                 (CosNotifyFilter.Helper.TC_ConstraintExp));
            CORBA.Internals.Add_Parameter
              (TC_InvalidConstraint,
               CORBA.To_Any
                 (Arg_Name_constr));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_InvalidConstraint),
               Raise_InvalidConstraint_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_InvalidConstraint);
            CORBA.TypeCode.Internals.Freeze
              (TC_InvalidConstraint);
         end if;
      end Initialize_InvalidConstraint;

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

      pragma No_Return (Raise_DuplicateConstraintID_From_Any);

      ------------------------------------------
      -- Raise_DuplicateConstraintID_From_Any --
      ------------------------------------------

      procedure Raise_DuplicateConstraintID_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyFilter.DuplicateConstraintID_Members :=
           CosNotifyFilter.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (DuplicateConstraintID'Identity,
            Members,
            Message);
      end Raise_DuplicateConstraintID_From_Any;

      DuplicateConstraintID_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------
      -- Initialize_DuplicateConstraintID --
      --------------------------------------

      procedure Initialize_DuplicateConstraintID is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("DuplicateConstraintID_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/DuplicateConstraintID:1.0");
         Arg_Name_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("id");
      begin
         if not DuplicateConstraintID_Initialized
         then
            DuplicateConstraintID_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_DuplicateConstraintID :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_DuplicateConstraintID,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DuplicateConstraintID,
               CORBA.To_Any
                 (Id_Ü));
            CosNotifyFilter.Helper.Internals.Initialize_ConstraintID;
            CORBA.Internals.Add_Parameter
              (TC_DuplicateConstraintID,
               CORBA.To_Any
                 (CosNotifyFilter.Helper.TC_ConstraintID));
            CORBA.Internals.Add_Parameter
              (TC_DuplicateConstraintID,
               CORBA.To_Any
                 (Arg_Name_id));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_DuplicateConstraintID),
               Raise_DuplicateConstraintID_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_DuplicateConstraintID);
            CORBA.TypeCode.Internals.Freeze
              (TC_DuplicateConstraintID);
         end if;
      end Initialize_DuplicateConstraintID;

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

      pragma No_Return (Raise_ConstraintNotFound_From_Any);

      ---------------------------------------
      -- Raise_ConstraintNotFound_From_Any --
      ---------------------------------------

      procedure Raise_ConstraintNotFound_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyFilter.ConstraintNotFound_Members :=
           CosNotifyFilter.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (ConstraintNotFound'Identity,
            Members,
            Message);
      end Raise_ConstraintNotFound_From_Any;

      ConstraintNotFound_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------
      -- Initialize_ConstraintNotFound --
      -----------------------------------

      procedure Initialize_ConstraintNotFound is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ConstraintNotFound_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/ConstraintNotFound:1.0");
         Arg_Name_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("id");
      begin
         if not ConstraintNotFound_Initialized
         then
            ConstraintNotFound_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_ConstraintNotFound :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_ConstraintNotFound,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ConstraintNotFound,
               CORBA.To_Any
                 (Id_Ü));
            CosNotifyFilter.Helper.Internals.Initialize_ConstraintID;
            CORBA.Internals.Add_Parameter
              (TC_ConstraintNotFound,
               CORBA.To_Any
                 (CosNotifyFilter.Helper.TC_ConstraintID));
            CORBA.Internals.Add_Parameter
              (TC_ConstraintNotFound,
               CORBA.To_Any
                 (Arg_Name_id));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_ConstraintNotFound),
               Raise_ConstraintNotFound_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ConstraintNotFound);
            CORBA.TypeCode.Internals.Freeze
              (TC_ConstraintNotFound);
         end if;
      end Initialize_ConstraintNotFound;

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

      pragma No_Return (Raise_CallbackNotFound_From_Any);

      -------------------------------------
      -- Raise_CallbackNotFound_From_Any --
      -------------------------------------

      procedure Raise_CallbackNotFound_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyFilter.CallbackNotFound_Members :=
           CosNotifyFilter.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (CallbackNotFound'Identity,
            Members,
            Message);
      end Raise_CallbackNotFound_From_Any;

      CallbackNotFound_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------------
      -- Initialize_CallbackNotFound --
      ---------------------------------

      procedure Initialize_CallbackNotFound is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("CallbackNotFound_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/CallbackNotFound:1.0");
      begin
         if not CallbackNotFound_Initialized
         then
            CallbackNotFound_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_CallbackNotFound :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_CallbackNotFound,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_CallbackNotFound,
               CORBA.To_Any
                 (Id_Ü));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_CallbackNotFound),
               Raise_CallbackNotFound_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_CallbackNotFound);
            CORBA.TypeCode.Internals.Freeze
              (TC_CallbackNotFound);
         end if;
      end Initialize_CallbackNotFound;

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

      pragma No_Return (Raise_InvalidValue_From_Any);

      ---------------------------------
      -- Raise_InvalidValue_From_Any --
      ---------------------------------

      procedure Raise_InvalidValue_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyFilter.InvalidValue_Members :=
           CosNotifyFilter.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (InvalidValue'Identity,
            Members,
            Message);
      end Raise_InvalidValue_From_Any;

      InvalidValue_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_InvalidValue --
      -----------------------------

      procedure Initialize_InvalidValue is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("InvalidValue_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/InvalidValue:1.0");
         Arg_Name_constr : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("constr");
         Arg_Name_value : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("value");
      begin
         if not InvalidValue_Initialized
         then
            InvalidValue_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_InvalidValue :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_InvalidValue,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_InvalidValue,
               CORBA.To_Any
                 (Id_Ü));
            CosNotifyFilter.Helper.Internals.Initialize_ConstraintExp;
            CORBA.Internals.Add_Parameter
              (TC_InvalidValue,
               CORBA.To_Any
                 (CosNotifyFilter.Helper.TC_ConstraintExp));
            CORBA.Internals.Add_Parameter
              (TC_InvalidValue,
               CORBA.To_Any
                 (Arg_Name_constr));
            CORBA.Internals.Add_Parameter
              (TC_InvalidValue,
               CORBA.To_Any
                 (CORBA.TC_Any));
            CORBA.Internals.Add_Parameter
              (TC_InvalidValue,
               CORBA.To_Any
                 (Arg_Name_value));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_InvalidValue),
               Raise_InvalidValue_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_InvalidValue);
            CORBA.TypeCode.Internals.Freeze
              (TC_InvalidValue);
         end if;
      end Initialize_InvalidValue;

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

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

      FilterID_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------
      -- Initialize_FilterID --
      -------------------------

      procedure Initialize_FilterID is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("FilterID");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/FilterID:1.0");
      begin
         if not FilterID_Initialized
         then
            FilterID_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_FilterID :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.TC_Long);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_FilterID);
            CORBA.TypeCode.Internals.Freeze
              (TC_FilterID);
         end if;
      end Initialize_FilterID;

      --------------------------------------------------------
      -- IDL_SEQUENCE_CosNotifyFilter_FilterID_Element_Wrap --
      --------------------------------------------------------

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

      function Wrap
        (X : access CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_FilterID.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CosNotifyFilter_FilterID_Helper.Wrap;

      IDL_SEQUENCE_CosNotifyFilter_FilterID_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CosNotifyFilter_FilterID --
      ------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CosNotifyFilter_FilterID is
      begin
         if not IDL_SEQUENCE_CosNotifyFilter_FilterID_Initialized
         then
            IDL_SEQUENCE_CosNotifyFilter_FilterID_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_FilterID;
            CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_FilterID :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CosNotifyFilter.Helper.TC_FilterID,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_FilterID);
            IDL_SEQUENCE_CosNotifyFilter_FilterID_Helper.Initialize
              (Element_TC => CosNotifyFilter.Helper.TC_FilterID,
               Sequence_TC => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_FilterID);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CosNotifyFilter_FilterID);
         end if;
      end Initialize_IDL_SEQUENCE_CosNotifyFilter_FilterID;

      FilterIDSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------
      -- Initialize_FilterIDSeq --
      ----------------------------

      procedure Initialize_FilterIDSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("FilterIDSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/FilterIDSeq:1.0");
      begin
         if not FilterIDSeq_Initialized
         then
            FilterIDSeq_Initialized :=
              True;
            CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_FilterID;
            CosNotifyFilter.Helper.TC_FilterIDSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CosNotifyFilter.Helper.TC_IDL_SEQUENCE_CosNotifyFilter_FilterID);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_FilterIDSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_FilterIDSeq);
         end if;
      end Initialize_FilterIDSeq;

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

      pragma No_Return (Raise_FilterNotFound_From_Any);

      -----------------------------------
      -- Raise_FilterNotFound_From_Any --
      -----------------------------------

      procedure Raise_FilterNotFound_From_Any
        (Item : PolyORB.Any.Any;
         Message : PolyORB.Std.String)
      is
         Members : constant CosNotifyFilter.FilterNotFound_Members :=
           CosNotifyFilter.Helper.From_Any
              (CORBA.Any
                 (Item));
      begin
         PolyORB.Exceptions.User_Raise_Exception
           (FilterNotFound'Identity,
            Members,
            Message);
      end Raise_FilterNotFound_From_Any;

      FilterNotFound_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------
      -- Initialize_FilterNotFound --
      -------------------------------

      procedure Initialize_FilterNotFound is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("FilterNotFound_Members");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CosNotifyFilter/FilterNotFound:1.0");
      begin
         if not FilterNotFound_Initialized
         then
            FilterNotFound_Initialized :=
              True;
            CosNotifyFilter.Helper.TC_FilterNotFound :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Except);
            CORBA.Internals.Add_Parameter
              (TC_FilterNotFound,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_FilterNotFound,
               CORBA.To_Any
                 (Id_Ü));
            PolyORB.Exceptions.Register_Exception
              (CORBA.TypeCode.Internals.To_PolyORB_Object
                 (TC_FilterNotFound),
               Raise_FilterNotFound_From_Any'Access);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_FilterNotFound);
            CORBA.TypeCode.Internals.Freeze
              (TC_FilterNotFound);
         end if;
      end Initialize_FilterNotFound;

   end Internals;

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

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

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

   function To_Any
     (Item : CosNotifyFilter.ConstraintID)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.To_Any
           (CORBA.Long
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ConstraintID);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.ConstraintExp
   is
   begin
      return (event_types => CosNotification.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotification.Helper.TC_EventTypeSeq,
            0)),
      constraint_expr => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_String,
            1)));
   end From_Any;

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

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintID.Sequence
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_ConstraintID_Helper.From_Any;

   function To_Any
     (Item : CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintID.Sequence)
     return CORBA.Any
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_ConstraintID_Helper.To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.ConstraintIDSeq
   is
      Result : constant CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintID.Sequence :=
        CosNotifyFilter.Helper.From_Any
           (Item);
   begin
      return CosNotifyFilter.ConstraintIDSeq
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotifyFilter.ConstraintIDSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotifyFilter.Helper.To_Any
           (CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintID.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ConstraintIDSeq);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintExp.Sequence
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_ConstraintExp_Helper.From_Any;

   function To_Any
     (Item : CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintExp.Sequence)
     return CORBA.Any
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_ConstraintExp_Helper.To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.ConstraintExpSeq
   is
      Result : constant CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintExp.Sequence :=
        CosNotifyFilter.Helper.From_Any
           (Item);
   begin
      return CosNotifyFilter.ConstraintExpSeq
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotifyFilter.ConstraintExpSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotifyFilter.Helper.To_Any
           (CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintExp.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ConstraintExpSeq);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.ConstraintInfo
   is
   begin
      return (constraint_expression => CosNotifyFilter.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotifyFilter.Helper.TC_ConstraintExp,
            0)),
      constraint_id => CosNotifyFilter.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotifyFilter.Helper.TC_ConstraintID,
            1)));
   end From_Any;

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

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo.Sequence
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo_Helper.From_Any;

   function To_Any
     (Item : CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo.Sequence)
     return CORBA.Any
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo_Helper.To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.ConstraintInfoSeq
   is
      Result : constant CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo.Sequence :=
        CosNotifyFilter.Helper.From_Any
           (Item);
   begin
      return CosNotifyFilter.ConstraintInfoSeq
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotifyFilter.ConstraintInfoSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotifyFilter.Helper.To_Any
           (CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ConstraintInfoSeq);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.MappingConstraintPair
   is
   begin
      return (constraint_expression => CosNotifyFilter.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotifyFilter.Helper.TC_ConstraintExp,
            0)),
      result_to_set => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_Any,
            1)));
   end From_Any;

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

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair.Sequence
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair_Helper.From_Any;

   function To_Any
     (Item : CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair.Sequence)
     return CORBA.Any
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair_Helper.To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.MappingConstraintPairSeq
   is
      Result : constant CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair.Sequence :=
        CosNotifyFilter.Helper.From_Any
           (Item);
   begin
      return CosNotifyFilter.MappingConstraintPairSeq
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotifyFilter.MappingConstraintPairSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotifyFilter.Helper.To_Any
           (CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_MappingConstraintPairSeq);
      return Result;
   end To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.MappingConstraintInfo
   is
   begin
      return (constraint_expression => CosNotifyFilter.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotifyFilter.Helper.TC_ConstraintExp,
            0)),
      constraint_id => CosNotifyFilter.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotifyFilter.Helper.TC_ConstraintID,
            1)),
      value => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_Any,
            2)));
   end From_Any;

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

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo.Sequence
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo_Helper.From_Any;

   function To_Any
     (Item : CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo.Sequence)
     return CORBA.Any
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo_Helper.To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.MappingConstraintInfoSeq
   is
      Result : constant CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo.Sequence :=
        CosNotifyFilter.Helper.From_Any
           (Item);
   begin
      return CosNotifyFilter.MappingConstraintInfoSeq
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotifyFilter.MappingConstraintInfoSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotifyFilter.Helper.To_Any
           (CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_MappingConstraintInfoSeq);
      return Result;
   end To_Any;

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

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

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

   function To_Any
     (Item : CosNotifyFilter.CallbackID)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.To_Any
           (CORBA.Long
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_CallbackID);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_CallbackID.Sequence
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_CallbackID_Helper.From_Any;

   function To_Any
     (Item : CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_CallbackID.Sequence)
     return CORBA.Any
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_CallbackID_Helper.To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.CallbackIDSeq
   is
      Result : constant CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_CallbackID.Sequence :=
        CosNotifyFilter.Helper.From_Any
           (Item);
   begin
      return CosNotifyFilter.CallbackIDSeq
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotifyFilter.CallbackIDSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotifyFilter.Helper.To_Any
           (CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_CallbackID.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_CallbackIDSeq);
      return Result;
   end To_Any;

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

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

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

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

   -------------------------------------
   -- Raise_UnsupportedFilterableData --
   -------------------------------------

   procedure Raise_UnsupportedFilterableData
     (Members : CosNotifyFilter.UnsupportedFilterableData_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (UnsupportedFilterableData'Identity,
         Members);
   end Raise_UnsupportedFilterableData;

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

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

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

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

   --------------------------
   -- Raise_InvalidGrammar --
   --------------------------

   procedure Raise_InvalidGrammar
     (Members : CosNotifyFilter.InvalidGrammar_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (InvalidGrammar'Identity,
         Members);
   end Raise_InvalidGrammar;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.InvalidConstraint_Members
   is
   begin
      return (constr => CosNotifyFilter.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotifyFilter.Helper.TC_ConstraintExp,
            0)));
   end From_Any;

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

   function To_Any
     (Item : CosNotifyFilter.InvalidConstraint_Members)
     return CORBA.Any
   is
      Result_Ü : CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotifyFilter.Helper.TC_InvalidConstraint);
   begin
      CORBA.Internals.Add_Aggregate_Element
        (Result_Ü,
         CosNotifyFilter.Helper.To_Any
           (Item.constr));
      return Result_Ü;
   end To_Any;

   -----------------------------
   -- Raise_InvalidConstraint --
   -----------------------------

   procedure Raise_InvalidConstraint
     (Members : CosNotifyFilter.InvalidConstraint_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (InvalidConstraint'Identity,
         Members);
   end Raise_InvalidConstraint;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.DuplicateConstraintID_Members
   is
   begin
      return (id => CosNotifyFilter.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotifyFilter.Helper.TC_ConstraintID,
            0)));
   end From_Any;

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

   function To_Any
     (Item : CosNotifyFilter.DuplicateConstraintID_Members)
     return CORBA.Any
   is
      Result_Ü : CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotifyFilter.Helper.TC_DuplicateConstraintID);
   begin
      CORBA.Internals.Add_Aggregate_Element
        (Result_Ü,
         CosNotifyFilter.Helper.To_Any
           (Item.id));
      return Result_Ü;
   end To_Any;

   ---------------------------------
   -- Raise_DuplicateConstraintID --
   ---------------------------------

   procedure Raise_DuplicateConstraintID
     (Members : CosNotifyFilter.DuplicateConstraintID_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (DuplicateConstraintID'Identity,
         Members);
   end Raise_DuplicateConstraintID;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.ConstraintNotFound_Members
   is
   begin
      return (id => CosNotifyFilter.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotifyFilter.Helper.TC_ConstraintID,
            0)));
   end From_Any;

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

   function To_Any
     (Item : CosNotifyFilter.ConstraintNotFound_Members)
     return CORBA.Any
   is
      Result_Ü : CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotifyFilter.Helper.TC_ConstraintNotFound);
   begin
      CORBA.Internals.Add_Aggregate_Element
        (Result_Ü,
         CosNotifyFilter.Helper.To_Any
           (Item.id));
      return Result_Ü;
   end To_Any;

   ------------------------------
   -- Raise_ConstraintNotFound --
   ------------------------------

   procedure Raise_ConstraintNotFound
     (Members : CosNotifyFilter.ConstraintNotFound_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (ConstraintNotFound'Identity,
         Members);
   end Raise_ConstraintNotFound;

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

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

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

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

   ----------------------------
   -- Raise_CallbackNotFound --
   ----------------------------

   procedure Raise_CallbackNotFound
     (Members : CosNotifyFilter.CallbackNotFound_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (CallbackNotFound'Identity,
         Members);
   end Raise_CallbackNotFound;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.InvalidValue_Members
   is
   begin
      return (constr => CosNotifyFilter.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CosNotifyFilter.Helper.TC_ConstraintExp,
            0)),
      value => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_Any,
            1)));
   end From_Any;

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

   function To_Any
     (Item : CosNotifyFilter.InvalidValue_Members)
     return CORBA.Any
   is
      Result_Ü : CORBA.Any :=
        CORBA.Internals.Get_Empty_Any_Aggregate
           (CosNotifyFilter.Helper.TC_InvalidValue);
   begin
      CORBA.Internals.Add_Aggregate_Element
        (Result_Ü,
         CosNotifyFilter.Helper.To_Any
           (Item.constr));
      CORBA.Internals.Add_Aggregate_Element
        (Result_Ü,
         CORBA.To_Any
           (Item.value));
      return Result_Ü;
   end To_Any;

   ------------------------
   -- Raise_InvalidValue --
   ------------------------

   procedure Raise_InvalidValue
     (Members : CosNotifyFilter.InvalidValue_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (InvalidValue'Identity,
         Members);
   end Raise_InvalidValue;

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

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

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

   function To_Any
     (Item : CosNotifyFilter.FilterID)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.To_Any
           (CORBA.Long
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_FilterID);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_FilterID.Sequence
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_FilterID_Helper.From_Any;

   function To_Any
     (Item : CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_FilterID.Sequence)
     return CORBA.Any
     renames CosNotifyFilter.Helper.Internals.IDL_SEQUENCE_CosNotifyFilter_FilterID_Helper.To_Any;

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

   function From_Any
     (Item : CORBA.Any)
     return CosNotifyFilter.FilterIDSeq
   is
      Result : constant CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_FilterID.Sequence :=
        CosNotifyFilter.Helper.From_Any
           (Item);
   begin
      return CosNotifyFilter.FilterIDSeq
        (Result);
   end From_Any;

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

   function To_Any
     (Item : CosNotifyFilter.FilterIDSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CosNotifyFilter.Helper.To_Any
           (CosNotifyFilter.IDL_SEQUENCE_CosNotifyFilter_FilterID.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_FilterIDSeq);
      return Result;
   end To_Any;

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

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

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

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

   --------------------------
   -- Raise_FilterNotFound --
   --------------------------

   procedure Raise_FilterNotFound
     (Members : CosNotifyFilter.FilterNotFound_Members)
   is
   begin
      PolyORB.Exceptions.User_Raise_Exception
        (FilterNotFound'Identity,
         Members);
   end Raise_FilterNotFound;

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

   procedure Deferred_Initialization is
   begin
      CosNotifyFilter.Helper.Internals.Initialize_ConstraintID;
      CosNotifyFilter.Helper.Internals.Initialize_ConstraintExp;
      CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintID;
      CosNotifyFilter.Helper.Internals.Initialize_ConstraintIDSeq;
      CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintExp;
      CosNotifyFilter.Helper.Internals.Initialize_ConstraintExpSeq;
      CosNotifyFilter.Helper.Internals.Initialize_ConstraintInfo;
      CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_ConstraintInfo;
      CosNotifyFilter.Helper.Internals.Initialize_ConstraintInfoSeq;
      CosNotifyFilter.Helper.Internals.Initialize_MappingConstraintPair;
      CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintPair;
      CosNotifyFilter.Helper.Internals.Initialize_MappingConstraintPairSeq;
      CosNotifyFilter.Helper.Internals.Initialize_MappingConstraintInfo;
      CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_MappingConstraintInfo;
      CosNotifyFilter.Helper.Internals.Initialize_MappingConstraintInfoSeq;
      CosNotifyFilter.Helper.Internals.Initialize_CallbackID;
      CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_CallbackID;
      CosNotifyFilter.Helper.Internals.Initialize_CallbackIDSeq;
      CosNotifyFilter.Helper.Internals.Initialize_UnsupportedFilterableData;
      CosNotifyFilter.Helper.Internals.Initialize_InvalidGrammar;
      CosNotifyFilter.Helper.Internals.Initialize_InvalidConstraint;
      CosNotifyFilter.Helper.Internals.Initialize_DuplicateConstraintID;
      CosNotifyFilter.Helper.Internals.Initialize_ConstraintNotFound;
      CosNotifyFilter.Helper.Internals.Initialize_CallbackNotFound;
      CosNotifyFilter.Helper.Internals.Initialize_InvalidValue;
      CosNotifyFilter.Helper.Internals.Initialize_FilterID;
      CosNotifyFilter.Helper.Internals.Initialize_IDL_SEQUENCE_CosNotifyFilter_FilterID;
      CosNotifyFilter.Helper.Internals.Initialize_FilterIDSeq;
      CosNotifyFilter.Helper.Internals.Initialize_FilterNotFound;
   end Deferred_Initialization;

begin
   declare
      use PolyORB.Utils.Strings;
      use PolyORB.Utils.Strings.Lists;
   begin
      PolyORB.Initialization.Register_Module
        (PolyORB.Initialization.Module_Info'
           (Name => +"CosNotifyFilter.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 CosNotifyFilter.Helper;
