Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
PrevUpHomeNext

Examples

Dates as Strings
Days Alive
Days Between New Years
Last Day of the Months
Localization Demonstration
Date Period Calculations
Print Holidays
Print Month
Month Adding
Time Math
Print Hours
Local to UTC Conversion
Time Periods
Simple Time Zones
Daylight Savings Calc Rules
Flight Time Example
Seconds Since Epoch

Dates as Strings

Various parsing and output of strings.

    

  /* The following is a simple example that shows conversion of dates 
   * to and from a std::string.
   * 
   * Expected output:
   * 2001-Oct-09
   * 2001-10-09
   * Tuesday October 9, 2001
   * An expected exception is next: 
   * Exception: Month number is out of range 1..12
   */

  #include "boost/date_time/gregorian/gregorian.hpp"
  #include <iostream>
  #include <string>

  int
  main() 
  {

    using namespace boost::gregorian;

    try {
      // The following date is in ISO 8601 extended format (CCYY-MM-DD)
      std::string s("2001-10-9"); //2001-October-09
      date d(from_simple_string(s));
      std::cout << to_simple_string(d) << std::endl;
      
      //Read ISO Standard(CCYYMMDD) and output ISO Extended
      std::string ud("20011009"); //2001-Oct-09
      date d1(from_undelimited_string(ud));
      std::cout << to_iso_extended_string(d1) << std::endl;
      
      //Output the parts of the date - Tuesday October 9, 2001
      date::ymd_type ymd = d1.year_month_day();
      greg_weekday wd = d1.day_of_week();
      std::cout << wd.as_long_string() << " "
                << ymd.month.as_long_string() << " "
                << ymd.day << ", " << ymd.year
                << std::endl;

      //Let's send in month 25 by accident and create an exception
      std::string bad_date("20012509"); //2001-??-09
      std::cout << "An expected exception is next: " << std::endl;
      date wont_construct(from_undelimited_string(bad_date));
      //use wont_construct so compiler doesn't complain, but you wont get here!
      std::cout << "oh oh, you shouldn't reach this line: " 
                << to_iso_string(wont_construct) << std::endl;
    }
    catch(std::exception& e) {
      std::cout << "  Exception: " <<  e.what() << std::endl;
    }


    return 0;
  }

    
  

Days Alive

Calculate the number of days you have been living using durations and dates.


/* Short example that calculates the number of days since user was born.
 * Demonstrates comparisons of durations, use of the day_clock,
 * and parsing a date from a string.
 */

#include "boost/date_time/gregorian/gregorian.hpp"
#include <iostream>

int
main() 
{
  
  using namespace boost::gregorian;
  std::string s;
  std::cout << "Enter birth day YYYY-MM-DD (eg: 2002-02-01): ";
  std::cin >> s;
  try {
    date birthday(from_simple_string(s));
    date today = day_clock::local_day();
    days days_alive = today - birthday;
    days one_day(1);
    if (days_alive == one_day) {
      std::cout << "Born yesterday, very funny" << std::endl;
    }
    else if (days_alive < days(0)) {
      std::cout << "Not born yet, hmm: " << days_alive.days() 
                << " days" <<std::endl;
    }
    else {
      std::cout << "Days alive: " << days_alive.days() << std::endl;
    }

  }
  catch(...) {
    std::cout << "Bad date entered: " << s << std::endl;
  }
  return 0;
}

Days Between New Years

Calculate the number of days till new years

    
  /* Provides a simple example of using a date_generator, and simple
   * mathematical operatorations, to calculate the days since 
   * New Years day of this year, and days until next New Years day.
   *
   * Expected results:
   * Adding together both durations will produce 366 (365 in a leap year).
   */
  #include <iostream>
  #include "boost/date_time/gregorian/gregorian.hpp"

  int
  main() 
  {
    
    using namespace boost::gregorian;

    date today = day_clock::local_day();
    partial_date new_years_day(1,Jan);
    //Subtract two dates to get a duration
    days days_since_year_start = today - new_years_day.get_date(today.year());
    std::cout << "Days since Jan 1: " << days_since_year_start.days() 
              << std::endl;
    
    days days_until_year_start = new_years_day.get_date(today.year()+1) - today;
    std::cout << "Days until next Jan 1: " << days_until_year_start.days() 
              << std::endl;
    return 0;
  };

    
  

