/*!\ingroup time_format
*/
inline
std::string to_iso_string(ptime t)
{
std::string ts = gregorian::to_iso_string(t.date());// + "T";
if(!t.time_of_day().is_special()) {
return ts + "T" + to_iso_string(t.time_of_day());
}
else {
return ts;
}
}
UTCTimestampsForLocalTime _boostTimezoneLocalPTimeToUTCTimestamps(
ptime local_pt,
time_zone_ptr tz
) {
UTCTimestampsForLocalTime res;
auto local_date = local_pt.date();
auto local_time = local_pt.time_of_day();
auto save_timestamp_if_valid = [&](bool is_dst, time_t *out) {
try {
auto local_dt = local_date_time(local_date, local_time, tz, is_dst);
// local_date_time() ignores is_dst if the timezone does not have
// DST (instead of throwing dst_not_valid). So, we must confirm
// that our is_dst guess was correct to avoid storing the same
// timestamp in both fields of res (same as problem (b) in the
// localtime_r code path).
if (local_dt.is_dst() == is_dst) {
*out = (local_dt.utc_time() - from_time_t(0)).total_seconds();
}
} catch (dst_not_valid& e) {
// Continue, we're trying both values of is_dst
}
};
try {
save_timestamp_if_valid(true, &res.dst_time);
save_timestamp_if_valid(false, &res.non_dst_time);
} catch (time_label_invalid& e) {
// This local time label was skipped by DST, so res will be empty.
}
return res;
}
time::time(ptime now_time)
{
gregorian::date now_d = now_time.date();
time_duration now_td = now_time.time_of_day();
time_duration td = time_duration(now_td.hours(), 0, 0);
_imp = ptime(now_d, td);
}
DSTRule::DSTRule (TZInfoIter info1, TZInfoIter info2,
ptime date1, ptime date2) :
to_std(date1.date()), to_dst(date2.date()),
to_std_time(date1.time_of_day()), to_dst_time(date2.time_of_day()),
std_info(info1), dst_info(info2)
{
if (info1->info.isdst == info2->info.isdst)
throw(std::invalid_argument("Both infos have the same dst value."));
if (info1->info.isdst && !info2->info.isdst)
{
std::swap(to_std, to_dst);
std::swap(to_std_time, to_dst_time);
std::swap(std_info, dst_info);
}
if (dst_info->isgmt)
to_dst_time += boost::posix_time::seconds(dst_info->info.gmtoff);
if (std_info->isgmt)
to_std_time += boost::posix_time::seconds(std_info->info.gmtoff);
}
int FlowRead::f(ptime time, int dt) {
boost::gregorian::date gd = time.date();
boost::posix_time::time_duration gt = time.time_of_day();
QDate qdate(gd.year(), gd.month(), gd.day());
QTime qtime(gt.hours(), gt.minutes(), gt.seconds());
QDateTime current(qdate, qtime);
ctxt.setOutPort(&out, current, dt);
return dt;
}
RtcDateTime MakeDateTime(ptime time, Meridiem period)
{
auto d = time.time_of_day();
auto hour = d.hours();
auto minute = d.minutes();
auto second = d.seconds();
auto mode = period == Meridiem::None
? ClockMode::MilitaryClock
: ClockMode::WallClock;
if (period != Meridiem::None)
{
if (hour == 0 && minute <= 59)
{
hour += 12;
}
else if (hour >= 13 && hour <= 23)
{
hour -= 12;
}
}
auto doy = byte(time.date().day_of_week());
auto mon = byte(time.date().month());
auto weekDay = pvt::ToDayOfWeek(doy);
auto month = pvt::ToMonth(mon);
auto day = int(time.date().day());
auto year = int(time.date().year());
printf("y: %d, m: %d, dy: %d, dt: %d, hh: %d, mm: %d, ss: %d\n",
year, mon, doy, day, hour, minute, second);
RtcDateTime result(RtcTime(period, hour, minute, second, mode),
day,
weekDay,
month,
year);
printf("rtc datetime: %s\n", result.AsString().c_str());
return result;
}
Time::Time(ptime t)
{
auto datePart = t.date();
auto timePart = t.time_of_day();
TimeScale timeScale = TimeScale::Master();
// consider date part only
auto d = datePart - date(1970, 1, 1);
int offsetFromEpochDays = d.days();
this->ticks_ = timeScale.TicksPerDay() * offsetFromEpochDays;
// add ticks for time of day
if(time_duration::ticks_per_second() > timeScale.TicksPerSecond()) // since the following computations are integer calculcations, we distinguish here
{
int64 conversionRate = time_duration::ticks_per_second() / timeScale.TicksPerSecond();
this->ticks_ += timePart.ticks() / conversionRate;
}
else
{
int64 conversionRate = timeScale.TicksPerSecond() / time_duration::ticks_per_second();
this->ticks_ += timePart.ticks() * conversionRate;
}
}
static std::string str (const ptime& start, const ptime& end) {
boost::posix_time::time_duration td(start.time_of_day());
return boost::posix_time::to_iso_string(ptime(start.date(), boost::posix_time::time_duration(td.hours(), td.minutes(), td.seconds())));
}
static std::string str (const ptime& start, const ptime& end) {
return boost::posix_time::to_iso_string(ptime(start.date(), boost::posix_time::time_duration(start.time_of_day().hours(), 0, 0)));
}
static std::string str (const ptime& start, const ptime& end) {
boost::posix_time::time_duration td(start.time_of_day());
return boost::posix_time::to_iso_string(start - boost::posix_time::time_duration(0,0,0,td.fractional_seconds() % 1000));
}
ServicePointer Edge::getPreviousService(const AccessParameters& accessParameters,
ptime arrivalMoment,
const ptime& minArrivalMoment,
bool checkIfTheServiceIsReachable,
optional<ArrivalServiceIndex::Value>& maxPreviousServiceIndex,
bool inverted,
bool ignoreReservation,
bool allowCanceled,
bool enableTheoretical,
bool enableRealTime
) const {
boost::shared_lock<util::shared_recursive_mutex> sharedServicesLock(
*getParentPath()->sharedServicesMutex
);
const ServiceSet& services(getParentPath()->getServices());
if(services.empty())
{
return ServicePointer();
}
bool RTData(enableRealTime && arrivalMoment < posix_time::second_clock().local_time() + posix_time::hours(23));
ArrivalServiceIndex::Value previous(getArrivalFromIndex(RTData, arrivalMoment.time_of_day().hours()));
if( maxPreviousServiceIndex &&
(*maxPreviousServiceIndex == services.rend() || services.value_comp()(**maxPreviousServiceIndex, *previous))
){
previous = *maxPreviousServiceIndex;
}
while ( arrivalMoment >= minArrivalMoment ) // Loop over dates
{
if( getParentPath()->isActive(arrivalMoment.date()))
{
for (; previous != services.rend(); ++previous) // Loop over services
{
// Saving of the used service
ServicePointer servicePointer(
(*previous)->getFromPresenceTime(
accessParameters,
enableTheoretical,
RTData,
false,
*this,
arrivalMoment,
checkIfTheServiceIsReachable,
inverted,
ignoreReservation,
allowCanceled
)
);
if (!servicePointer.getService())
continue;
// Check of validity of departure date time
if (servicePointer.getArrivalDateTime() + servicePointer.getServiceRange() < minArrivalMoment)
{
return ServicePointer();
}
// Limitation of the continuous service range at the specified bounds
if(servicePointer.getArrivalDateTime() < minArrivalMoment)
{
time_duration toShift(minArrivalMoment - servicePointer.getArrivalDateTime());
servicePointer.shift(toShift);
servicePointer.setServiceRange(servicePointer.getServiceRange() - toShift);
}
// Store service rank in edge
maxPreviousServiceIndex = previous;
// The service is now returned
return servicePointer;
} }
arrivalMoment = ptime(arrivalMoment.date(), -seconds(1));
previous = _arrivalIndex[INDICES_NUMBER - 1].get(RTData);
}
return ServicePointer();
}
ServicePointer Edge::getNextService(const AccessParameters& accessParameters,
ptime departureMoment,
const ptime& maxDepartureMoment,
bool checkIfTheServiceIsReachable,
optional<DepartureServiceIndex::Value>& minNextServiceIndex,
bool inverted,
bool ignoreReservation,
bool allowCanceled,
bool enableTheoretical,
bool enableRealTime
) const {
boost::shared_lock<util::shared_recursive_mutex> sharedServicesLock(
*getParentPath()->sharedServicesMutex
);
const ServiceSet& services(getParentPath()->getServices());
if(services.empty() || (!enableTheoretical && !enableRealTime))
{
return ServicePointer();
}
bool RTData(enableRealTime && departureMoment < posix_time::second_clock().local_time() + posix_time::hours(23));
// Search schedule
DepartureServiceIndex::Value next(getDepartureFromIndex(RTData, departureMoment.time_of_day().hours()));
if( minNextServiceIndex &&
(*minNextServiceIndex == services.end() || services.value_comp()(*next, **minNextServiceIndex))
){
next = *minNextServiceIndex;
}
while ( departureMoment <= maxDepartureMoment ) // boucle sur les dates
{
// Look in schedule for when the line is in service
if( getParentPath()->isActive(departureMoment.date()))
{
for (; next != services.end(); ++next) // boucle sur les services
{
// Saving of the used service
ServicePointer servicePointer(
(*next)->getFromPresenceTime(
accessParameters,
enableTheoretical,
RTData,
true,
*this,
departureMoment,
checkIfTheServiceIsReachable,
inverted,
ignoreReservation,
allowCanceled
)
);
if (!servicePointer.getService())
continue;
// Check of validity of departure date time
if (servicePointer.getDepartureDateTime() > maxDepartureMoment )
{
return ServicePointer();
}
// Limitation of the continuous service range at the specified bounds
if(servicePointer.getDepartureDateTime() + servicePointer.getServiceRange() > maxDepartureMoment)
{
servicePointer.setServiceRange(maxDepartureMoment - servicePointer.getDepartureDateTime());
}
// Store the service rank in edge
minNextServiceIndex = next;
// The service is now returned
return servicePointer;
} }
if (departureMoment.time_of_day().hours() < 3)
departureMoment = ptime(departureMoment.date(), hours(3));
else
departureMoment = ptime(departureMoment.date(), hours(27));
next = _departureIndex[0].get(RTData);
}
return ServicePointer();
}
void ParametersMap::insert(
const std::string& parameterName,
const ptime& value
){
insert(parameterName, value.is_not_a_date_time() ? string() : to_iso_extended_string(value.date()) + " " + to_simple_string(value.time_of_day()));
}
