#ifndef POSIXTIME_FORMATTERS_HPP___

#define POSIXTIME_FORMATTERS_HPP___



/* Copyright (c) 2002-2004 CrystalClear Software, Inc.

 * Use, modification and distribution is subject to the 

 * Boost Software License, Version 1.0. (See accompanying

 * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)

 * Author: Jeff Garland, Bart Garst

 * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $

 */



#include "boost/date_time/gregorian/gregorian.hpp"

#include "boost/date_time/compiler_config.hpp"

#include "boost/date_time/iso_format.hpp"

#include "boost/date_time/date_format_simple.hpp"

#include "boost/date_time/posix_time/posix_time_types.hpp"

#include "boost/date_time/time_formatting_streams.hpp"



#include "boost/date_time/time_parsing.hpp"



/* NOTE: The "to_*_string" code for older compilers, ones that define 

 * BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS, is located in 

 * formatters_limited.hpp

 */



namespace boost {



namespace posix_time {



  // template function called by wrapper functions:

  // to_*_string(time_duration) & to_*_wstring(time_duration)

  template<class charT>

  inline std::basic_string<charT> to_simple_string_type(time_duration td) {

    std::basic_ostringstream<charT> ss;

    if(td.is_special()) {

      /* simply using 'ss << td.get_rep()' won't work on compilers

       * that don't support locales. This way does. */

      // switch copied from date_names_put.hpp

      switch(td.get_rep().as_special())

      {

      case not_a_date_time:

        //ss << "not-a-number";

        ss << "not-a-date-time";

        break;

      case pos_infin:

        ss << "+infinity";

        break;

      case neg_infin:

        ss << "-infinity";

        break;

      default:

        ss << "";

      }

    }

    else {

      charT fill_char = '0';

      if(td.is_negative()) {

        ss << '-';

      }

      ss  << std::setw(2) << std::setfill(fill_char) 

          << date_time::absolute_value(td.hours()) << ":";

      ss  << std::setw(2) << std::setfill(fill_char) 

          << date_time::absolute_value(td.minutes()) << ":";

      ss  << std::setw(2) << std::setfill(fill_char) 

          << date_time::absolute_value(td.seconds());

      //TODO the following is totally non-generic, yelling FIXME

#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))

      boost::int64_t frac_sec = 

        date_time::absolute_value(td.fractional_seconds());

      // JDG [7/6/02 VC++ compatibility]

      charT buff[32];

      _i64toa(frac_sec, buff, 10);

#else

      time_duration::fractional_seconds_type frac_sec = 

        date_time::absolute_value(td.fractional_seconds());

#endif

      if (frac_sec != 0) {

        ss  << "." << std::setw(time_duration::num_fractional_digits())

            << std::setfill(fill_char)

          

          // JDG [7/6/02 VC++ compatibility]

#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))

            << buff;

#else

        << frac_sec;

#endif

      }

    }// else

    return ss.str();

  }

  //! Time duration to string -hh::mm::ss.fffffff. Example: 10:09:03.0123456

  /*!\ingroup time_format

   */

  inline std::string to_simple_string(time_duration td) {

    return to_simple_string_type<char>(td);

  }





  // template function called by wrapper functions:

  // to_*_string(time_duration) & to_*_wstring(time_duration)

  template<class charT>

  inline std::basic_string<charT> to_iso_string_type(time_duration td) 

  {

    std::basic_ostringstream<charT> ss;

    if(td.is_special()) {

      /* simply using 'ss << td.get_rep()' won't work on compilers

       * that don't support locales. This way does. */

      // switch copied from date_names_put.hpp

      switch(td.get_rep().as_special()) {

      case not_a_date_time:

        //ss << "not-a-number";

        ss << "not-a-date-time";

        break;

      case pos_infin:

        ss << "+infinity";

        break;

      case neg_infin:

        ss << "-infinity";

        break;

      default:

        ss << "";

      }

    }

    else {

      charT fill_char = '0';

      if(td.is_negative()) {

        ss << '-';

      }

      ss  << std::setw(2) << std::setfill(fill_char) 

          << date_time::absolute_value(td.hours());

      ss  << std::setw(2) << std::setfill(fill_char) 

          << date_time::absolute_value(td.minutes());

      ss  << std::setw(2) << std::setfill(fill_char) 

          << date_time::absolute_value(td.seconds());

      //TODO the following is totally non-generic, yelling FIXME

#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))

      boost::int64_t frac_sec = 

        date_time::absolute_value(td.fractional_seconds());

      // JDG [7/6/02 VC++ compatibility]

      charT buff[32];

      _i64toa(frac_sec, buff, 10);

#else

      time_duration::fractional_seconds_type frac_sec = 

        date_time::absolute_value(td.fractional_seconds());

#endif

      if (frac_sec != 0) {

        ss  << "." << std::setw(time_duration::num_fractional_digits())

            << std::setfill(fill_char)

          

          // JDG [7/6/02 VC++ compatibility]

#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))

            << buff;

#else

        << frac_sec;

#endif

      }

    }// else

    return ss.str();

  }

