template<typename date_type> class day_functor;
    template<typename date_type> class month_functor;
    template<typename date_type> class week_functor;
    template<typename date_type> class year_functor;
  }
}

Time adjustment calculations based on machine

  
    template<typename time_type> class c_local_adjustor;
  }
}

Provide workarounds related to the ctime header

}
  
    struct c_time;
  }
}

  
    template<typename value_policies> class constrained_value;
    template<typename rep_type,  min_value,  max_value, 
             typename exception_type> 
      class simple_exception_policy;

    // Represent a min or max violation type. 
    enum violation_enum { min_violation, max_violation };
  }
}

  
    template<typename T, typename calendar, typename duration_type_> class date;
  }
}

  
    template<typename date_type> class day_clock;
  }
}

  

    // An enumeration of weekday names. 
    enum weekdays { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, 
                    Saturday };

    // Simple enum to allow for nice programming with Jan, Feb, etc. 
    enum months_of_year { Jan = =1, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, 
                          Oct, Nov, Dec, NotAMonth, NumMonths };
  }
}

  
    template<typename duration_rep_traits> class date_duration;

    struct duration_traits_adapted;
    struct duration_traits_long;
  }
}

  
    template<typename base_config> class months_duration;
    template<typename duration_config> class weeks_duration;
    template<typename base_config> class years_duration;

    class BOOST_SYMBOL_VISIBLE years_duration;
  }
}

  
    template<typename date_type, typename CharT, 
             typename OutItrT = CharT, CharT> > > 
      class date_facet;
    template<typename date_type, typename CharT, 
             typename InItrT = CharT, CharT> > > 
      class date_input_facet;
  }
}

  
    template<typename charT> class simple_format;

    template<> class simple_format<>;
  }
}

  
    template<typename date_type, typename format_type> class date_formatter;
    template<typename month_type, typename format_type> class month_formatter;
    template<typename ymd_type, typename format_type> class ymd_formatter;
  }
}

  
    template<typename date_type, typename facet_type, typename charT = char> 
      class ostream_date_formatter;
    template<typename facet_type, typename charT = char> 
      class ostream_month_formatter;
    template<typename weekday_type, typename facet_type, 
             typename charT = char> 
      class ostream_weekday_formatter;
    template<typename ymd_type, typename facet_type, typename charT = char> 
      class ostream_ymd_formatter;
  }
}

  
    template<typename date_type, typename CharT, 
             typename OutItrT = CharT, CharT> > > 
      class date_generator_formatter;
  }
}

  
    template<typename date_type, typename charT> class date_generator_parser;
  }
}

Definition and implementation of date algorithm templates

  
    template<typename date_type> class first_kday_after;
    template<typename date_type> class first_kday_before;
    template<typename date_type> class first_kday_of_month;
    template<typename date_type> class last_kday_of_month;
    template<typename date_type> class nth_kday_of_month;
    template<typename date_type> class partial_date;
    template<typename date_type> class year_based_generator;

    // Returns nth arg as string. 1 -> "first", 2 -> "second", max is 5. 
    const char * (int ele);
    template<typename date_type, typename weekday_type> 
       
      (const , const weekday_type &);
    template<typename date_type, typename weekday_type> 
       
      (const , const weekday_type &);
    template<typename date_type, typename weekday_type> 
       (const , const weekday_type &);
    template<typename date_type, typename weekday_type> 
       (const , const weekday_type &);
  }
}

  
    template<typename offset_functor, typename date_type> class date_itr;
    template<typename date_type> class date_itr_base;

    // An iterator over dates with varying resolution (day, week, month, year, etc) 
    enum date_resolutions { day, week, months, year, decade, century, 
                            NumDateResolutions };
  }
}

  
    template<typename Config, typename charT = char, 
             typename OutputIterator = charT> > 
      class all_date_names_put;
    template<typename Config, typename charT = char, 
             typename OutputIterator = charT> > 
      class date_names_put;
  }
}

  
     ();

    // Helper function for parse_date. 
    template<typename month_type> 
      unsigned short (const & s);
    template<typename date_type> 
       (const , int = );

    // Generic function to parse undelimited date (eg: 20020201) 
    template<typename date_type> 
       (const  s);
    template<typename date_type, typename iterator_type> 
       (iterator_type &, iterator_type const &, char);
    template<typename date_type, typename iterator_type> 
       (iterator_type &, iterator_type const &, 
                                 const &);
    template<typename date_type, typename iterator_type> 
       (iterator_type &, iterator_type const &, 
                                 wchar_t);
    template<typename date_type, typename iterator_type> 
       (iterator_type &, iterator_type const &, 
                                 const &);

    // function called by wrapper functions: date_period_from_(w)string() 
    template<typename date_type, typename charT> 
      period< typename  
      (const charT > & s);
  }
}