Last Day of the Months

Example that gets a month and a year from the user and finds the last day of each remaining month of that year.

    
  /* Simple program that finds the last day of the given month, 
   * then displays the last day of every month left in the given year.
   */

  #include "boost/date_time/gregorian/gregorian.hpp"
  #include <iostream>

  int
  main()
  {
    using namespace boost::gregorian;
    
    greg_year year(1400);
    greg_month month(1);

    // get a month and a year from the user
    try {
      int y, m;
      std::cout << "   Enter Year(ex: 2002): ";
      std::cin >> y;
      year = greg_year(y);
      std::cout << "   Enter Month(1..12): ";
      std::cin >> m;
      month = greg_month(m);
    }
    catch(bad_year by) {
      std::cout << "Invalid Year Entered: " << by.what() << '\n'
        << "Using minimum values for month and year." << std::endl;
    }
    catch(bad_month bm) {
      std::cout << "Invalid Month Entered" << bm.what() << '\n'
        << "Using minimum value for month. " << std::endl;
    }
    
    date start_of_next_year(year+1, Jan, 1);
    date d(year, month, 1);
    
    // add another month to d until we enter the next year.
    while (d < start_of_next_year){
      std::cout << to_simple_string(d.end_of_month()) << std::endl;
      d += months(1);
    }

    return 0;
  }

    
  

Localization Demonstration

The boost::date_time library provides the ability to create customized locale facets. Date ordering, language, seperators, and abbreviations can be customized.

    
  /* The following shows the creation of a facet for the output of 
   * dates in German (please forgive me for any errors in my German --
   * I'm not a native speaker).
   */

  #include "boost/date_time/gregorian/gregorian.hpp"
  #include <iostream>
  #include <algorithm>

  /* Define a series of char arrays for short and long name strings 
   * to be associated with German date output (US names will be 
   * retrieved from the locale). */
  const char* const de_short_month_names[] = 
  {
    "Jan", "Feb", "Mar", "Apr", "Mai", "Jun",
    "Jul", "Aug", "Sep", "Okt", "Nov", "Dez", "NAM" 
  };
  const char* const de_long_month_names[] =
  {
    "Januar", "Februar", "Marz", "April", "Mai",
    "Juni", "Juli", "August", "September", "Oktober",
    "November", "Dezember", "NichtDerMonat"
  };
  const char* const de_long_weekday_names[] = 
  {
    "Sonntag", "Montag", "Dienstag", "Mittwoch",
    "Donnerstag", "Freitag", "Samstag"
  };
  const char* const de_short_weekday_names[] =
  {
    "Son", "Mon", "Die","Mit", "Don", "Fre", "Sam"
  };


  int main() 
  {
    using namespace boost::gregorian;
   
    // create some gregorian objects to output
    date d1(2002, Oct, 1);
    greg_month m = d1.month();
    greg_weekday wd = d1.day_of_week();
    
    // create a facet and a locale for German dates
    date_facet* german_facet = new date_facet();
    std::cout.imbue(std::locale(std::locale::classic(), german_facet));

    // create the German name collections
    date_facet::input_collection_type short_months, long_months, 
                                      short_weekdays, long_weekdays;
    std::copy(&de_short_month_names[0], &de_short_month_names[11],
              std::back_inserter(short_months));
    std::copy(&de_long_month_names[0], &de_long_month_names[11],
              std::back_inserter(long_months));
    std::copy(&de_short_weekday_names[0], &de_short_weekday_names[6],
              std::back_inserter(short_weekdays));
    std::copy(&de_long_weekday_names[0], &de_long_weekday_names[6],
              std::back_inserter(long_weekdays));

    // replace the default names with ours
    // NOTE: date_generators and special_values were not replaced as 
    // they are not used in this example
    german_facet->short_month_names(short_months);
    german_facet->long_month_names(long_months);
    german_facet->short_weekday_names(short_weekdays);
    german_facet->long_weekday_names(long_weekdays);
    
    // output the date in German using short month names
    german_facet->format("%d.%m.%Y");
    std::cout << d1 << std::endl; //01.10.2002
    
    german_facet->month_format("%B");
    std::cout << m << std::endl; //Oktober
    
    german_facet->weekday_format("%A");
    std::cout << wd << std::endl; //Dienstag


    // Output the same gregorian objects using US names
    date_facet* us_facet = new date_facet();
    std::cout.imbue(std::locale(std::locale::classic(), us_facet)); 

    us_facet->format("%m/%d/%Y");
    std::cout << d1 << std::endl; //  10/01/2002
    
    // English names, iso order (year-month-day), '-' separator
    us_facet->format("%Y-%b-%d");
    std::cout << d1 << std::endl; //  2002-Oct-01
    
    return 0;

  }
    
  