  //! Time duration in iso format -hhmmss,fffffff Example: 10:09:03,0123456

  /*!\ingroup time_format

   */

  inline std::string to_iso_string(time_duration td){

    return to_iso_string_type<char>(td);

  }



  //! Time to simple format CCYY-mmm-dd hh:mm:ss.fffffff

  /*!\ingroup time_format

   */

  template<class charT>

  inline std::basic_string<charT> to_simple_string_type(ptime t) 

  {

    // can't use this w/gcc295, no to_simple_string_type<>(td) available

    std::basic_string<charT> ts = gregorian::to_simple_string_type<charT>(t.date());// + " ";

    if(!t.time_of_day().is_special()) {

      charT space = ' ';

      return ts + space + to_simple_string_type<charT>(t.time_of_day());

    }

    else {

      return ts;

    }

  }

  inline std::string to_simple_string(ptime t){

    return to_simple_string_type<char>(t);

  }



  // function called by wrapper functions to_*_string(time_period) 

  // & to_*_wstring(time_period)

  template<class charT>

  inline std::basic_string<charT> to_simple_string_type(time_period tp) 

  {

    charT beg = '[', mid = '/', end = ']';

    std::basic_string<charT> d1(to_simple_string_type<charT>(tp.begin()));

    std::basic_string<charT> d2(to_simple_string_type<charT>(tp.last()));

    return std::basic_string<charT>(beg + d1 + mid + d2 + end);

  }

  //! Convert to string of form [YYYY-mmm-DD HH:MM::SS.ffffff/YYYY-mmm-DD HH:MM::SS.fffffff]

  /*!\ingroup time_format

   */

  inline std::string to_simple_string(time_period tp){

    return to_simple_string_type<char>(tp);

  }



  // function called by wrapper functions to_*_string(time_period) 

  // & to_*_wstring(time_period)

  template<class charT>

  inline std::basic_string<charT> to_iso_string_type(ptime t) 

  {

    std::basic_string<charT> ts = gregorian::to_iso_string_type<charT>(t.date());// + "T";

    if(!t.time_of_day().is_special()) {

      charT sep = 'T';

      return ts + sep + to_iso_string_type<charT>(t.time_of_day());

    }

    else {

      return ts;

    }

  }

  //! Convert iso short form YYYYMMDDTHHMMSS where T is the date-time separator

  /*!\ingroup time_format

   */

  inline std::string to_iso_string(ptime t){

    return to_iso_string_type<char>(t);

  }





  // function called by wrapper functions to_*_string(time_period) 

  // & to_*_wstring(time_period)

  template<class charT>

  inline std::basic_string<charT> to_iso_extended_string_type(ptime t) 

  {

    std::basic_string<charT> ts = gregorian::to_iso_extended_string_type<charT>(t.date());// + "T";

    if(!t.time_of_day().is_special()) {

      charT sep = 'T';

      return ts + sep + to_simple_string_type<charT>(t.time_of_day());

    }

    else {

      return ts;

    }

  }

  //! Convert to form YYYY-MM-DDTHH:MM:SS where T is the date-time separator

  /*!\ingroup time_format

   */

  inline std::string to_iso_extended_string(ptime t){

    return to_iso_extended_string_type<char>(t);

  }



#if !defined(BOOST_NO_STD_WSTRING)

  //! Time duration to wstring -hh::mm::ss.fffffff. Example: 10:09:03.0123456

  /*!\ingroup time_format

   */

  inline std::wstring to_simple_wstring(time_duration td) {

    return to_simple_string_type<wchar_t>(td);

  }

  //! Time duration in iso format -hhmmss,fffffff Example: 10:09:03,0123456

  /*!\ingroup time_format

   */

  inline std::wstring to_iso_wstring(time_duration td){

    return to_iso_string_type<wchar_t>(td);

  }

    inline std::wstring to_simple_wstring(ptime t){

    return to_simple_string_type<wchar_t>(t);

  }

  //! Convert to wstring of form [YYYY-mmm-DD HH:MM::SS.ffffff/YYYY-mmm-DD HH:MM::SS.fffffff]

  /*!\ingroup time_format

   */

  inline std::wstring to_simple_wstring(time_period tp){

    return to_simple_string_type<wchar_t>(tp);

  }

  //! Convert iso short form YYYYMMDDTHHMMSS where T is the date-time separator

  /*!\ingroup time_format

   */

  inline std::wstring to_iso_wstring(ptime t){

    return to_iso_string_type<wchar_t>(t);

  }

  //! Convert to form YYYY-MM-DDTHH:MM:SS where T is the date-time separator

  /*!\ingroup time_format

   */

  inline std::wstring to_iso_extended_wstring(ptime t){

    return to_iso_extended_string_type<wchar_t>(t);

  }



#endif // BOOST_NO_STD_WSTRING





} } //namespace posix_time





#endif