Contains template class to provide static dst rule calculations

  
    template<typename date_type, typename time_duration_type, 
             typename dst_traits> 
      class dst_calc_engine;
    template<typename date_type_, typename time_duration_type_> 
      class dst_calculator;
    template<typename date_type_, typename time_duration_type_> 
      class null_dst_rules;
    template<typename date_type_, typename time_duration_type_, 
              dst_start_offset_minutes = , 
              dst_length_minutes = > 
      class us_dst_rules;

    enum time_is_dst_result { is_not_in_dst, is_in_dst, ambiguous, 
                              invalid_time_label };
  }
}

  
    template<typename spec> class day_calc_dst_rule;
    template<typename date_type> class dst_day_calc_rule;
  }
}

Function(s) for converting between a FILETIME structure and a time object. This file is only available on systems that have BOOST_HAS_FTIME defined.

  
    template<typename TimeT, typename FileTimeT> 
      TimeT (const FileTimeT &);
  }
}

  
    template<typename charT> 
      short (const charT *const *, const charT *const *, short, 
                       const charT > &);
  }
}

}
  
    template<typename date_type, typename charT> class format_date_parser;
    template<typename int_type, typename charT> 
       (charT > &, 
                                   charT > &, 
                                   parse_match_result< charT > &, 
                                   unsigned int, const charT &);
    template<typename int_type, typename charT> 
       (charT > &, 
                                   charT > &, 
                                   parse_match_result< charT > &, 
                                   unsigned int);
    template<typename int_type, typename charT> 
       (charT > &, 
                                 const charT > &, 
                                 unsigned int);
  }
}

  
    template<typename ymd_type_, typename date_int_type_> 
      class gregorian_calendar_base;
  }
}

  
    template<typename int_type_> class int_adapter;
    template<typename charT, typename traits, typename int_type> 
      charT, traits > & 
      (charT, traits > &, 
                 const int_adapter< );
  }
}

  
    template<typename charT> class iso_extended_format;
    template<typename charT> class iso_format;
    template<typename charT> class iso_format_base;

    template<> class iso_format_base<>;
  }
}

Time adjustment calculations for local times

  
    template<typename time_type, typename dst_rules> 
      class dynamic_local_time_adjustor;
    template<typename time_type,  utc_offset, typename dst_rule> 
      class local_adjustor;
    template<typename time_type, typename dst_rules, 
             typename utc_offset_rules> 
      class static_local_time_adjustor;
    template<typename time_duration_type,  hours,  minutes = > 
      class utc_adjustment;
    void ();
  }
}

  
    template<typename date_type> struct acst_dst_trait;
    template<typename date_type> struct eu_dst_trait;
    template<typename date_type> struct uk_dst_trait;
    template<typename date_type> struct us_dst_trait;
  }
}

This file contains a high resolution time clock implementation.

  
    template<typename time_type> class microsec_clock;
  }
}

  

    // Enum for distinguishing parsing and formatting options. 
    enum month_format_spec { month_as_integer, month_as_short_string, 
                             month_as_long_string };
    enum ymd_order_spec;
  }
}

This file contain the implementation of the period abstraction. This is basically the same idea as a range. Although this class is intended for use in the time library, it is pretty close to general enough for other numeric uses.

  
    template<typename point_rep, typename duration_rep> class period;
  }
}

  
    template<typename CharT, 
             typename OutItrT = CharT, CharT> > > 
      class period_formatter;
  }
}

  
    template<typename date_type, typename CharT> class period_parser;
  }
}

  

    enum special_values { not_a_date_time, neg_infin, pos_infin, 
                          min_date_time, max_date_time, not_special, 
                          NumSpecialValues };
  }
}

  
    template<typename CharT, 
             typename OutItrT = CharT, CharT> > > 
      class special_values_formatter;
  }
}

  
    template<typename date_type, typename charT> class special_values_parser;
  }
}

  
    template<typename InputT, typename OutputT> 
      OutputT > 
      (const InputT > &);
  }
}

  
    template<typename charT> struct parse_match_result;
    template<typename charT> struct string_parse_tree;
    template<typename charT> 
      charT > & 
      (charT > & os, 
                 parse_match_result< charT > & mr);
  }
}

  
    template<typename charT> 
      charT > > 
      (const , bool = true);
    template<typename charT> 
      charT > > 
      (const , bool = true);
  }
}