Date Period Calculations

Calculates if a date is in an 'irregular' collection of periods using period calculation functions.

    
  /*
  This example demonstrates a simple use of periods for the calculation
  of date information.

  The example calculates if a given date is a weekend or holiday
  given an exclusion set.  That is, each weekend or holiday is
  entered into the set as a time interval.  Then if a given date
  is contained within any of the intervals it is considered to
  be within the exclusion set and hence is a offtime.

  Output:
  Number Excluded Periods: 5
  20020202/20020203
  20020209/20020210
  20020212/20020212
  20020216/20020217
  In Exclusion Period: 20020216 --> 20020216/20020217
  20020223/20020224

  */


  #include "boost/date_time/gregorian/gregorian.hpp"
  #include <set>
  #include <algorithm>
  #include <iostream>

  typedef std::set<boost::gregorian::date_period> date_period_set;

  //Simple population of the exclusion set
  date_period_set
  generateExclusion()
  {
    using namespace boost::gregorian;
    date_period periods_array[] = 
      { date_period(date(2002,Feb,2), date(2002,Feb,4)),//weekend of 2nd-3rd
        date_period(date(2002,Feb,9), date(2002,Feb,11)),
        date_period(date(2002,Feb,16), date(2002,Feb,18)),
        date_period(date(2002,Feb,23), date(2002,Feb,25)),
        date_period(date(2002,Feb,12), date(2002,Feb,13))//a random holiday 2-12
      };
    const int num_periods = sizeof(periods_array)/sizeof(date_period);

    date_period_set ps;
    //insert the periods in the set
    std::insert_iterator<date_period_set> itr(ps, ps.begin());
    std::copy(periods_array, periods_array+num_periods, itr );
    return ps;
    
  }


  int main() 
  {
    using namespace boost::gregorian;
    
    date_period_set ps = generateExclusion();
    std::cout << "Number Excluded Periods: "  << ps.size() << std::endl;

    date d(2002,Feb,16);
    date_period_set::const_iterator i = ps.begin();
    //print the periods, check for containment
    for (;i != ps.end(); i++) {
      std::cout << to_iso_string(*i) << std::endl;
      //if date is in exclusion period then print it
      if (i->contains(d)) {
        std::cout << "In Exclusion Period: "
            << to_iso_string(d) << " --> " << to_iso_string(*i)
            << std::endl;
      }
    }

    return 0;  

  }

    
  

Print Holidays

