ServicePointer Application::get_service_pointer(const std::string& name) const
{
auto it = services_map_.find(name);
if(it != services_map_.end())
{
return it->second;
}
return ServicePointer();
}
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();
}