This file contains the interface for the time associated classes.

  
    template<typename T, typename time_system> class base_time;
  }
}

This file contains the interface for clock devices.

  
    template<typename time_type> class second_clock;
  }
}

This file contains nice definitions for handling the resoluion of various time reprsentations.

  

    // Defines some nice types for handling time level resolutions. 
    enum time_resolutions { sec, tenth, hundreth, hundredth = = hundreth, 
                            milli, ten_thousandth, micro, nano, 
                            NumResolutions };

    // Flags for daylight savings or summer time. 
    enum dst_flags { not_dst, is_dst, calculate };
  }
}

  
    template<typename base_duration,  frac_of_second> class subsecond_duration;
    template<typename T, typename rep_type> class time_duration;
  }
}

  
    template<typename time_type, typename CharT, 
             typename OutItrT = CharT, CharT> > > 
      class time_facet;

    template<typename CharT> struct time_formats;

    template<typename time_type, typename CharT, 
             typename InItrT = CharT, CharT> > > 
      class time_input_facet;
  }
}

  
    template<typename time_duration_type, typename charT = char> 
      class ostream_time_duration_formatter;
    template<typename time_type, typename charT = char> 
      class ostream_time_formatter;
    template<typename time_period_type, typename charT = char> 
      class ostream_time_period_formatter;
  }
}

  
    template<typename time_type> class time_itr;
  }
}

  

    // computes exponential math like 2^8 => 256, only works with positive integers 
    template<typename int_type> 
       ( base,  exponent);
    template<typename time_duration, typename char_type> 
      time_duration 
      (const );
    template<typename time_duration> 
      time_duration (const );

    // Utility function to split appart string. 
    bool (const  s, char sep,  first, 
                second);
    template<typename time_type> 
       (const  s, char sep);

    // Parse time duration part of an ISO 8601 time of form: [-]hhmmss[.fff...] (eg: 120259.123 is 12 hours, 2 min, 59 seconds, 123000 microseconds) 
    template<typename time_duration> 
      time_duration (const  s);

    // Parse time string of form YYYYMMDDThhmmss where T is delimeter between date and time. 
    template<typename time_type> 
       (const  s, char sep);
  }
}

  
    template<typename frac_sec_type,  res, 
              resolution_adjust,  resolution_adjust,  frac_digits, 
             typename var_type> 
      class time_resolution_traits;

    struct time_resolution_traits_adapted32_impl;
    struct time_resolution_traits_adapted64_impl;
    struct time_resolution_traits_bi32_impl;
    struct time_resolution_traits_bi64_impl;

    typedef time_resolution_traits< time_resolution_traits_adapted32_impl,  ;
    typedef time_resolution_traits< time_resolution_traits_adapted64_impl,  ;
    typedef time_resolution_traits< time_resolution_traits_adapted64_impl,  ;

    // Simple function to calculate absolute value of a numeric type. 
    template<typename T> BOOST_CXX14_CONSTEXPR T (T x);
  }
}

  
    template<typename config> struct counted_time_rep;

    template<typename time_rep> class counted_time_system;
  }
}

  
    template<typename config,  ticks_per_second> class split_timedate_system;
  }
}

  
    template<typename time_duration_type> class dst_adjustment_offsets;
    template<typename time_type, typename CharT> class time_zone_base;
  }
}

  
    template<typename CharT> struct default_zone_names;

    template<typename CharT> class time_zone_names_base;
  }
}

  
    class bad_field_count;
    class data_not_accessible;
    template<typename time_zone_type, typename rule_type> class tz_db_base;
  }
}

  
    template<typename int_type_,  wrap_val> class wrapping_int;
    template<typename int_type_,  wrap_min,  wrap_max> class wrapping_int2;
  }
}

  
    template<typename YearType, typename MonthType, typename DayType> 
      struct year_month_day_base;
  }
}

  

    // Converts a date to a tm struct. Throws out_of_range exception if date is a special value. 
     (date & d);

    // Converts a tm structure into a date dropping the any time values. 
    date ( datetm);
  }
}

  
    template<typename charT> 
       (date & d);
    template<typename charT> 
       ( d);
    template<typename charT> 
       ( d);
    template<typename charT> 
       (date & d);
    template<typename charT> 
       (date & d);
    template<typename charT> 
       (date & d);

    // Convert date period to simple string. Example: [2002-Jan-01/2002-Jan-02]. 
     ( d);

    // To YYYY-mmm-DD string where mmm 3 char month name. Example: 2002-Jan-01. 
     (date & d);

    // Date period to iso standard format CCYYMMDD/CCYYMMDD. Example: 20021225/20021231. 
     ( d);

    // Convert to iso extended format string CCYY-MM-DD. Example 2002-12-31. 
     (date & d);

    // Convert to iso standard string YYYYMMDD. Example: 20021231. 
     (date & d);
     (date & d);
  }
}

  

    // Convert to ISO 8601 standard string YYYYMMDD. Example: 20021231. 
     (date &);

    // To YYYY-mmm-DD string where mmm 3 char month name. Example: 2002-Jan-01. 
     (date & d);

    // Convert date period to simple string. Example: [2002-Jan-01/2002-Jan-02]. 
     ( d);

    // Date period to ISO 8601 standard format CCYYMMDD/CCYYMMDD. Example: 20021225/20021231. 
     ( d);

    // Convert to ISO 8601 extended format string CCYY-MM-DD. Example 2002-12-31. 
     (date & d);
     (date & d);
  }
}

  
    class gregorian_calendar;

    typedef  ;  // An internal date representation that includes infinities, not a date. 
  }
}

  
    class date;
     (date & lhs, date & rhs);
  }
}

  
    struct bad_day_of_month;

    class greg_day;

    typedef bad_day_of_month > ;  // Policy class that declares error handling and day of month ranges. 
    typedef  ;  // Generated represetation for gregorian day of month. 
  }
}

  
    struct bad_day_of_year;

    typedef bad_day_of_year > ;  // A day of the year range (1..366) 
    typedef  ;  // Define a range representation type for the day of the year 1..366. 
  }
}

  
    class date_duration;

    typedef  ;  // An internal date representation that includes infinities, not a date. 
    typedef date_duration ;  // Shorthand for date_duration. 
    date_duration 
    (date_duration rhs, date_duration  lhs);
    date_duration 
    (date_duration rhs, date_duration  lhs);
    date_duration (date_duration rhs,  lhs);
  }
}

  
    struct greg_durations_config;

    class weeks_duration;

    typedef greg_durations_config > ;
    typedef greg_durations_config > ;
    typedef weeks_duration ;
  }
}

  
    struct greg_facet_config;

    typedef greg_facet_config > ;  // Create the base facet type for gregorian::date. 
    template<typename charT, typename traits> 
       
      (, date &);
    template<typename charT, typename traits> 
       
      (, greg_month &);
    template<typename charT, typename traits> 
       
      (, greg_weekday &);
    template<typename charT, typename traits> 
       
      (, );
    template<typename charT, typename traits> 
       
      ( os, 
                 date_duration & dd);

    // operator<< for gregorian::partial_date. Output: "Jan 1" 
    template<typename charT, typename traits> 
       
      ( os, 
                  pd);

    // operator<< for gregorian::nth_kday_of_month. Output: "first Mon of Jun" 
    template<typename charT, typename traits> 
       
      ( os, 
                  nkd);

    // operator<< for gregorian::first_kday_of_month. Output: "first Mon of Jun" 
    template<typename charT, typename traits> 
       
      ( os, 
                  fkd);

    // operator<< for gregorian::last_kday_of_month. Output: "last Mon of Jun" 
    template<typename charT, typename traits> 
       
      ( os, 
                  lkd);

    // operator<< for gregorian::first_kday_after. Output: "first Mon after" 
    template<typename charT, typename traits> 
       
      ( os, 
                  fka);

    // operator<< for gregorian::first_kday_before. Output: "first Mon before" 
    template<typename charT, typename traits> 
       
      ( os, 
                  fkb);

    // operator>> for gregorian::date
    template<typename charT> 
       
      ( is, date & d);

    // operator>> for gregorian::date_duration
    template<typename charT> 
       
      ( is, date_duration & dd);

    // operator>> for gregorian::date_period 
    template<typename charT> 
       
      ( is,  dp);

    // generates a locale with the set of gregorian name-strings of type char* 
     
    ( loc,  type);

    // Returns a pointer to a facet with a default set of names (English) 
    greg_facet_config,  
    ( type);

    // generates a locale with the set of gregorian name-strings of type wchar_t* 
     
    ( loc,  type);

    // Returns a pointer to a facet with a default set of names (English) 
    greg_facet_config,  
    ( type);

    // operator>> for gregorian::greg_month - throws exception if invalid month given 
    template<typename charT> 
       
      ( is, greg_month & m);

    // operator>> for gregorian::greg_weekday - throws exception if invalid weekday given 
    template<typename charT> 
       
      ( is, greg_weekday & wd);
  }
}

  
    struct bad_month;

    class greg_month;

    typedef  ;
    typedef bad_month > ;  // Build a policy class for the greg_month_rep. 
    typedef  ;  // A constrained range that implements the gregorian_month rules. 
  }
}

  
  }
  
     (::boost::gregorian::date);
    template<typename Archive> 
       (, ::boost::gregorian::date &, );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (, ::boost::gregorian::date * dp, 
                               );

    // Function to save gregorian::date_duration objects using serialization lib. 
    template<typename Archive> 
       ( ar, gregorian::date_duration & dd, 
                );

    // Function to load gregorian::date_duration objects using serialization lib. 
    template<typename Archive> 
       ( ar, gregorian::date_duration & dd, );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (, gregorian::date_duration * dd, 
                               );

    // helper unction to save date_duration objects using serialization lib 
    template<typename Archive> 
       ( ar, 
                 dr, 
                );

    // helper function to load date_duration objects using serialization lib 
    template<typename Archive> 
       ( ar,  dr, 
                );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (, 
                                dr, 
                               );
    template<typename Archive> 
       (, , );
    template<typename Archive> 
       (, , );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (,  dp, 
                               );

    // Function to save gregorian::greg_year objects using serialization lib. 
    template<typename Archive> 
       ( ar, gregorian::greg_year & gy, );

    // Function to load gregorian::greg_year objects using serialization lib. 
    template<typename Archive> 
       ( ar, gregorian::greg_year & gy, );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (, gregorian::greg_year * gy, 
                               );

    // Function to save gregorian::greg_month objects using serialization lib. 
    template<typename Archive> 
       ( ar, gregorian::greg_month & gm, );

    // Function to load gregorian::greg_month objects using serialization lib. 
    template<typename Archive> 
       ( ar, gregorian::greg_month & gm, );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (, gregorian::greg_month * gm, 
                               );

    // Function to save gregorian::greg_day objects using serialization lib. 
    template<typename Archive> 
       ( ar, gregorian::greg_day & gd, );

    // Function to load gregorian::greg_day objects using serialization lib. 
    template<typename Archive> 
       ( ar, gregorian::greg_day & gd, );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (, gregorian::greg_day * gd, 
                               );

    // Function to save gregorian::greg_weekday objects using serialization lib. 
    template<typename Archive> 
       ( ar, gregorian::greg_weekday & gd, 
                );

    // Function to load gregorian::greg_weekday objects using serialization lib. 
    template<typename Archive> 
       ( ar, gregorian::greg_weekday & gd, );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (, gregorian::greg_weekday * gd, 
                               );
    template<typename Archive> 
       (, , );
    template<typename Archive> 
       (, , );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (,  pd, 
                               );
    template<typename Archive> 
       (, , );
    template<typename Archive> 
       (, , );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (,  nkd, 
                               );
    template<typename Archive> 
       (, , 
                );
    template<typename Archive> 
       (, , );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (, 
                                fkd, 
                               );
    template<typename Archive> 
       (, , 
                );
    template<typename Archive> 
       (, , );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (,  lkd, 
                               );

    // Function to save first_day_of_the_week_before objects using serialization lib. 
    template<typename Archive> 
       ( ar,  fkdb, 
                );

    // Function to load first_day_of_the_week_before objects using serialization lib. 
    template<typename Archive> 
       ( ar,  fkdb, 
                );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (,  fkdb, 
                               );

    // Function to save first_day_of_the_week_after objects using serialization lib. 
    template<typename Archive> 
       ( ar,  fkda, 
                );

    // Function to load first_day_of_the_week_after objects using serialization lib. 
    template<typename Archive> 
       ( ar,  fkda, 
                );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (,  fkda, 
                               );
  }
}

  
    struct bad_weekday;

    class greg_weekday;

    typedef bad_weekday > ;
    typedef  ;
  }
}

  
    struct bad_year;

    class greg_year;

    typedef bad_year > ;  // Policy class that declares error handling gregorian year type. 
    typedef  ;  // Generated representation for gregorian year. 
  }
}

  
    typedef greg_year, greg_month, greg_day > ;
  }
}