This is an example of using functors to define a holiday schedule

    

  /* Generate a set of dates using a collection of date generators
   * Output looks like:
   * Enter Year: 2002
   * 2002-Jan-01 [Tue]
   * 2002-Jan-21 [Mon]
   * 2002-Feb-12 [Tue]
   * 2002-Jul-04 [Thu]
   * 2002-Sep-02 [Mon]
   * 2002-Nov-28 [Thu]
   * 2002-Dec-25 [Wed]
   * Number Holidays: 7
   */

  #include "boost/date_time/gregorian/gregorian.hpp"
  #include <algorithm>
  #include <functional>
  #include <vector>
  #include <iostream>
  #include <set>

  void
  print_date(boost::gregorian::date d) 
  {
    using namespace boost::gregorian;
  #if defined(BOOST_DATE_TIME_NO_LOCALE)
    std::cout << to_simple_string(d) << " [" << d.day_of_week() << "]\n";
  #else
    std::cout << d << " [" << d.day_of_week() << "]\n";
  #endif
  }


  int
  main() {

    std::cout << "Enter Year: ";
    int year;
    std::cin >> year;

    using namespace boost::gregorian;

    //define a collection of holidays fixed by month and day
    std::vector<year_based_generator*> holidays;
    holidays.push_back(new partial_date(1,Jan)); //Western New Year
    holidays.push_back(new partial_date(4,Jul)); //US Independence Day
    holidays.push_back(new partial_date(25, Dec));//Christmas day


    //define a shorthand for the nth_day_of_the_week_in_month function object
    typedef nth_day_of_the_week_in_month nth_dow;
    
    //US labor day
    holidays.push_back(new nth_dow(nth_dow::first,  Monday,   Sep)); 
    //MLK Day
    holidays.push_back(new nth_dow(nth_dow::third,  Monday,   Jan)); 
    //Pres day
    holidays.push_back(new nth_dow(nth_dow::second, Tuesday,  Feb)); 
    //Thanksgiving
    holidays.push_back(new nth_dow(nth_dow::fourth, Thursday, Nov)); 

    typedef std::set<date> date_set;
    date_set all_holidays;
    
    for(std::vector<year_based_generator*>::iterator it = holidays.begin();
        it != holidays.end(); ++it)
    {
      all_holidays.insert((*it)->get_date(year));
    }

    //print the holidays to the screen
    std::for_each(all_holidays.begin(), all_holidays.end(), print_date);
    std::cout << "Number Holidays: " << all_holidays.size() << std::endl;

    return 0;
  }

    
  

Print Month

Simple utility to print out days of the month with the days of a month. Demontstrates date iteration (date_time::date_itr).

    
  /* This example prints all the dates in a month. It demonstrates
   * the use of iterators as well as functions of the gregorian_calendar
   * 
   * Output:
   * Enter Year: 2002
   * Enter Month(1..12): 2
   * 2002-Feb-01 [Fri]
   * 2002-Feb-02 [Sat]
   * 2002-Feb-03 [Sun]
   * 2002-Feb-04 [Mon]
   * 2002-Feb-05 [Tue]
   * 2002-Feb-06 [Wed]
   * 2002-Feb-07 [Thu]
   */

  #include "boost/date_time/gregorian/gregorian.hpp"
  #include <iostream>

  int
  main()
  {
    std::cout << "Enter Year: ";
    int year, month;
    std::cin >> year;
    std::cout << "Enter Month(1..12): ";
    std::cin >> month;

    using namespace boost::gregorian;
    try {
      //Use the calendar to get the last day of the month
      int eom_day = gregorian_calendar::end_of_month_day(year,month);
      date endOfMonth(year,month,eom_day);

      //construct an iterator starting with firt day of the month
      day_iterator ditr(date(year,month,1));
      //loop thru the days and print each one
      for (; ditr <= endOfMonth; ++ditr) {
  #if defined(BOOST_DATE_TIME_NO_LOCALE) 
        std::cout << to_simple_string(*ditr) << " ["
  #else
        std::cout << *ditr << " ["
  #endif
                  << ditr->day_of_week() << "]"
                  << std::endl; 
      }
    }
    catch(std::exception& e) {

      std::cout << "Error bad date, check your entry: \n"
                << "  Details: " << e.what() << std::endl;
    }
    return 0;
  }

    
  

Month Adding

Adding a month to a day without the use of iterators.

    
  /* Simple program that uses the gregorian calendar to progress by exactly
   * one month, irregardless of how many days are in that month.
   *
   * This method can be used as an alternative to iterators
   */

  #include "boost/date_time/gregorian/gregorian.hpp"
  #include <iostream>

  int
  main()
  {

    using namespace boost::gregorian;

    date d = day_clock::local_day();
    add_month mf(1);
    date d2 = d + mf.get_offset(d);
    std::cout << "Today is: " << to_simple_string(d) << ".\n"
      << "One month from today will be: " << to_simple_string(d2) 
      << std::endl;

    return 0;
  }
    
  

Time Math

