116 lines
3.0 KiB
C++
116 lines
3.0 KiB
C++
#ifndef RESTRICTION_HPP
|
|
#define RESTRICTION_HPP
|
|
|
|
#include "util/typedefs.hpp"
|
|
|
|
#include <limits>
|
|
|
|
namespace osrm
|
|
{
|
|
namespace extractor
|
|
{
|
|
|
|
struct TurnRestriction
|
|
{
|
|
union WayOrNode
|
|
{
|
|
OSMNodeID_weak node;
|
|
OSMEdgeID_weak way;
|
|
};
|
|
WayOrNode via;
|
|
WayOrNode from;
|
|
WayOrNode to;
|
|
|
|
struct Bits
|
|
{ // mostly unused
|
|
Bits()
|
|
: is_only(false), uses_via_way(false), unused2(false), unused3(false), unused4(false),
|
|
unused5(false), unused6(false), unused7(false)
|
|
{
|
|
}
|
|
|
|
bool is_only : 1;
|
|
bool uses_via_way : 1;
|
|
bool unused2 : 1;
|
|
bool unused3 : 1;
|
|
bool unused4 : 1;
|
|
bool unused5 : 1;
|
|
bool unused6 : 1;
|
|
bool unused7 : 1;
|
|
} flags;
|
|
|
|
explicit TurnRestriction(NodeID node)
|
|
{
|
|
via.node = node;
|
|
from.node = SPECIAL_NODEID;
|
|
to.node = SPECIAL_NODEID;
|
|
}
|
|
|
|
explicit TurnRestriction(const bool is_only = false)
|
|
{
|
|
via.node = SPECIAL_NODEID;
|
|
from.node = SPECIAL_NODEID;
|
|
to.node = SPECIAL_NODEID;
|
|
flags.is_only = is_only;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This is just a wrapper around TurnRestriction used in the extractor.
|
|
*
|
|
* Could be merged with TurnRestriction. For now the type-destiction makes sense
|
|
* as the format in which the restriction is presented in the extractor and in the
|
|
* preprocessing is different. (see restriction_parser.cpp)
|
|
*/
|
|
struct InputRestrictionContainer
|
|
{
|
|
TurnRestriction restriction;
|
|
|
|
InputRestrictionContainer(EdgeID fromWay, EdgeID toWay, EdgeID vw)
|
|
{
|
|
restriction.from.way = fromWay;
|
|
restriction.to.way = toWay;
|
|
restriction.via.way = vw;
|
|
}
|
|
explicit InputRestrictionContainer(bool is_only = false)
|
|
{
|
|
restriction.from.way = SPECIAL_EDGEID;
|
|
restriction.to.way = SPECIAL_EDGEID;
|
|
restriction.via.node = SPECIAL_NODEID;
|
|
restriction.flags.is_only = is_only;
|
|
}
|
|
|
|
static InputRestrictionContainer min_value() { return InputRestrictionContainer(0, 0, 0); }
|
|
static InputRestrictionContainer max_value()
|
|
{
|
|
return InputRestrictionContainer(SPECIAL_EDGEID, SPECIAL_EDGEID, SPECIAL_EDGEID);
|
|
}
|
|
};
|
|
|
|
struct CmpRestrictionContainerByFrom
|
|
{
|
|
using value_type = InputRestrictionContainer;
|
|
bool operator()(const InputRestrictionContainer &a, const InputRestrictionContainer &b) const
|
|
{
|
|
return a.restriction.from.way < b.restriction.from.way;
|
|
}
|
|
value_type max_value() const { return InputRestrictionContainer::max_value(); }
|
|
value_type min_value() const { return InputRestrictionContainer::min_value(); }
|
|
};
|
|
|
|
struct CmpRestrictionContainerByTo
|
|
{
|
|
using value_type = InputRestrictionContainer;
|
|
bool operator()(const InputRestrictionContainer &a, const InputRestrictionContainer &b) const
|
|
{
|
|
return a.restriction.to.way < b.restriction.to.way;
|
|
}
|
|
value_type max_value() const { return InputRestrictionContainer::max_value(); }
|
|
value_type min_value() const { return InputRestrictionContainer::min_value(); }
|
|
};
|
|
|
|
}
|
|
}
|
|
|
|
#endif // RESTRICTION_HPP
|