blob: f0ff71c2984536b3595ad6c108716cc10b5eb7ed (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
#pragma once
#include "std/cstdint.hpp"
#include "std/initializer_list.hpp"
#include "std/shared_ptr.hpp"
#include "std/string.hpp"
#include "std/unordered_map.hpp"
#include "std/utility.hpp"
#include "std/vector.hpp"
class Classificator;
class FeatureType;
namespace feature { class TypesHolder; }
namespace routing
{
class IVehicleModel
{
public:
enum class RoadAvailability
{
NotAvailable,
Available,
Unknown,
};
virtual ~IVehicleModel() {}
/// @return Allowed speed in KMpH.
/// 0 means that it's forbidden to move on this feature or it's not a road at all.
virtual double GetSpeed(FeatureType const & f) const = 0;
/// @returns Max speed in KMpH for this model
virtual double GetMaxSpeed() const = 0;
virtual bool IsOneWay(FeatureType const & f) const = 0;
/// @returns true iff feature |f| can be used for routing with corresponding vehicle model.
virtual bool IsRoad(FeatureType const & f) const = 0;
};
class VehicleModelFactory
{
public:
virtual ~VehicleModelFactory() {}
/// @return Default vehicle model which corresponds for all countrines,
/// but it may be non optimal for some countries
virtual shared_ptr<IVehicleModel> GetVehicleModel() const = 0;
/// @return The most optimal vehicle model for specified country
virtual shared_ptr<IVehicleModel> GetVehicleModelForCountry(string const & country) const = 0;
};
class VehicleModel : public IVehicleModel
{
public:
struct SpeedForType
{
char const * m_types[2]; /// 2-arity road type
double m_speedKMpH; /// max allowed speed on this road type
};
typedef initializer_list<SpeedForType> InitListT;
VehicleModel(Classificator const & c, InitListT const & speedLimits);
/// IVehicleModel overrides:
double GetSpeed(FeatureType const & f) const override;
double GetMaxSpeed() const override { return m_maxSpeedKMpH; }
bool IsOneWay(FeatureType const & f) const override;
bool IsRoad(FeatureType const & f) const override;
public:
/// @returns true if |m_types| or |m_addRoadTypes| contains |type| and false otherwise.
bool IsRoadType(uint32_t type) const;
template <class TList>
bool HasRoadType(TList const & types) const
{
for (uint32_t t : types)
{
if (IsRoadType(t))
return true;
}
return false;
}
protected:
struct AdditionalRoadTags
{
initializer_list<char const *> m_hwtag;
double m_speedKMpH;
};
/// @returns a special restriction which is set to the feature.
virtual RoadAvailability GetRoadAvailability(feature::TypesHolder const & types) const;
/// Used in derived class constructors only. Not for public use.
void SetAdditionalRoadTypes(Classificator const & c,
vector<AdditionalRoadTags> const & additionalTags);
/// \returns true if |types| is a oneway feature.
/// \note According to OSM, tag "oneway" could have value "-1". That means it's a oneway feature
/// with reversed geometry. In that case at map generation the geometry of such features
/// is reversed (the order of points is changed) so in vehicle model all oneway feature
/// may be considered as features with forward geometry.
bool HasOneWayType(feature::TypesHolder const & types) const;
double GetMinTypeSpeed(feature::TypesHolder const & types) const;
double m_maxSpeedKMpH;
private:
struct AdditionalRoadType
{
AdditionalRoadType(Classificator const & c, AdditionalRoadTags const & tag);
bool operator==(AdditionalRoadType const & rhs) const { return m_type == rhs.m_type; }
uint32_t const m_type;
double const m_speedKMpH;
};
vector<AdditionalRoadType>::const_iterator FindRoadType(uint32_t type) const;
unordered_map<uint32_t, double> m_types;
vector<AdditionalRoadType> m_addRoadTypes;
uint32_t m_onewayType;
};
string DebugPrint(IVehicleModel::RoadAvailability const l);
} // namespace routing
|