Various types of calculations with times and time durations.

    
  /* Some simple examples of constructing and calculating with times
   * Output:
   * 2002-Feb-01 00:00:00 - 2002-Feb-01 05:04:02.001000000 = -5:04:02.001000000
   */

  #include "boost/date_time/posix_time/posix_time.hpp"
  #include <iostream>

  int
  main() 
  {
    using namespace boost::posix_time;
    using namespace boost::gregorian;

    date d(2002,Feb,1); //an arbitrary date
    //construct a time by adding up some durations durations
    ptime t1(d, hours(5)+minutes(4)+seconds(2)+millisec(1));
    //construct a new time by subtracting some times
    ptime t2 = t1 - hours(5)- minutes(4)- seconds(2)- millisec(1);
    //construct a duration by taking the difference between times
    time_duration td = t2 - t1;
      
    std::cout << to_simple_string(t2) << " - " 
              << to_simple_string(t1) << " = "
              << to_simple_string(td) << std::endl;
    
    return 0;
  }
    
  

Print Hours

Demonstrate time iteration, clock retrieval, and simple calculation.

    
  /* Print the remaining hours of the day
   * Uses the clock to get the local time 
   * Use an iterator to iterate over the remaining hours
   * Retrieve the date part from a time
   *
   * Expected Output something like:
   *
   * 2002-Mar-08 16:30:59
   * 2002-Mar-08 17:30:59
   * 2002-Mar-08 18:30:59
   * 2002-Mar-08 19:30:59
   * 2002-Mar-08 20:30:59
   * 2002-Mar-08 21:30:59
   * 2002-Mar-08 22:30:59
   * 2002-Mar-08 23:30:59
   * Time left till midnight: 07:29:01
   */

  #include "boost/date_time/posix_time/posix_time.hpp"
  #include <iostream>

  int
  main() 
  {
    using namespace boost::posix_time;
    using namespace boost::gregorian;

    //get the current time from the clock -- one second resolution
    ptime now = second_clock::local_time();
    //Get the date part out of the time
    date today = now.date();
    date tommorrow = today + days(1);
    ptime tommorrow_start(tommorrow); //midnight 

    //iterator adds by one hour
    time_iterator titr(now,hours(1)); 
    for (; titr < tommorrow_start; ++titr) {
      std::cout << to_simple_string(*titr) << std::endl;
    }
    
    time_duration remaining = tommorrow_start - now;
    std::cout << "Time left till midnight: " 
              << to_simple_string(remaining) << std::endl;
    return 0;
  }

    
  

Local to UTC Conversion

Demonstrate utc to local and local to utc calculations including dst.

    

  /* Demonstrate conversions between a local time and utc
   * Output:
   * 
   * UTC <--> New York while DST is NOT active (5 hours)
   * 2001-Dec-31 19:00:00 in New York is 2002-Jan-01 00:00:00 UTC time 
   * 2002-Jan-01 00:00:00 UTC is 2001-Dec-31 19:00:00 New York time 
   * 
   * UTC <--> New York while DST is active (4 hours)
   * 2002-May-31 20:00:00 in New York is 2002-Jun-01 00:00:00 UTC time 
   * 2002-Jun-01 00:00:00 UTC is 2002-May-31 20:00:00 New York time 
   * 
   * UTC <--> Arizona (7 hours)
   * 2002-May-31 17:00:00 in Arizona is 2002-Jun-01 00:00:00 UTC time 
   */

  #include "boost/date_time/posix_time/posix_time.hpp"
  #include "boost/date_time/local_time_adjustor.hpp"
  #include "boost/date_time/c_local_time_adjustor.hpp"
  #include <iostream>

  int
  main() 
  {
    using namespace boost::posix_time;
    using namespace boost::gregorian;

    //This local adjustor depends on the machine TZ settings-- highly dangerous!
    typedef boost::date_time::c_local_adjustor<ptime> local_adj;
    ptime t10(date(2002,Jan,1), hours(7)); 
    ptime t11 = local_adj::utc_to_local(t10);
    std::cout << "UTC <--> Zone base on TZ setting" << std::endl;
    std::cout << to_simple_string(t11) << " in your TZ is " 
              << to_simple_string(t10) << " UTC time "
              << std::endl;
    time_duration td = t11 - t10;
    std::cout << "A difference of: " 
              << to_simple_string(td) << std::endl;


    //eastern timezone is utc-5
    typedef boost::date_time::local_adjustor<ptime, -5, us_dst> us_eastern;

    ptime t1(date(2001,Dec,31), hours(19)); //5 hours b/f midnight NY time

    std::cout << "\nUTC <--> New York while DST is NOT active (5 hours)" 
              << std::endl;
    ptime t2 =  us_eastern::local_to_utc(t1);
    std::cout << to_simple_string(t1) << " in New York is " 
              << to_simple_string(t2) << " UTC time "
              << std::endl;

    ptime t3 = us_eastern::utc_to_local(t2);//back should be the same
    std::cout << to_simple_string(t2) << " UTC is " 
              << to_simple_string(t3) << " New York time "
              << "\n\n";

    ptime t4(date(2002,May,31), hours(20)); //4 hours b/f midnight NY time
    std::cout << "UTC <--> New York while DST is active (4 hours)" << std::endl;
    ptime t5 = us_eastern::local_to_utc(t4);
    std::cout << to_simple_string(t4) << " in New York is " 
              << to_simple_string(t5) << " UTC time "
              << std::endl;

    ptime t6 = us_eastern::utc_to_local(t5);//back should be the same
    std::cout << to_simple_string(t5) << " UTC is " 
              << to_simple_string(t6) << " New York time "
              << "\n" << std::endl;

      
    //Arizona timezone is utc-7 with no dst
    typedef boost::date_time::local_adjustor<ptime, -7, no_dst> us_arizona;

    ptime t7(date(2002,May,31), hours(17)); 
    std::cout << "UTC <--> Arizona (7 hours)" << std::endl;
    ptime t8 = us_arizona::local_to_utc(t7);
    std::cout << to_simple_string(t7) << " in Arizona is " 
              << to_simple_string(t8) << " UTC time "
              << std::endl;

    return 0;
  }

    
  