Single file header that provides overall include for all elements of the gregorian date-time system. This includes the various types defined, but also other functions for formatting and parsing.

  
    typedef  ;
    typedef  ;
    typedef date,  ;
    typedef date,  ;
    typedef date,  ;
    typedef date,  ;
    typedef  ;
    typedef  ;
    typedef date,  ;
    typedef date,  ;
    typedef date,  ;
    typedef date,  ;
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                 boost::gregorian::date & d);

    // input operator for date 
    template<typename CharT, typename Traits> 
       
      ( is, date & d);
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                 boost::gregorian::date_duration & dd);

    // input operator for date_duration
    template<typename CharT, typename Traits> 
       
      ( is, date_duration & dd);
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                  dp);

    // input operator for date_period 
    template<typename CharT, typename Traits> 
       
      ( is,  dp);
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                 boost::gregorian::greg_month & gm);

    // input operator for greg_month
    template<typename CharT, typename Traits> 
       
      ( is, greg_month & m);
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                 boost::gregorian::greg_weekday & gw);

    // input operator for greg_weekday
    template<typename CharT, typename Traits> 
       
      ( is, greg_weekday & wd);

    // input operator for greg_day
    template<typename CharT, typename Traits> 
       
      ( is, greg_day & gd);

    // input operator for greg_year
    template<typename CharT, typename Traits> 
       
      ( is, greg_year & gy);
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                  pd);

    // input operator for partial_date 
    template<typename CharT, typename Traits> 
       
      ( is,  pd);
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                  nkd);

    // input operator for nth_day_of_the_week_in_month 
    template<typename CharT, typename Traits> 
       
      ( is, 
                  nday);
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                  fkd);

    // input operator for first_day_of_the_week_in_month 
    template<typename CharT, typename Traits> 
       
      ( is, 
                  fkd);
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                  lkd);

    // input operator for last_day_of_the_week_in_month 
    template<typename CharT, typename Traits> 
       
      ( is, 
                  lkd);
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                  fda);

    // input operator for first_day_of_the_week_after 
    template<typename CharT, typename Traits> 
       
      ( is, 
                  fka);
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                  fdb);

    // input operator for first_day_of_the_week_before 
    template<typename CharT, typename Traits> 
       
      ( is, 
                  fkb);
  }
}

