自学教程：C++ time_duration函数代码示例

  inline  time_duration  parse_delimited_time_duration(const std::string& s)  {    unsigned short min=0, sec =0;    int hour =0;     bool is_neg = (s.at(0) == '-');    boost::int64_t fs=0;    int pos = 0;        char_separator<char> sep("-:,.");    tokenizer<char_separator<char> > tok(s,sep);    for(tokenizer<char_separator<char> >::iterator beg=tok.begin(); beg!=tok.end();++beg){      switch(pos) {      case 0: {        hour = boost::lexical_cast<int>(*beg);        break;      }      case 1: {        min = boost::lexical_cast<unsigned short>(*beg);        break;      }      case 2: {        sec = boost::lexical_cast<unsigned short>(*beg);        break;      };      case 3: {        //Works around a bug in MSVC 6 library that does not support        //operator>> thus meaning lexical_cast will fail to compile.#if (defined(BOOST_MSVC) && (_MSC_VER <= 1200))  // 1200 == VC++ 6.0        fs = _atoi64(beg->c_str());        // msvc wouldn't compile 'time_duration::num_fractional_digits()'         // (required template argument list) as a workaround a temp         // time_duration object was used        time_duration td(hour,min,sec,fs);        int precision = td.num_fractional_digits();#else        fs = boost::lexical_cast<boost::int64_t>(*beg);        int precision = time_duration::num_fractional_digits();#endif        int digits = beg->length();        if(digits < precision){          // leading zeros get dropped from the string,           // "1:01:01.1" would yield .000001 instead of .100000          // the power() compensates for the missing decimal places          fs *= power(10, precision - digits);         }                break;      }      }//switch      pos++;    }    if(is_neg) {      return -time_duration(hour, min, sec, fs);    }    else {      return time_duration(hour, min, sec, fs);    }  }

   // Jan 31 08:09:01 ...   boost::posix_time::ptime to_time( auth_time const& ai ) {      // year is current      string const& month = ai.mon;      string const& day = ai.day;      string const& time = ai.time;      vector<string> t = rlf_hstring::split( time, ':' );      if( t.size() != 3 ) { // wrong time format         throw runtime_error {"wrong time format/n"};      }      string const& hour = t[0];      string const& minute = t[1];      string const& second = t[2];      time_duration::hour_type hh = string2type<time_duration::hour_type>( hour );      time_duration::min_type mm = string2type<time_duration::min_type>( minute );;      time_duration::sec_type ss = string2type<time_duration::sec_type>( second );      date::month_type m = boost::date_time::month_str_to_ushort<date::month_type>( month  );;      date::day_type d = string2type<short unsigned int>( day );;      date::year_type y = day_clock::universal_day().year();      return boost::posix_time::ptime ( date( y, m, d ), time_duration( hh, mm, ss ) );   }

void RunSequence::HandleQuote2( const ou::tf::Quote& quote ) {  m_quote = quote;  ptime dt( quote.DateTime() );  std::cout << dt << " quote: B:" << quote.Bid() << "-A:" << quote.Ask() << std::endl;  static ptime mark( date( 2012, 7, 22 ), time_duration( 21, 7, 5, 368590 ) );  if ( quote.DateTime() == mark ) {    std::cout << dt << " quote " << std::endl;  }  if ( quote.IsValid() ) {    m_quotes.Append( quote );    switch ( m_stateTimeFrame ) {    case EPreOpen:      if ( m_dtOpeningBell <= dt ) {        m_stateTimeFrame = EBellHeard;      }      break;    case EBellHeard:      m_stateTimeFrame = EPauseForQuotes;      break;    case EPauseForQuotes:      if ( m_dtStartTrading <= dt ) {        m_stateTimeFrame = EAfterBell;      }      break;    case EAfterBell:      m_stateTimeFrame = ETrading;      break;    case ETrading:      if ( m_dtCancelTrades <= dt ) {        m_pPosition->CancelOrders();        m_stateTimeFrame = ECancelling;      }      else {        Trade();      }      break;    case ECancelling:      if ( m_dtClosePositions <= dt ) {        m_pPosition->ClosePosition();        m_stateTimeFrame = EClosing;      }      break;    case EGoingNeutral:      assert( false );      break;    case EClosing:      if ( m_dtClosingBell <= dt ) {        m_stateTimeFrame = EAfterHours;      }      break;    case EAfterHours:      break;    }  }}

		boost::posix_time::time_duration Service::GetTimeOfDay( const boost::posix_time::time_duration& value )		{			return				value >= DAY_DURATION ?				time_duration(value.hours() % 24, value.minutes(), value.seconds()) :				value			;		}

 inline time_duration parse_undelimited_time_duration(const std::string& s) {   int offsets[] = {2,2,2};   int pos = 0, sign = 0;   int hours = 0;   short min=0, sec=0;   // increment one position if the string was "signed"   if(s.at(sign) == '-')   {     ++sign;   }   // stlport choked when passing s.substr() to tokenizer   // using a new string fixed the error   std::string remain = s.substr(sign);   boost::offset_separator osf(offsets, offsets+3);    boost::tokenizer<boost::offset_separator> tok(remain, osf);   for(boost::tokenizer<boost::offset_separator>::iterator ti=tok.begin(); ti!=tok.end();++ti){     switch(pos) {     case 0:        {         hours = boost::lexical_cast<int>(*ti);          break;       }     case 1:        {         min = boost::lexical_cast<short>(*ti);          break;       }     case 2:       {        sec = boost::lexical_cast<short>(*ti);         break;       }     };     pos++;   }   if(sign) {     return -time_duration(hours, min, sec);   }   else {     return time_duration(hours, min, sec);   } }

void aggr_source_discovery::dump_cache(base_stream &out, const cache &c) const {	time_t now = time(0);	for (cache::const_iterator i = c.begin(); i != c.end(); ++i) {		out.xprintf("(%{Addr}, %{Addr}) for %{duration}/n",			    i->first.second, i->first.first,			    time_duration((now - i->second) * 1000));	}}

void PerformanceTimer::advance(const std::string& step){   BOOST_ASSERT(running());      // if there is an existing step pending then record its duration   recordPendingStep();      // record the start time and add a step   startTime_ = now();   steps_.push_back(std::make_pair(step, time_duration()));}

        TEST_F(DBTableTest, find_data_timestamp) {            std::string fieldName = "fieldName";            createTable(tableName, {"a timestamp"});            insertTable(tableName, "'2015-01-25 12:11:54.88'");            ptime expectedTime(date(2015, 1, 25), time_duration(12, 11, 54, 880000));            dbTable = std::make_shared<DBTable>(tableName);            auto row = dbTable->find("");            ASSERT_THAT(row->getValue("a"), IsAnyPosixTime(expectedTime));        }

RunSequence::RunSequence( const boost::gregorian::date& dateStart )   : m_portfolio( "test" ),      m_stateTimeFrame( EPreOpen ), m_stateTrading( ENeutral ),    m_timeOpeningBell( 19, 0, 0 ),    m_timeCancelTrades( 16, 40, 0 ),    m_timeClosePositions( 16, 45, 0 ),    m_timeClosingBell( 17, 0, 0 ),    m_dtOpeningBell( dateStart, m_timeOpeningBell ),    m_dtStartTrading( m_dtOpeningBell + time_duration( 0, 16, 0 ) ),    m_dtCancelTrades( dateStart + date_duration( 1 ), m_timeCancelTrades ),    m_dtClosePositions( dateStart + date_duration( 1 ), m_timeClosePositions ),    m_dtClosingBell( dateStart + date_duration( 1 ), m_timeClosingBell ){}

		boost::posix_time::time_duration DBResult::getHour( const std::string& name ) const		{			try			{				string text(getText(name));				if(!text.empty())				{					return duration_from_string(text);				}			}			catch(...)			{			}			return time_duration(not_a_date_time);		}

	inline time_duration operator*(int lhs, time_duration rhs)	{ return time_duration(boost::int64_t(lhs * rhs.diff)); }

Process::Process(void):  m_bIBConnected( false ), m_bIQFeedConnected( false ), m_bSimConnected( false ),  m_contractidUnderlying( 0 ),  m_bWatchingOptions( false ), m_bTrading( false ),  m_bPositionsOpened( false ),  m_dblBaseDelta( 2000.0 ), m_dblBaseDeltaIncrement( 100.0 ),  m_TradingState( ETSFirstPass ), #ifdef testing  m_sSymbolName( "DELL" ),   m_dtMarketOpen( time_duration( 0, 30, 0 ) ),  m_dtMarketOpeningOrder( time_duration( 0, 31, 0 ) ),  m_dtMarketClosingOrder( time_duration( 23, 56, 0 ) ),  m_dtMarketClose( time_duration( 23, 59, 59 ) ),#else  m_sSymbolName( "GLD" ),   m_dtMarketOpen( time_duration( 10, 30, 0 ) ),  m_dtMarketOpeningOrder( time_duration( 10, 30, 20 ) ),  m_dtMarketClosingOrder( time_duration( 16, 56, 0 ) ),  m_dtMarketClose( time_duration( 17, 0, 0 ) ),#endif  m_sPathForSeries( "/strategy/deltaneutral2" ),  m_sDesiredSimTradingDay( "2010-Sep-10 20:10:25.562500" ),  m_bProcessSimTradingDayGroup( false ),  m_tws( new IBTWS( "U215226" ) ), m_iqfeed( new IQFeedProvider() ), m_sim( new SimulationProvider() ),  m_eMode( EModeLive ),  //m_eMode( EModeSimulation )  m_bExecConnected( false ), m_bDataConnected( false ), m_bData2Connected( false ), m_bConnectDone( false ){  boost::gregorian::date dToday = ou::TimeSource::Instance().Internal().date();  m_dExpiry = ou::tf::options::Next3rdFriday( dToday );  while ( boost::gregorian::date_period( dToday, m_dExpiry ).length().days() < 8 ) { // some say use front month for scalping    boost::gregorian::date_duration dd( 1 );    boost::gregorian::date d = m_dExpiry + dd;    m_dExpiry = ou::tf::options::Next3rdFriday( d );  }  m_contract.currency = "USD";  m_contract.exchange = "SMART";  m_contract.symbol = m_sSymbolName;  // will need to use the expiry date to look at existing positions to see if a calendar spread is needed for rolling over  m_contract.expiry = boost::gregorian::to_iso_string( m_dExpiry );  m_db.SetOnPopulateDatabaseHandler( MakeDelegate( this, &Process::HandlePopulateDatabase ) );  m_idPortfolio = "dn01-" + m_sSymbolName + "-" + m_contract.expiry;  // needs to come before database open  // Implement the calendar roll over at some point  // this is where we select which provider we will be working with on this run  // providers need to be registered in order for portfolio/position loading to function properly  // key needs to match to account  ProviderManager::Instance().Register( "ib01", static_cast<pProvider_t>( m_tws ) );  ProviderManager::Instance().Register( "iq01", static_cast<pProvider_t>( m_iqfeed ) );  ProviderManager::Instance().Register( "sim01", static_cast<pProvider_t>( m_sim ) );  std::string sDbName;  switch ( m_eMode ) {    case EModeSimulation:      sDbName = ":memory:";      m_pExecutionProvider = m_sim;      m_pDataProvider = m_sim;      break;    case EModeLive:      sDbName = "TradeGldOptions.db";      m_pExecutionProvider = m_tws;      m_pDataProvider = m_tws;      break;  }  m_db.Open( sDbName );  m_pExecutionProvider->OnConnected.Add( MakeDelegate( this, &Process::HandleOnExecConnected ) );  m_pExecutionProvider->OnDisconnected.Add( MakeDelegate( this, &Process::HandleOnExecDisconnected ) );  m_pDataProvider->OnConnected.Add( MakeDelegate( this, &Process::HandleOnDataConnected ) );  m_pDataProvider->OnDisconnected.Add( MakeDelegate( this, &Process::HandleOnDataDisconnected ) );  m_iqfeed->OnConnected.Add( MakeDelegate( this, &Process::HandleOnData2Connected ) );  m_iqfeed->OnDisconnected.Add( MakeDelegate( this, &Process::HandleOnData2Disconnected ) );}

 //! Convert a tm struct to a ptime ignoring is_dst flag inline ptime ptime_from_tm(const std::tm& timetm) {   boost::gregorian::date d = boost::gregorian::date_from_tm(timetm);   return ptime(d, time_duration(timetm.tm_hour, timetm.tm_min, timetm.tm_sec)); }

 time_duration operator*(const double rhs) const {     return time_duration( boost::int64_t (diff * rhs) ); }

  inline  time_duration  parse_undelimited_time_duration(const std::string& s)  {    int precision = 0;    {      // msvc wouldn't compile 'time_duration::num_fractional_digits()'       // (required template argument list) as a workaround, a temp       // time_duration object was used      time_duration tmp(0,0,0,1);      precision = tmp.num_fractional_digits();    }    // 'precision+1' is so we grab all digits, plus the decimal    int offsets[] = {2,2,2, precision+1};    int pos = 0, sign = 0;    int hours = 0;    short min=0, sec=0;    boost::int64_t fs=0;    // increment one position if the string was "signed"    if(s.at(sign) == '-')    {      ++sign;    }    // stlport choked when passing s.substr() to tokenizer    // using a new string fixed the error    std::string remain = s.substr(sign);    /* We do not want the offset_separator to wrap the offsets, we      * will never want to  process more than:      * 2 char, 2 char, 2 char, frac_sec length.     * We *do* want the offset_separator to give us a partial for the     * last characters if there were not enough provided in the input string. */    bool wrap_off = false;    bool ret_part = true;    boost::offset_separator osf(offsets, offsets+4, wrap_off, ret_part);     typedef boost::tokenizer<boost::offset_separator,                             std::basic_string<char>::const_iterator,                             std::basic_string<char> > tokenizer;    typedef boost::tokenizer<boost::offset_separator,                             std::basic_string<char>::const_iterator,                             std::basic_string<char> >::iterator tokenizer_iterator;    tokenizer tok(remain, osf);    for(tokenizer_iterator ti=tok.begin(); ti!=tok.end();++ti){      switch(pos) {        case 0:           {            hours = boost::lexical_cast<int>(*ti);             break;          }        case 1:           {            min = boost::lexical_cast<short>(*ti);             break;          }        case 2:           {            sec = boost::lexical_cast<short>(*ti);             break;          }        case 3:          {            std::string char_digits(ti->substr(1)); // digits w/no decimal            int digits = static_cast<int>(char_digits.length());                        //Works around a bug in MSVC 6 library that does not support            //operator>> thus meaning lexical_cast will fail to compile.#if (defined(BOOST_MSVC) && (_MSC_VER <= 1200))  // 1200 == VC++ 6.0            // _atoi64 is an MS specific function            if(digits >= precision) {              // drop excess digits              fs = _atoi64(char_digits.substr(0, precision).c_str());            }            else if(digits == 0) {              fs = 0; // just in case _atoi64 doesn't like an empty string            }            else {              fs = _atoi64(char_digits.c_str());            }#else            if(digits >= precision) {              // drop excess digits              fs = boost::lexical_cast<boost::int64_t>(char_digits.substr(0, precision));            }            else if(digits == 0) {              fs = 0; // lexical_cast doesn't like empty strings            }            else {              fs = boost::lexical_cast<boost::int64_t>(char_digits);            }#endif            if(digits < precision){              // trailing zeros get dropped from the string,               // "1:01:01.1" would yield .000001 instead of .100000              // the power() compensates for the missing decimal places              fs *= power(10, precision - digits);             }                        break;          }          default: break;      };//.........这里部分代码省略.........

  inline  time_duration  str_from_delimited_time_duration(const std::basic_string<char_type>& s)  {    unsigned short min=0, sec =0;    int hour =0;     bool is_neg = (s.at(0) == '-');    boost::int64_t fs=0;    int pos = 0;          typedef typename std::basic_string<char_type>::traits_type traits_type;    typedef boost::char_separator<char_type, traits_type> char_separator_type;    typedef boost::tokenizer<char_separator_type,                             typename std::basic_string<char_type>::const_iterator,                             std::basic_string<char_type> > tokenizer;    typedef typename boost::tokenizer<char_separator_type,                             typename std::basic_string<char_type>::const_iterator,                             typename std::basic_string<char_type> >::iterator tokenizer_iterator;       char_type sep_chars[5] = {'-',':',',','.'};    char_separator_type sep(sep_chars);    tokenizer tok(s,sep);    for(tokenizer_iterator beg=tok.begin(); beg!=tok.end();++beg){      switch(pos) {      case 0: {        hour = boost::lexical_cast<int>(*beg);        break;      }      case 1: {        min = boost::lexical_cast<unsigned short>(*beg);        break;      }      case 2: {        sec = boost::lexical_cast<unsigned short>(*beg);        break;      };      case 3: {        int digits = static_cast<int>(beg->length());        //Works around a bug in MSVC 6 library that does not support        //operator>> thus meaning lexical_cast will fail to compile.#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))        // msvc wouldn't compile 'time_duration::num_fractional_digits()'         // (required template argument list) as a workaround a temp         // time_duration object was used        time_duration td(hour,min,sec,fs);        int precision = td.num_fractional_digits();        // _atoi64 is an MS specific function        if(digits >= precision) {          // drop excess digits          fs = _atoi64(beg->substr(0, precision).c_str());        }        else {          fs = _atoi64(beg->c_str());        }#else        int precision = time_duration::num_fractional_digits();        if(digits >= precision) {          // drop excess digits          fs = boost::lexical_cast<boost::int64_t>(beg->substr(0, precision));        }        else {          fs = boost::lexical_cast<boost::int64_t>(*beg);        }#endif        if(digits < precision){          // trailing zeros get dropped from the string,           // "1:01:01.1" would yield .000001 instead of .100000          // the power() compensates for the missing decimal places          fs *= power(10, precision - digits);         }                break;      }      default: break;      }//switch      pos++;    }    if(is_neg) {      return -time_duration(hour, min, sec, fs);    }    else {      return time_duration(hour, min, sec, fs);    }  }