Time Periods

Demonstrate some simple uses of time periods.

    

  /* Some simple examples of constructing and calculating with times
   * Returns:
   * [2002-Feb-01 00:00:00/2002-Feb-01 23:59:59.999999999] 
   * contains 2002-Feb-01 03:00:05
   * [2002-Feb-01 00:00:00/2002-Feb-01 23:59:59.999999999] 
   * intersected with
   * [2002-Feb-01 00:00:00/2002-Feb-01 03:00:04.999999999] 
   * is 
   * [2002-Feb-01 00:00:00/2002-Feb-01 03:00:04.999999999]
   */

  #include "boost/date_time/posix_time/posix_time.hpp"
  #include <iostream>

  using namespace boost::posix_time;
  using namespace boost::gregorian;

  //Create a simple period class to contain all the times in a day
  class day_period : public time_period
  {
  public:
    day_period(date d) : time_period(ptime(d),//midnight
                                     ptime(d,hours(24)))
    {}

  };

  int
  main() 
  {

    date d(2002,Feb,1); //an arbitrary date
    //a period that represents a day  
    day_period dp(d);
    ptime t(d, hours(3)+seconds(5)); //an arbitray time on that day
    if (dp.contains(t)) {
      std::cout << to_simple_string(dp) << " contains "
                << to_simple_string(t)  << std::endl;
    }
    //a period that represents part of the day
    time_period part_of_day(ptime(d, hours(0)), t);
    //intersect the 2 periods and print the results
    if (part_of_day.intersects(dp)) {
      time_period result = part_of_day.intersection(dp);
      std::cout << to_simple_string(dp) << " intersected with\n"
                << to_simple_string(part_of_day) << " is \n"
                << to_simple_string(result) << std::endl;
    }
      
    
    return 0;
  }

    
  

Simple Time Zones