Single file header that defines most of the types for the gregorian date-time system.

  
    typedef date, date_duration > ;  // Date periods for the gregorian system. 
    typedef date > ;
    typedef date > ;  // A date generation object type. 
    typedef date > ;
    typedef  ;
    typedef date > ;
    typedef  ;
    typedef date > ;
    typedef  ;
    typedef date > ;
    typedef  ;
    typedef date > ;
    typedef  ;
    typedef date > ;  // A clock to get the current day from the local computer. 
    typedef date > ;  // Base date_iterator type for gregorian types. 
    typedef date >, date > ;  // A day level iterator. 
    typedef date >, date > ;  // A week level iterator. 
    typedef date >, date > ;  // A month level iterator. 
    typedef date >, date > ;  // A year level iterator. 
  }
}

  
     ();

    // Deprecated: Use from_simple_string. 
    date ( s);

    // From delimited date string where with order year-month-day eg: 2002-1-25 or 2003-Jan-25 (full month name is also accepted) 
    date ( s);

    // From delimited date string where with order year-month-day eg: 1-25-2003 or Jan-25-2003 (full month name is also accepted) 
    date ( s);

    // From delimited date string where with order day-month-year eg: 25-1-2002 or 25-Jan-2003 (full month name is also accepted) 
    date ( s);

    // From ISO 8601 type date string where with order year-month-day eg: 20020125. 
    date ( s);

    // From ISO 8601 type date string where with order year-month-day eg: 20020125. 
    date ( s);

    // Stream should hold a date in the form of: 2002-1-25. Month number, abbrev, or name are accepted. 
    template<typename iterator_type> 
      date ( beg,  end);

    // Function to parse a date_period from a string (eg: [2003-Oct-31/2003-Dec-25]) 
     ( s);

    // Function to parse a date_period from a wstring (eg: [2003-Oct-31/2003-Dec-25]) 
     ( s);
  }
}

  

    // Function that converts a time_t into a ptime. 
    ptime ( t);

    // Function that converts a ptime into a time_t. 
     (ptime pt);

    // Convert a time to a tm structure truncating any fractional seconds. 
     (boost::posix_time::ptime & t);

    // Convert a time_duration to a tm structure truncating any fractional seconds and zeroing fields for date components. 
     (boost::posix_time::time_duration & td);

    // Convert a tm struct to a ptime ignoring is_dst flag. 
    ptime ( timetm);
    template<typename TimeT, typename FileTimeT> 
       ();
  }
}

