Skip to content

Calendar#

A delay_statement is used to block further execution until a specified expiration time is reached. The expiration time can be specified either as a particular point in time (in a delay_until_statement), or in seconds from the current time (in a delay_relative_statement). The language-defined package Calendar provides definitions for a type Time and associated operations, including a function Clock that returns the current time.

package Ada.Calendar 
   with Nonblocking, Global => in out synchronized is

   type Time is private;
   subtype Year_Number  is Integer  range 1901 .. 2399;
   subtype Month_Number is Integer  range 1    .. 12;
   subtype Day_Number   is Integer  range 1    .. 31;
   subtype Day_Duration is Duration range 0.0  .. 86_400.0;

   function Clock return Time;

   function Year   (Date: Time) return Year_Number;
   function Month  (Date: Time) return Month_Number;
   function Day    (Date: Time) return Day_Number;
   function Seconds(Date: Time) return Day_Duration;

   procedure Split(Date   : Time;
                   Year   : out Year_Number;
                   Month  : out Month_Number;
                   Day    : out Day_Number;
                   Seconds: out Day_Duration);
   function Time_Of(Year   : Year_Number;
                    Month  : Month_Number;
                    Day    : Day_Number;
                    Seconds: Day_Duration := 0.0)
      return Time;

   function "+"(Left: Time    ; Right: Duration) return Time;
   function "+"(Left: Duration; Right: Time)     return Time;
   function "-"(Left: Time    ; Right: Duration) return Time;
   function "-"(Left: Time    ; Right: Time)     return Duration;

   function "<" (Left, Right: Time) return Boolean;
   function "<="(Left, Right: Time) return Boolean;
   function ">" (Left, Right: Time) return Boolean;
   function ">="(Left, Right: Time) return Boolean;

   Time_Error: exception;
end Ada.Calendar;

Example of a relative delay statement
delay 3.0; -- delay 3.0 seconds
Example of a periodic task
declare
   use Ada.Calendar;
   Next_Time: Time := Clock + Period; -- Period is a global constant of type Duration
begin
   loop -- repeated every Period seconds
      delay until Next_Time;
      ... -- perform some actions
      Next_Time := Next_Time + Period;
   end loop;
end;

Time Zones#

package Ada.Calendar.Time_Zones 
   with Nonblocking, Global => in out synchronized is

   -- Time zone manipulation:
   type Time_Offset is range -28*60 .. 28*60;

   Unknown_Zone_Error: exception;

   function Local_Time_Offset(Date: Time := Clock) return Time_Offset;
   function UTC_Time_Offset  (Date: Time := Clock) return Time_Offset renames Local_Time_Offset;
end Ada.Calendar.Time_Zones;

Arithmetic#

package Ada.Calendar.Arithmetic 
   with Nonblocking, Global => in out synchronized is

   -- Arithmetic on days:
   type Day_Count is range -366*(1 + Year_Number'Last - Year_Number'First) ..
                            366*(1 + Year_Number'Last - Year_Number'First);

   subtype Leap_Seconds_Count is Integer range -2047 .. 2047;

   procedure Difference(Left, Right : Time;
                        Days        : out Day_Count;
                        Seconds     : out Duration;
                        Leap_Seconds: out Leap_Seconds_Count);

   function "+"(Left: Time     ; Right: Day_Count) return Time;
   function "+"(Left: Day_Count; Right: Time)      return Time;
   function "-"(Left: Time     ; Right: Day_Count) return Time;
   function "-"(Left, Right: Time) return Day_Count;
end Ada.Calendar.Arithmetic;

Formatting#

with Ada.Calendar.Time_Zones;

package Ada.Calendar.Formatting 
   with Nonblocking, Global => in out synchronized is

   type Day_Name is (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);

   function Day_of_Week(Date: Time) return Day_Name;

   -- Hours:Minutes:Seconds access:
   subtype Hour_Number     is Natural      range 0   .. 23;
   subtype Second_Number   is Natural      range 0   .. 59;
   subtype Minute_Number   is Natural      range 0   .. 59;
   subtype Second_Duration is Day_Duration range 0.0 .. 1.0;

   function Year  (Date: Time; Time_Zone: Time_Zones.Time_Offset := 0) return Year_Number;
   function Month (Date: Time; Time_Zone: Time_Zones.Time_Offset := 0) return Month_Number;
   function Day   (Date: Time; Time_Zone: Time_Zones.Time_Offset := 0) return Day_Number;
   function Hour  (Date: Time; Time_Zone: Time_Zones.Time_Offset := 0) return Hour_Number;
   function Minute(Date: Time; Time_Zone: Time_Zones.Time_Offset := 0) return Minute_Number;

   function Second    (Date: Time) return Second_Number;
   function Sub_Second(Date: Time) return Second_Duration;

   function Seconds_Of(Hour      : Hour_Number;
                       Minute    : Minute_Number;
                       Second    : Second_Number   := 0;
                       Sub_Second: Second_Duration := 0.0)
      return Day_Duration;
   procedure Split(Seconds   : Day_Duration;
                   Hour      : out Hour_Number;
                   Minute    : out Minute_Number;
                   Second    : out Second_Number;
                   Sub_Second: out Second_Duration);
   function Time_Of(Year       : Year_Number;
                    Month      : Month_Number;
                    Day        : Day_Number;
                    Hour       : Hour_Number;
                    Minute     : Minute_Number;
                    Second     : Second_Number;
                    Sub_Second : Second_Duration        := 0.0;
                    Leap_Second: Boolean                := False;
                    Time_Zone  : Time_Zones.Time_Offset := 0)
      return Time;
   function Time_Of(Year       : Year_Number;
                    Month      : Month_Number;
                    Day        : Day_Number;
                    Seconds    : Day_Duration           := 0.0;
                    Leap_Second: Boolean                := False;
                    Time_Zone  : Time_Zones.Time_Offset := 0)
      return Time;
   procedure Split(Date      : Time;
                   Year      : out Year_Number;
                   Month     : out Month_Number;
                   Day       : out Day_Number;
                   Hour      : out Hour_Number;
                   Minute    : out Minute_Number;
                   Second    : out Second_Number;
                   Sub_Second: out Second_Duration;
                   Time_Zone : Time_Zones.Time_Offset := 0);
   procedure Split(Date       : Time;
                   Year       : out Year_Number;
                   Month      : out Month_Number;
                   Day        : out Day_Number;
                   Hour       : out Hour_Number;
                   Minute     : out Minute_Number;
                   Second     : out Second_Number;
                   Sub_Second : out Second_Duration;
                   Leap_Second: out Boolean;
                   Time_Zone  : Time_Zones.Time_Offset := 0);
   procedure Split(Date       : Time;
                   Year       : out Year_Number;
                   Month      : out Month_Number;
                   Day        : out Day_Number;
                   Seconds    : out Day_Duration;
                   Leap_Second: out Boolean;
                   Time_Zone  : Time_Zones.Time_Offset := 0);

   -- Simple image and value:
   function Image(Date                 : Time;
                  Include_Time_Fraction: Boolean                := False;
                  Time_Zone            : Time_Zones.Time_Offset := 0)
      return String;
   function Local_Image(Date: Time; Include_Time_Fraction: Boolean := False) return String is
      (Image(Date, Include_Time_Fraction, Time_Zones.Local_Time_Offset(Date)));

   function Value(Date: String; Time_Zone: Time_Zones.Time_Offset := 0) return Time;
   function Image(Elapsed_Time: Duration; Include_Time_Fraction: Boolean := False) return String;
   function Value(Elapsed_Time: String) return Duration;
end Ada.Calendar.Formatting;