Example usage of custom_time_zone as well as posix_time_zone.

    
  /* A simple example for using a custom_time_zone and a posix_time_zone.
   */

  #include "boost/date_time/local_time/local_time.hpp"
  #include <iostream>

  int
  main() 
  {
    using namespace boost;
    using namespace local_time;
    using namespace gregorian;
    using posix_time::time_duration;

    /***** custom_time_zone *****/
    
    // create the dependent objects for a custom_time_zone
    time_zone_names tzn("Eastern Standard Time", "EST",
                        "Eastern Daylight Time", "EDT");
    time_duration utc_offset(-5,0,0);
    dst_adjustment_offsets adj_offsets(time_duration(1,0,0), 
                                       time_duration(2,0,0), 
                                       time_duration(2,0,0));
    // rules for this zone are:
    // start on first Sunday of April at 2 am
    // end on last Sunday of October at 2 am
    // so we use a first_last_dst_rule
    first_day_of_the_week_in_month start_rule(Sunday, Apr);
    last_day_of_the_week_in_month    end_rule(Sunday, Oct);
    shared_ptr<dst_calc_rule> nyc_rules(new first_last_dst_rule(start_rule, 
                                                                end_rule));
    // create more dependent objects for a non-dst custom_time_zone
    time_zone_names tzn2("Mountain Standard Time", "MST",
                         "", ""); // no dst means empty dst strings
    time_duration utc_offset2(-7,0,0);
    dst_adjustment_offsets adj_offsets2(time_duration(0,0,0), 
                                        time_duration(0,0,0), 
                                        time_duration(0,0,0));
    // no dst means we need a null pointer to the rules
    shared_ptr<dst_calc_rule> phx_rules;

    // create the custom_time_zones
    time_zone_ptr nyc_1(new custom_time_zone(tzn, utc_offset, 
                                             adj_offsets, nyc_rules));
    time_zone_ptr phx_1(new custom_time_zone(tzn2, utc_offset2, 
                                             adj_offsets2, phx_rules));

    /***** posix_time_zone *****/

    // create posix_time_zones that are the duplicates of the 
    // custom_time_zones created above. See posix_time_zone documentation 
    // for details on full zone names.
    std::string nyc_string, phx_string;
    nyc_string = "EST-05:00:00EDT+01:00:00,M4.1.0/02:00:00,M10.5.0/02:00:00";
    // nyc_string = "EST-05EDT,M4.1.0,M10.5.0"; // shorter when defaults used
    phx_string = "MST-07"; // no-dst
    time_zone_ptr nyc_2(new posix_time_zone(nyc_string));
    time_zone_ptr phx_2(new posix_time_zone(phx_string));
   

    /***** show the sets are equal *****/

    std::cout << "The first zone is in daylight savings from:\n " 
      << nyc_1->dst_local_start_time(2004) << " through "
      << nyc_1->dst_local_end_time(2004) << std::endl;

    std::cout << "The second zone is in daylight savings from:\n " 
      << nyc_2->dst_local_start_time(2004) << " through "
      << nyc_2->dst_local_end_time(2004) << std::endl;

    std::cout << "The third zone (no daylight savings):\n " 
      << phx_1->std_zone_abbrev() << " and "
      << phx_1->base_utc_offset() << std::endl;

    std::cout << "The fourth zone (no daylight savings):\n " 
      << phx_2->std_zone_abbrev() << " and "
      << phx_2->base_utc_offset() << std::endl;

    return 0;
  }
    
  

Daylight Savings Calc Rules

Example of creating various Daylight Savings Calc Rule objects.

    
  /* A simple example for creating various dst_calc_rule instances
   */

  #include "boost/date_time/gregorian/gregorian.hpp"
  #include "boost/date_time/local_time/local_time.hpp"
  #include <iostream>

  int
  main() 
  {
    using namespace boost;
    using namespace local_time;
    using namespace gregorian;

    /***** create the necessary date_generator objects *****/
    // starting generators
    first_day_of_the_week_in_month fd_start(Sunday, May);
    last_day_of_the_week_in_month ld_start(Sunday, May);
    nth_day_of_the_week_in_month nkd_start(nth_day_of_the_week_in_month::third, 
                                           Sunday, May);
    partial_date pd_start(1, May);
    // ending generators
    first_day_of_the_week_in_month fd_end(Sunday, Oct);
    last_day_of_the_week_in_month ld_end(Sunday, Oct);
    nth_day_of_the_week_in_month nkd_end(nth_day_of_the_week_in_month::third, 
                                         Sunday, Oct);
    partial_date pd_end(31, Oct);

    /***** create the various dst_calc_rule objects *****/
    dst_calc_rule_ptr pdr(new partial_date_dst_rule(pd_start, pd_end));
    dst_calc_rule_ptr flr(new first_last_dst_rule(fd_start, ld_end));
    dst_calc_rule_ptr llr(new last_last_dst_rule(ld_start, ld_end));
    dst_calc_rule_ptr nlr(new nth_last_dst_rule(nkd_start, ld_end));
    dst_calc_rule_ptr ndr(new nth_day_of_the_week_in_month_dst_rule(nkd_start, 
                                                                    nkd_end));

    return 0;
  }

    
  