Operators for ptime and optional gregorian types. Operators use snap-to-end-of-month behavior. Further details on this behavior can be found in reference for date_time/date_duration_types.hpp and documentation for month and year iterators.

  
    ptime 
    (ptime &, );
    ptime 
    (ptime &, );
    ptime 
    (ptime &, );
    ptime 
    (ptime &, );
    ptime 
    (ptime &, );
    ptime 
    (ptime &, );
    ptime 
    (ptime &, );
    ptime 
    (ptime &, );
  }
}

Global header file to get all of posix time types

  
    class millisec_posix_time_system_config;
    class posix_time_system_config;

    struct simple_time_rep;

    class time_duration;

    typedef  ;
  }
}

  
    class hours;
    class minutes;
    class seconds;

    typedef time_duration,  ;  // Allows expression of durations as milli seconds. 
    typedef time_duration,  ;
    typedef time_duration,  ;  // Allows expression of durations as micro seconds. 
    typedef time_duration,  ;
    typedef time_duration,  ;  // Allows expression of durations as nano seconds. 
    typedef time_duration,  ;
  }
}

  
    typedef ptime,  ;
    typedef ptime,  ;
    typedef ptime,  ;
    typedef ptime,  ;
    template<typename CharT, typename TraitsT> 
       
      ( os, ptime & p);

    // input operator for ptime 
    template<typename CharT, typename Traits> 
       
      ( is, ptime & pt);
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                  p);

    // input operator for time_period 
    template<typename CharT, typename Traits> 
       
      ( is,  tp);

    // ostream operator for posix_time::time_duration
    template<typename CharT, typename Traits> 
       
      ( os, 
                 time_duration & td);

    // input operator for time_duration
    template<typename CharT, typename Traits> 
       
      ( is, time_duration & td);
  }
}

  

    // ostream operator for posix_time::time_duration
    template<typename charT, typename traits> 
       
      ( os, 
                 time_duration & td);

    // ostream operator for posix_time::ptime
    template<typename charT, typename traits> 
       
      ( os, ptime & t);

    // ostream operator for posix_time::time_period 
    template<typename charT, typename traits> 
       
      ( os, 
                  tp);
    template<typename charT> 
       
      ( is, time_duration & td);
    template<typename charT> 
       
      ( is, ptime & pt);
    template<typename charT> 
       
      (, );
  }
}

  
    typedef posix_time_system_config,  ;
    typedef millisec_posix_time_system_config > ;
  }
}

  
    typedef ptime > ;  // Iterator over a defined time duration. 
    typedef ptime > ;  // A time clock that has a resolution of one second. 
    typedef ptime > ;  // A time clock that has a resolution of one microsecond. 
    typedef time_duration > ;  // Define a dst null dst rule for the posix_time system. 
    typedef time_duration > ;  // Define US dst rule calculator for the posix_time system. 
  }
}

  
    class ptime;
     
    (ptime & lhs, ptime & rhs);
  }
}

  
    template<typename charT> 
       (time_duration td);
    template<typename charT> 
       (time_duration td);

    // Time to simple format CCYY-mmm-dd hh:mm:ss.fffffff. 
    template<typename charT> 
       (ptime t);
    template<typename charT> 
       ( tp);
    template<typename charT> 
       (ptime t);
    template<typename charT> 
       (ptime t);

    // Time duration to wstring -hh::mm::ss.fffffff. Example: 10:09:03.0123456. 
     (time_duration td);

    // Time duration in ISO 8601 format -hhmmss.fffffff. Example: 10:09:03.0123456. 
     (time_duration td);
     (ptime t);

    // Convert to wstring of form [YYYY-mmm-DD HH:MM::SS.ffffff/YYYY-mmm-DD HH:MM::SS.fffffff]. 
     ( tp);

    // Convert ISO 8601 short form YYYYMMDDTHHMMSS where T is the date-time separator. 
     (ptime t);

    // Convert to form YYYY-MM-DDTHH:MM:SS where T is the date-time separator. 
     (ptime t);
  }
}

  

    // Time duration to string -hh::mm::ss.fffffff. Example: 10:09:03.0123456. 
     (time_duration td);

    // Time duration in ISO 8601 format -hhmmss.fffffff. Example: 10:09:03.0123456. 
     (time_duration td);

    // Time to simple format CCYY-mmm-dd hh:mm:ss.fffffff. 
     (ptime t);

    // Convert to string of form [YYYY-mmm-DD HH:MM::SS.ffffff/YYYY-mmm-DD HH:MM::SS.fffffff]. 
     ( tp);

    // Convert ISO 8601 short form YYYYMMDDTHHMMSS where T is the date-time separator. 
     (ptime t);

    // Convert to form YYYY-MM-DDTHH:MM:SS where T is the date-time separator. 
     (ptime t);
  }
}

  
    time_duration ();
    ptime ( s);
    ptime ( s);
    ptime ( s);
  }
}

  
    typedef ptime, time_duration > ;  // Time period type. 
  }
}

  
    template<typename T> struct version;

    template<> struct version<>;
     (boost::posix_time::ptime);
    template<typename Archive> 
       ( ar, posix_time::time_duration & td, 
                 version);
    template<typename TimeResTraitsSize, typename Archive> 
       (, posix_time::time_duration &);
    template<typename Archive> 
       ( ar, posix_time::time_duration & td, 
                 version);
    template<typename Archive> 
       (, posix_time::ptime &, );
    template<typename Archive> 
       (, posix_time::ptime &, );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (, posix_time::ptime * pt, 
                               );
    template<typename Archive> 
       (, , );
    template<typename Archive> 
       (, , );

    // override needed b/c no default constructor 
    template<typename Archive> 
       (,  tp, 
                               );
  }
}

  

    // Function that creates a tm struct from a local_date_time. 
     (local_date_time & lt);
  }
}

  
    template<typename CharT> class custom_time_zone_base;

    typedef  ;
    typedef custom_time_zone_base<  ;
  }
}

