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/time/CosTime.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.Any.NVList;
with PolyORB.Any;
with PolyORB.Requests;
with PolyORB.Types;
with TimeBase.Helper;
with PolyORB.CORBA_P.Interceptors_Hooks;
with PolyORB.CORBA_P.Exceptions;
with CORBA.Object.Helper;
with CosTime.UTO.Helper;
with CosTime.Helper;
with CosTime.TIO.Helper;

package body CosTime.UTO is

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

   -----------------------
   -- get_time_Result_Ü --
   -----------------------

   function get_time_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_time_Result_Ü);
   begin
      return (Name => get_time_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (TimeBase.Helper.TC_TimeT),
      Arg_Modes => 0);
   end get_time_Result_Ü;

   --------------
   -- get_time --
   --------------

   function get_time
     (Self : Ref)
     return TimeBase.TimeT
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : TimeBase.TimeT;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Unsigned_Long_Long
              (Result_Ü)'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_time_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "_get_time",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end get_time;

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

   -----------------------------
   -- get_inaccuracy_Result_Ü --
   -----------------------------

   function get_inaccuracy_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_inaccuracy_Result_Ü);
   begin
      return (Name => get_inaccuracy_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (TimeBase.Helper.TC_InaccuracyT),
      Arg_Modes => 0);
   end get_inaccuracy_Result_Ü;

   --------------------
   -- get_inaccuracy --
   --------------------

   function get_inaccuracy
     (Self : Ref)
     return TimeBase.InaccuracyT
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : TimeBase.InaccuracyT;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Unsigned_Long_Long
              (Result_Ü)'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_inaccuracy_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "_get_inaccuracy",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end get_inaccuracy;

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

   ----------------------
   -- get_tdf_Result_Ü --
   ----------------------

   function get_tdf_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_tdf_Result_Ü);
   begin
      return (Name => get_tdf_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (TimeBase.Helper.TC_TdfT),
      Arg_Modes => 0);
   end get_tdf_Result_Ü;

   -------------
   -- get_tdf --
   -------------

   function get_tdf
     (Self : Ref)
     return TimeBase.TdfT
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : TimeBase.TdfT;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.Short
              (Result_Ü)'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_tdf_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "_get_tdf",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end get_tdf;

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

   ---------------------------
   -- get_utc_time_Result_Ü --
   ---------------------------

   function get_utc_time_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_utc_time_Result_Ü);
   begin
      return (Name => get_utc_time_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (TimeBase.Helper.TC_UtcT),
      Arg_Modes => 0);
   end get_utc_time_Result_Ü;

   ------------------
   -- get_utc_time --
   ------------------

   function get_utc_time
     (Self : Ref)
     return TimeBase.UtcT
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : TimeBase.UtcT;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        TimeBase.Helper.Internals.Wrap
           (Result_Ü'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_utc_time_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "_get_utc_time",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end get_utc_time;

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

   ----------------------------
   -- absolute_time_Result_Ü --
   ----------------------------

   function absolute_time_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (absolute_time_Result_Ü);
   begin
      return (Name => absolute_time_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosTime.UTO.Helper.TC_UTO),
      Arg_Modes => 0);
   end absolute_time_Result_Ü;

   -------------------
   -- absolute_time --
   -------------------

   function absolute_time
     (Self : Ref)
     return CosTime.UTO.Ref'Class
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosTime.UTO.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        absolute_time_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "absolute_time",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end absolute_time;

   compare_time_Arg_Name_comparison_type_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("comparison_type");

   compare_time_Arg_Name_uto_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("uto");

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

   ---------------------------
   -- compare_time_Result_Ü --
   ---------------------------

   function compare_time_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (compare_time_Result_Ü);
   begin
      return (Name => compare_time_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosTime.Helper.TC_TimeComparison),
      Arg_Modes => 0);
   end compare_time_Result_Ü;

   ------------------
   -- compare_time --
   ------------------

   function compare_time
     (Self : Ref;
      comparison_type : CosTime.ComparisonType;
      uto : CosTime.UTO.Ref'Class)
     return CosTime.TimeComparison
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosTime.TimeComparison;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CosTime.Helper.Internals.Wrap
           (Result_Ü'Unrestricted_Access);
      Arg_CC_comparison_type_Ü : aliased PolyORB.Any.Content'Class :=
        CosTime.Helper.Internals.Wrap
           (comparison_type'Unrestricted_Access);
      Arg_Any_comparison_type_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosTime.Helper.TC_ComparisonType,
            Arg_CC_comparison_type_Ü'Unchecked_Access);
      Arg_CC_uto_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (uto)'Unrestricted_Access);
      Arg_Any_uto_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosTime.UTO.Helper.TC_UTO,
            Arg_CC_uto_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        compare_time_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         compare_time_Arg_Name_comparison_type_Ü,
         PolyORB.Any.Any
           (Arg_Any_comparison_type_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         compare_time_Arg_Name_uto_Ü,
         PolyORB.Any.Any
           (Arg_Any_uto_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "compare_time",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end compare_time;

   time_to_interval_Arg_Name_uto_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("uto");

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

   -------------------------------
   -- time_to_interval_Result_Ü --
   -------------------------------

   function time_to_interval_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (time_to_interval_Result_Ü);
   begin
      return (Name => time_to_interval_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosTime.TIO.Helper.TC_TIO),
      Arg_Modes => 0);
   end time_to_interval_Result_Ü;

   ----------------------
   -- time_to_interval --
   ----------------------

   function time_to_interval
     (Self : Ref;
      uto : CosTime.UTO.Ref'Class)
     return CosTime.TIO_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosTime.TIO_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_uto_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (uto)'Unrestricted_Access);
      Arg_Any_uto_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CosTime.UTO.Helper.TC_UTO,
            Arg_CC_uto_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        time_to_interval_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         time_to_interval_Arg_Name_uto_Ü,
         PolyORB.Any.Any
           (Arg_Any_uto_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "time_to_interval",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end time_to_interval;

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

   -----------------------
   -- interval_Result_Ü --
   -----------------------

   function interval_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (interval_Result_Ü);
   begin
      return (Name => interval_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CosTime.TIO.Helper.TC_TIO),
      Arg_Modes => 0);
   end interval_Result_Ü;

   --------------
   -- interval --
   --------------

   function interval
     (Self : Ref)
     return CosTime.TIO_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CosTime.TIO_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        interval_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "interval",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end interval;

   ----------
   -- Is_A --
   ----------

   function Is_A
     (Self : Ref;
      Logical_Type_Id : PolyORB.Std.String)
     return CORBA.Boolean
   is
   begin
      return (False
         or else (Is_A
           (Logical_Type_Id)
            or else CORBA.Object.Is_A
              (CORBA.Object.Ref
                 (Self),
               Logical_Type_Id)));
   end Is_A;

   ----------
   -- Is_A --
   ----------

   function Is_A
     (Logical_Type_Id : PolyORB.Std.String)
     return CORBA.Boolean
   is
   begin
      return ((CORBA.Is_Equivalent
        (Logical_Type_Id,
         CosTime.UTO.Repository_Id)
         or else CORBA.Is_Equivalent
           (Logical_Type_Id,
            "IDL:omg.org/CORBA/Object:1.0"))
         or else False);
   end Is_A;

end CosTime.UTO;