Flight Time Example

This example shows a program that calculates the arrival time of a plane that flys from Phoenix to New York. During the flight New York shifts into daylight savings time (Phoenix doesn't because Arizona doesn't use dst).


#include "boost/date_time/local_time/local_time.hpp"
#include <iostream>

/* This example shows a program that calculates the arrival time of a plane
 * that flys from Phoenix to New York.  During the flight New York shifts
 * into daylight savings time (Phoenix doesn't because Arizona doesn't use
 * dst).  
 *
 * 
 */

int main()
{
  using namespace boost::gregorian; 
  using namespace boost::local_time;
  using namespace boost::posix_time;


  //setup some timezones for creating and adjusting local times
  //This user editable file can be found in libs/date_time/data.
  tz_database tz_db;
  tz_db.load_from_file("date_time_zonespec.csv");
  time_zone_ptr nyc_tz = tz_db.time_zone_from_region("America/New_York");
  //Use a 
  time_zone_ptr phx_tz(new posix_time_zone("MST-07:00:00"));

  //local departure time in phoenix is 11 pm on april 2 2005 
  // (ny changes to dst on apr 3 at 2 am)
  local_date_time phx_departure(date(2005, Apr, 2), hours(23), 
                                phx_tz, 
                                local_date_time::NOT_DATE_TIME_ON_ERROR);

  time_duration flight_length = hours(4) + minutes(30);
  local_date_time phx_arrival = phx_departure + flight_length;
  local_date_time nyc_arrival = phx_arrival.local_time_in(nyc_tz);

  std::cout << "departure phx time: " << phx_departure << std::endl;
  std::cout << "arrival phx time:   " << phx_arrival << std::endl;
  std::cout << "arrival nyc time:   " << nyc_arrival << std::endl;

}

Seconds Since Epoch

Example of calculating seconds elapsed since epoch (1970-Jan-1) using local_date_time.

    
  /* This example demonstrates the use of the time zone database and 
   * local time to calculate the number of seconds since the UTC
   * time_t epoch 1970-01-01 00:00:00.  Note that the selected timezone
   * could be any timezone supported in the time zone database file which
   * can be modified and updated as needed by the user.
   *
   * To solve this problem the following steps are required:
   * 1) Get a timezone from the tz database for the local time
   * 2) Construct a local time using the timezone
   * 3) Construct a posix_time::ptime for the time_t epoch time
   * 4) Convert the local_time to utc and subtract the epoch time
   * 
   */

  #include "boost/date_time/local_time/local_time.hpp"
  #include <iostream>

  int main()
  {
    using namespace boost::gregorian; 
    using namespace boost::local_time;
    using namespace boost::posix_time;
    
    tz_database tz_db;
    try {
      tz_db.load_from_file("../data/date_time_zonespec.csv");
    }catch(data_not_accessible dna) {
      std::cerr << "Error with time zone data file: " << dna.what() << std::endl;
      exit(EXIT_FAILURE);
    }catch(bad_field_count bfc) {
      std::cerr << "Error with time zone data file: " << bfc.what() << std::endl;
      exit(EXIT_FAILURE);
    }

    time_zone_ptr nyc_tz = tz_db.time_zone_from_region("America/New_York");
    date in_date(2004,10,04);
    time_duration td(12,14,32);
    // construct with local time value
    // create not-a-date-time if invalid (eg: in dst transition)
    local_date_time nyc_time(in_date, 
                             td, 
                             nyc_tz, 
                             local_date_time::NOT_DATE_TIME_ON_ERROR);

    std::cout << nyc_time << std::endl;

    ptime time_t_epoch(date(1970,1,1)); 
    std::cout << time_t_epoch << std::endl;

    // first convert nyc_time to utc via the utc_time() 
    // call and subtract the ptime.
    time_duration diff = nyc_time.utc_time() - time_t_epoch;

    //Expected 1096906472
    std::cout << "Seconds diff: " << diff.total_seconds() << std::endl;

  }
    
  

PrevUpHomeNext