Operators for local_date_time and optional gregorian types. Operators use snap-to-end-of-month behavior. Further details on this behavior can be found in reference for date_time/date_duration_types.hpp and documentation for month and year iterators.

  
    local_date_time 
    (local_date_time &, );
    local_date_time 
    (local_date_time &, );
    local_date_time 
    (local_date_time &, );
    local_date_time 
    (local_date_time &, );
    local_date_time 
    (local_date_time &, );
    local_date_time 
    (local_date_time &, );
    local_date_time 
    (local_date_time &, );
    local_date_time 
    (local_date_time &, );
  }
}

  
    struct first_last_rule_spec;
    struct last_last_rule_spec;
    struct nth_kday_rule_spec;
    struct nth_last_rule_spec;
    struct partial_date_rule_spec;

    typedef  ;  // Provides rule of the form starting Apr 30 ending Oct 21. 
    typedef partial_date_rule_spec > ;  // Provides rule of the form first Sunday in April, last Saturday in Oct. 
    typedef first_last_rule_spec > ;  // Provides rule of the form first Sunday in April, last Saturday in Oct. 
    typedef last_last_rule_spec > ;  // Provides rule of the form last Sunday in April, last Saturday in Oct. 
    typedef nth_last_rule_spec > ;  // Provides rule in form of [1st|2nd|3rd|4th] Sunday in April, last Sunday in Oct. 
    typedef nth_kday_rule_spec > ;  // Provides rule in form of [1st|2nd|3rd|4th] Sunday in April/October. 
    typedef nth_kday_rule_spec > ;  // Provides rule in form of [1st|2nd|3rd|4th] Sunday in April/October. 
  }
}

  
    struct ambiguous_result;
    struct dst_not_valid;

    template<typename utc_time_, 
             typename tz_type> class local_date_time_base;

    struct time_label_invalid;

    typedef local_date_time_base ;  // Use the default parameters to define local_date_time. 
  }
}

  
    typedef local_date_time,  ;
    typedef local_date_time,  ;
    typedef  ;
    typedef  ;

    // operator<< for local_date_time - see local_time docs for formatting details 
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                 local_date_time & ldt);

    // input operator for local_date_time 
    template<typename CharT, typename Traits> 
       
      ( is, 
                 local_date_time & ldt);

    // output operator for local_time_period 
    template<typename CharT, typename TraitsT> 
       
      ( os, 
                  p);

    // input operator for local_time_period 
    template<typename CharT, typename Traits> 
       
      ( is, 
                  tp);
  }
}

  
    typedef local_date_time,  ;
    typedef local_date_time > ;
    typedef local_date_time > ;
    typedef local_date_time > ;
    typedef  ;
    typedef  ;
    typedef  ;  // Shared Pointer for custom_time_zone and posix_time_zone objects. 
    typedef  ;
    typedef  ;
    typedef  ;
  }
}

  
    struct bad_adjustment;
    struct bad_offset;

    template<typename CharT> class posix_time_zone_base;

    typedef  ;
    typedef posix_time_zone_base<  ;
  }
}

  
    typedef  ;
  }
}