From 340673070024e4c3b4d0016e180ac7b8ca1d2226 Mon Sep 17 00:00:00 2001 From: Maxim Pimenov Date: Fri, 28 Apr 2017 16:19:24 +0300 Subject: [PATCH] [routing] Get road access by vehicle type; masks are for serialization only. --- .../generator_tests/road_access_test.cpp | 54 ++++++------- generator/road_access_generator.cpp | 81 +++++++------------ generator/road_access_generator.hpp | 15 ++-- routing/CMakeLists.txt | 1 + routing/road_access.cpp | 52 +++--------- routing/road_access.hpp | 20 +++-- routing/road_access_serialization.hpp | 30 +++---- routing/routing.pro | 1 + routing/routing_tests/road_access_test.cpp | 21 +++-- routing/vehicle_mask.hpp | 36 +-------- 10 files changed, 107 insertions(+), 204 deletions(-) diff --git a/generator/generator_tests/road_access_test.cpp b/generator/generator_tests/road_access_test.cpp index 54f0a83eaf..e1bbf332ff 100644 --- a/generator/generator_tests/road_access_test.cpp +++ b/generator/generator_tests/road_access_test.cpp @@ -59,7 +59,7 @@ void BuildTestMwmWithRoads(LocalCountryFile & country) } } -void LoadRoadAccess(string const & mwmFilePath, VehicleMask vehicleMask, RoadAccess & roadAccess) +void LoadRoadAccess(string const & mwmFilePath, VehicleType vehicleType, RoadAccess & roadAccess) { FilesContainerR const cont(mwmFilePath); TEST(cont.IsExist(ROAD_ACCESS_FILE_TAG), ()); @@ -69,7 +69,7 @@ void LoadRoadAccess(string const & mwmFilePath, VehicleMask vehicleMask, RoadAcc FilesContainerR::TReader const reader = cont.GetReader(ROAD_ACCESS_FILE_TAG); ReaderSource src(reader); - RoadAccessSerializer::Deserialize(src, vehicleMask, roadAccess); + RoadAccessSerializer::Deserialize(src, vehicleType, roadAccess); } catch (Reader::OpenException const & e) { @@ -78,8 +78,8 @@ void LoadRoadAccess(string const & mwmFilePath, VehicleMask vehicleMask, RoadAcc } // todo(@m) This helper function is almost identical to the one in restriction_test.cpp. -map SaveAndLoadRoadAccess(string const & roadAccessContent, - string const & mappingContent) +RoadAccessCollector::RoadAccessByVehicleType SaveAndLoadRoadAccess(string const & roadAccessContent, + string const & mappingContent) { classificator::Load(); @@ -110,17 +110,16 @@ map SaveAndLoadRoadAccess(string const & roadAccessCont BuildRoadAccessInfo(mwmFullPath, roadAccessFullPath, mappingFullPath); // Reading from mwm section and testing road access. - map roadAccessByMaskFromMwm; - for (auto const vehicleMask : RoadAccess::GetSupportedVehicleMasks()) + RoadAccessCollector::RoadAccessByVehicleType roadAccessFromMwm; + for (size_t i = 0; i < static_cast(VehicleType::Count); ++i) { - RoadAccess roadAccess; - LoadRoadAccess(mwmFullPath, vehicleMask, roadAccess); - roadAccessByMaskFromMwm.emplace(vehicleMask, roadAccess); + auto const vehicleType = static_cast(i); + LoadRoadAccess(mwmFullPath, vehicleType, roadAccessFromMwm[i]); } RoadAccessCollector const collector(mwmFullPath, roadAccessFullPath, mappingFullPath); TEST(collector.IsValid(), ()); - TEST_EQUAL(roadAccessByMaskFromMwm, collector.GetRoadAccessByMask(), ()); - return roadAccessByMaskFromMwm; + TEST_EQUAL(roadAccessFromMwm, collector.GetRoadAccessAllTypes(), ()); + return roadAccessFromMwm; } UNIT_TEST(RoadAccess_Smoke) @@ -134,14 +133,13 @@ UNIT_TEST(RoadAccess_AccessPrivate) { string const roadAccessContent = R"(Car Private 0)"; string const osmIdsToFeatureIdsContent = R"(0, 0,)"; - auto const roadAccessByMask = SaveAndLoadRoadAccess(roadAccessContent, osmIdsToFeatureIdsContent); - auto const carIt = roadAccessByMask.find(kCarMask); - TEST(carIt != roadAccessByMask.end(), ()); - auto const carRoadAccess = carIt->second; - TEST_EQUAL(carRoadAccess.GetType(Segment(0, 0, 0, false)), RoadAccess::Type::Private, ()); + auto const roadAccessAllTypes = + SaveAndLoadRoadAccess(roadAccessContent, osmIdsToFeatureIdsContent); + auto const carRoadAccess = roadAccessAllTypes[static_cast(VehicleType::Car)]; + TEST_EQUAL(carRoadAccess.GetSegmentType(Segment(0, 0, 0, false)), RoadAccess::Type::Private, ()); } -UNIT_TEST(RoadAccess_Access_Multiple_Vehicle_Masks) +UNIT_TEST(RoadAccess_Access_Multiple_Vehicle_Types) { string const roadAccessContent = R"(Car Private 10 Car Private 20 @@ -151,17 +149,15 @@ UNIT_TEST(RoadAccess_Access_Multiple_Vehicle_Masks) 20, 2, 30, 3, 40, 4,)"; - auto const roadAccessByMask = SaveAndLoadRoadAccess(roadAccessContent, osmIdsToFeatureIdsContent); - auto const carIt = roadAccessByMask.find(kCarMask); - TEST(carIt != roadAccessByMask.end(), ()); - auto const carRoadAccess = carIt->second; - auto const bicycleIt = roadAccessByMask.find(kBicycleMask); - TEST(bicycleIt != roadAccessByMask.end(), ()); - auto const bicycleRoadAccess = bicycleIt->second; - TEST_EQUAL(carRoadAccess.GetType(Segment(0, 1, 0, false)), RoadAccess::Type::Private, ()); - TEST_EQUAL(carRoadAccess.GetType(Segment(0, 2, 2, true)), RoadAccess::Type::Private, ()); - TEST_EQUAL(carRoadAccess.GetType(Segment(0, 3, 1, true)), RoadAccess::Type::Yes, ()); - TEST_EQUAL(carRoadAccess.GetType(Segment(0, 4, 3, false)), RoadAccess::Type::Destination, ()); - TEST_EQUAL(bicycleRoadAccess.GetType(Segment(0, 3, 0, false)), RoadAccess::Type::No, ()); + auto const roadAccessAllTypes = + SaveAndLoadRoadAccess(roadAccessContent, osmIdsToFeatureIdsContent); + auto const carRoadAccess = roadAccessAllTypes[static_cast(VehicleType::Car)]; + auto const bicycleRoadAccess = roadAccessAllTypes[static_cast(VehicleType::Bicycle)]; + TEST_EQUAL(carRoadAccess.GetSegmentType(Segment(0, 1, 0, false)), RoadAccess::Type::Private, ()); + TEST_EQUAL(carRoadAccess.GetSegmentType(Segment(0, 2, 2, true)), RoadAccess::Type::Private, ()); + TEST_EQUAL(carRoadAccess.GetSegmentType(Segment(0, 3, 1, true)), RoadAccess::Type::Yes, ()); + TEST_EQUAL(carRoadAccess.GetSegmentType(Segment(0, 4, 3, false)), RoadAccess::Type::Destination, + ()); + TEST_EQUAL(bicycleRoadAccess.GetSegmentType(Segment(0, 3, 0, false)), RoadAccess::Type::No, ()); } } // namespace diff --git a/generator/road_access_generator.cpp b/generator/road_access_generator.cpp index 9898670a69..d53d9df26d 100644 --- a/generator/road_access_generator.cpp +++ b/generator/road_access_generator.cpp @@ -55,33 +55,9 @@ TagMapping const kBicycleTagMapping = { {OsmElement::Tag("bicycle", "no"), RoadAccess::Type::No}, }; -VehicleMask ReadVehicleMaskFromString(string const & s) -{ - if (s == kCar) - return kCarMask; - if (s == kPedestrian) - return kPedestrianMask; - if (s == kBicycle) - return kBicycleMask; - LOG(LERROR, ("Could not read vehicle mask from the string", s)); - return kAllVehiclesMask; -} - -string WriteVehicleMaskToString(VehicleMask vehicleMask) -{ - if (vehicleMask == kCarMask) - return kCar; - if (vehicleMask == kPedestrianMask) - return kPedestrian; - if (vehicleMask == kBicycleMask) - return kBicycle; - LOG(LERROR, ("Unsupported vehicle mask", vehicleMask)); - return "Unsupported VehicleMask"; -} - bool ParseRoadAccess(string const & roadAccessPath, map const & osmIdToFeatureId, FeaturesVector const & featuresVector, - map & roadAccessByMask) + RoadAccessCollector::RoadAccessByVehicleType & roadAccessByVehicleType) { ifstream stream(roadAccessPath); if (!stream) @@ -92,11 +68,11 @@ bool ParseRoadAccess(string const & roadAccessPath, map const vector privateRoads; - map> segmentType; + map> segmentType; - auto addSegment = [&](Segment const & segment, VehicleMask vehicleMask, + auto addSegment = [&](Segment const & segment, VehicleType vehicleType, RoadAccess::Type roadAccessType, uint64_t osmId) { - auto & m = segmentType[vehicleMask]; + auto & m = segmentType[vehicleType]; auto const emplaceRes = m.emplace(segment, roadAccessType); if (!emplaceRes.second) LOG(LWARNING, ("duplicate road access info for", osmId)); @@ -115,7 +91,8 @@ bool ParseRoadAccess(string const & roadAccessPath, map const LOG(LERROR, ("Error when parsing road access: empty line", lineNo)); return false; } - VehicleMask const vehicleMask = ReadVehicleMaskFromString(*iter); + VehicleType vehicleType; + FromString(*iter, vehicleType); ++iter; if (!iter) @@ -156,19 +133,17 @@ bool ParseRoadAccess(string const & roadAccessPath, map const // Set this road access type for the entire feature. for (uint32_t segmentIdx = 0; segmentIdx < numSegments; ++segmentIdx) { - addSegment(Segment(kFakeNumMwmId, featureId, segmentIdx, true /* isForward */), vehicleMask, + addSegment(Segment(kFakeNumMwmId, featureId, segmentIdx, true /* isForward */), vehicleType, roadAccessType, osmId); - addSegment(Segment(kFakeNumMwmId, featureId, segmentIdx, false /* isForward */), vehicleMask, + addSegment(Segment(kFakeNumMwmId, featureId, segmentIdx, false /* isForward */), vehicleType, roadAccessType, osmId); } } - roadAccessByMask.clear(); - for (auto const vehicleMask : RoadAccess::GetSupportedVehicleMasks()) + for (size_t i = 0; i < static_cast(VehicleType::Count); ++i) { - RoadAccess roadAccess; - roadAccess.SetTypes(segmentType[vehicleMask]); - roadAccessByMask.emplace(vehicleMask, roadAccess); + auto const vehicleType = static_cast(i); + roadAccessByVehicleType[i].SetTypes(segmentType[vehicleType]); } return true; @@ -178,17 +153,16 @@ bool ParseRoadAccess(string const & roadAccessPath, map const namespace routing { // RoadAccessTagProcessor -------------------------------------------------------------------------- -RoadAccessTagProcessor::RoadAccessTagProcessor(VehicleMask vehicleMask) - : m_vehicleMask(vehicleMask), m_tagMapping(nullptr) +RoadAccessTagProcessor::RoadAccessTagProcessor(VehicleType vehicleType) + : m_vehicleType(vehicleType), m_tagMapping(nullptr) { - if (vehicleMask == kCarMask) - m_tagMapping = &kCarTagMapping; - else if (vehicleMask == kPedestrianMask) - m_tagMapping = &kPedestrianTagMapping; - else if (vehicleMask == kBicycleMask) - m_tagMapping = &kBicycleTagMapping; - else - CHECK(false, ("Road access info is not supported for this vehicle mask", vehicleMask)); + switch (vehicleType) + { + case VehicleType::Car: m_tagMapping = &kCarTagMapping; + case VehicleType::Pedestrian: m_tagMapping = &kPedestrianTagMapping; + case VehicleType::Bicycle: m_tagMapping = &kBicycleTagMapping; + case VehicleType::Count: CHECK(false, ("Bad vehicle type")); + } } void RoadAccessTagProcessor::Process(OsmElement const & elem, ofstream & oss) const @@ -202,16 +176,15 @@ void RoadAccessTagProcessor::Process(OsmElement const & elem, ofstream & oss) co auto const it = m_tagMapping->find(tag); if (it == m_tagMapping->cend()) continue; - oss << WriteVehicleMaskToString(m_vehicleMask) << " " << ToString(it->second) << " " << elem.id - << endl; + oss << ToString(m_vehicleType) << " " << ToString(it->second) << " " << elem.id << endl; } } // RoadAccessWriter ------------------------------------------------------------ RoadAccessWriter::RoadAccessWriter() { - for (auto const vehicleMask : RoadAccess::GetSupportedVehicleMasks()) - m_tagProcessors.emplace_back(vehicleMask); + for (size_t i = 0; i < static_cast(VehicleType::Count); ++i) + m_tagProcessors.emplace_back(static_cast(i)); } void RoadAccessWriter::Open(string const & filePath) @@ -253,9 +226,9 @@ RoadAccessCollector::RoadAccessCollector(string const & dataFilePath, string con FeaturesVectorTest featuresVector(dataFilePath); - map roadAccessByMask; + RoadAccessCollector::RoadAccessByVehicleType roadAccessByVehicleType; if (!ParseRoadAccess(roadAccessPath, osmIdToFeatureId, featuresVector.GetVector(), - roadAccessByMask)) + roadAccessByVehicleType)) { LOG(LWARNING, ("An error happened while parsing road access from file:", roadAccessPath)); m_valid = false; @@ -263,7 +236,7 @@ RoadAccessCollector::RoadAccessCollector(string const & dataFilePath, string con } m_valid = true; - m_roadAccessByMask.swap(roadAccessByMask); + m_roadAccessByVehicleType.swap(roadAccessByVehicleType); } // Functions ------------------------------------------------------------------ @@ -283,6 +256,6 @@ void BuildRoadAccessInfo(string const & dataFilePath, string const & roadAccessP FilesContainerW cont(dataFilePath, FileWriter::OP_WRITE_EXISTING); FileWriter writer = cont.GetWriter(ROAD_ACCESS_FILE_TAG); - RoadAccessSerializer::Serialize(writer, collector.GetRoadAccessByMask()); + RoadAccessSerializer::Serialize(writer, collector.GetRoadAccessAllTypes()); } } // namespace routing diff --git a/generator/road_access_generator.hpp b/generator/road_access_generator.hpp index 66d915ce13..f50ef7d89d 100644 --- a/generator/road_access_generator.hpp +++ b/generator/road_access_generator.hpp @@ -6,6 +6,7 @@ #include "routing/road_access.hpp" #include "routing/vehicle_mask.hpp" +#include #include #include #include @@ -24,14 +25,14 @@ namespace routing class RoadAccessTagProcessor { public: - using TagMapping = map; + using TagMapping = std::map; - explicit RoadAccessTagProcessor(VehicleMask vehicleMask); + explicit RoadAccessTagProcessor(VehicleType vehicleType); void Process(OsmElement const & elem, std::ofstream & oss) const; private: - VehicleMask m_vehicleMask; + VehicleType m_vehicleType; TagMapping const * m_tagMapping; }; @@ -54,18 +55,20 @@ private: class RoadAccessCollector { public: + using RoadAccessByVehicleType = std::array(VehicleType::Count)>; + RoadAccessCollector(std::string const & dataFilePath, std::string const & roadAccessPath, std::string const & osmIdsToFeatureIdsPath); - std::map const & GetRoadAccessByMask() const + RoadAccessByVehicleType const & GetRoadAccessAllTypes() const { - return m_roadAccessByMask; + return m_roadAccessByVehicleType; } bool IsValid() const { return m_valid; } private: - std::map m_roadAccessByMask; + RoadAccessByVehicleType m_roadAccessByVehicleType; bool m_valid = true; }; diff --git a/routing/CMakeLists.txt b/routing/CMakeLists.txt index c3f6573461..b4a10ef9e2 100644 --- a/routing/CMakeLists.txt +++ b/routing/CMakeLists.txt @@ -127,6 +127,7 @@ set( turns_sound_settings.hpp turns_tts_text.cpp turns_tts_text.hpp + vehicle_mask.cpp vehicle_mask.hpp world_graph.cpp world_graph.hpp diff --git a/routing/road_access.cpp b/routing/road_access.cpp index 0f0768fc8c..4ab67c5494 100644 --- a/routing/road_access.cpp +++ b/routing/road_access.cpp @@ -10,62 +10,28 @@ using namespace std; namespace { string const kNames[] = {"No", "Private", "Destination", "Yes", "Count"}; - -// *NOTE* Order may be important for users (such as serializers). -// Add new types to the end of the list. -vector const kSupportedVehicleMasks = { - routing::kPedestrianMask, - routing::kBicycleMask, - routing::kCarMask, -}; } // namespace namespace routing { // RoadAccess -------------------------------------------------------------------------------------- -RoadAccess::RoadAccess() : m_vehicleMask(kAllVehiclesMask) {} +RoadAccess::RoadAccess() : m_vehicleType(VehicleType::Count) {} -RoadAccess::RoadAccess(VehicleMask vehicleMask) : m_vehicleMask(vehicleMask) -{ - CHECK(IsSupportedVehicleMask(vehicleMask), ()); -} +RoadAccess::RoadAccess(VehicleType vehicleType) : m_vehicleType(vehicleType) {} -// static -vector const & RoadAccess::GetSupportedVehicleMasks() -{ - return kSupportedVehicleMasks; -} - -// static -bool RoadAccess::IsSupportedVehicleMask(VehicleMask vehicleMask) -{ - return find(kSupportedVehicleMasks.begin(), kSupportedVehicleMasks.end(), vehicleMask) != - kSupportedVehicleMasks.end(); -} - -RoadAccess::Type const RoadAccess::GetType(Segment const & segment) const +RoadAccess::Type const RoadAccess::GetSegmentType(Segment const & segment) const { Segment key(kFakeNumMwmId, segment.GetFeatureId(), segment.GetSegmentIdx(), segment.IsForward()); - auto const it = m_types.find(key); - if (it != m_types.end()) + auto const it = m_segmentTypes.find(key); + if (it != m_segmentTypes.end()) return it->second; return RoadAccess::Type::Yes; } -void RoadAccess::Clear() -{ - m_types.clear(); -} - -void RoadAccess::Swap(RoadAccess & rhs) -{ - m_types.swap(rhs.m_types); -} - bool RoadAccess::operator==(RoadAccess const & rhs) const { - return m_types == rhs.m_types; + return m_segmentTypes == rhs.m_segmentTypes; } // Functions --------------------------------------------------------------------------------------- @@ -97,9 +63,9 @@ string DebugPrint(RoadAccess const & r) { size_t const kMaxIdsToShow = 10; ostringstream oss; - oss << "RoadAccess " << DebugPrint(r.GetVehicleMask()) << "[ "; + oss << "RoadAccess " << DebugPrint(r.GetVehicleType()) << " ["; size_t id = 0; - for (auto const & kv : r.GetTypes()) + for (auto const & kv : r.GetSegmentTypes()) { if (id > 0) oss << ", "; @@ -108,7 +74,7 @@ string DebugPrint(RoadAccess const & r) if (id == kMaxIdsToShow) break; } - if (r.GetTypes().size() > kMaxIdsToShow) + if (r.GetSegmentTypes().size() > kMaxIdsToShow) oss << "..."; oss << "]"; diff --git a/routing/road_access.hpp b/routing/road_access.hpp index bf146173a2..fd451fe836 100644 --- a/routing/road_access.hpp +++ b/routing/road_access.hpp @@ -14,7 +14,7 @@ namespace routing { // This class provides information about road access classes. // One instance of RoadAccess holds information about one -// mwm and one router type (also known as VehicleMask). +// mwm and one router type (also known as VehicleType). class RoadAccess final { public: @@ -42,19 +42,17 @@ public: RoadAccess(); - RoadAccess(VehicleMask vehicleMask); + RoadAccess(VehicleType vehicleType); - static std::vector const & GetSupportedVehicleMasks(); - static bool IsSupportedVehicleMask(VehicleMask vehicleMask); - - VehicleMask const GetVehicleMask() const { return m_vehicleMask; } - std::map const & GetTypes() const { return m_types; } - Type const GetType(Segment const & segment) const; + VehicleType const GetVehicleType() const { return m_vehicleType; } + void SetVehicleType(VehicleType vehicleType) { m_vehicleType = vehicleType; } + std::map const & GetSegmentTypes() const { return m_segmentTypes; } + Type const GetSegmentType(Segment const & segment) const; template void SetTypes(V && v) { - m_types = std::forward(v); + m_segmentTypes = std::forward(v); } void Clear(); @@ -64,11 +62,11 @@ public: bool operator==(RoadAccess const & rhs) const; private: - VehicleMask m_vehicleMask; + VehicleType m_vehicleType; // todo(@m) Segment's NumMwmId is not used here. Decouple it from // segment and use only (fid, idx, forward) in the map. - std::map m_types; + std::map m_segmentTypes; }; std::string ToString(RoadAccess::Type type); diff --git a/routing/road_access_serialization.hpp b/routing/road_access_serialization.hpp index bf8ab9b9e6..d69fdfcc0c 100644 --- a/routing/road_access_serialization.hpp +++ b/routing/road_access_serialization.hpp @@ -4,6 +4,7 @@ #include "routing/num_mwm_id.hpp" #include "routing/road_access.hpp" #include "routing/segment.hpp" +#include "routing/vehicle_mask.hpp" #include "coding/bit_streams.hpp" #include "coding/reader.hpp" @@ -25,46 +26,39 @@ class RoadAccessSerializer final { public: using RoadAccessTypesMap = std::map; + using RoadAccessByVehicleType = std::array(VehicleType::Count)>; RoadAccessSerializer() = delete; template - static void Serialize(Sink & sink, std::map const & roadAccessByMask) + static void Serialize(Sink & sink, RoadAccessByVehicleType const & roadAccessByType) { uint32_t const header = kLatestVersion; WriteToSink(sink, header); - uint32_t const numMasks = static_cast(roadAccessByMask.size()); - WriteToSink(sink, numMasks); - - for (auto const & kv : roadAccessByMask) - { - uint32_t const mask = static_cast(kv.first); - WriteToSink(sink, mask); - SerializeOneVehicleMask(sink, kv.second.GetTypes()); - } + for (size_t i = 0; i < static_cast(VehicleType::Count); ++i) + SerializeOneVehicleType(sink, roadAccessByType[i].GetSegmentTypes()); } template - static void Deserialize(Source & src, VehicleMask vehicleMask, RoadAccess & roadAccess) + static void Deserialize(Source & src, VehicleType vehicleType, RoadAccess & roadAccess) { uint32_t const header = ReadPrimitiveFromSource(src); CHECK_EQUAL(header, kLatestVersion, ()); - uint32_t const numMasks = ReadPrimitiveFromSource(src); - for (uint32_t i = 0; i < numMasks; ++i) + roadAccess.SetVehicleType(vehicleType); + for (size_t i = 0; i < static_cast(VehicleType::Count); ++i) { - uint32_t const vm = base::checked_cast(ReadPrimitiveFromSource(src)); RoadAccessTypesMap m; - DeserializeOneVehicleMask(src, m); - if (vehicleMask == vm) + DeserializeOneVehicleType(src, m); + if (vehicleType == static_cast(i)) roadAccess.SetTypes(std::move(m)); } } private: template - static void SerializeOneVehicleMask(Sink & sink, RoadAccessTypesMap const & m) + static void SerializeOneVehicleType(Sink & sink, RoadAccessTypesMap const & m) { std::array, static_cast(RoadAccess::Type::Count)> segmentsByRoadAccessType; @@ -79,7 +73,7 @@ private: } template - static void DeserializeOneVehicleMask(Source & src, RoadAccessTypesMap & m) + static void DeserializeOneVehicleType(Source & src, RoadAccessTypesMap & m) { m.clear(); for (size_t i = 0; i < static_cast(RoadAccess::Type::Count); ++i) diff --git a/routing/routing.pro b/routing/routing.pro index dffa227605..f68e3f8402 100644 --- a/routing/routing.pro +++ b/routing/routing.pro @@ -65,6 +65,7 @@ SOURCES += \ turns_notification_manager.cpp \ turns_sound_settings.cpp \ turns_tts_text.cpp \ + vehicle_mask.cpp \ world_graph.cpp \ HEADERS += \ diff --git a/routing/routing_tests/road_access_test.cpp b/routing/routing_tests/road_access_test.cpp index 2090a70bcd..fe2fe060fa 100644 --- a/routing/routing_tests/road_access_test.cpp +++ b/routing/routing_tests/road_access_test.cpp @@ -20,9 +20,9 @@ namespace { UNIT_TEST(RoadAccess_Serialization) { + // Segment is (numMwmId, featureId, segmentIdx, isForward). map const m0 = { - {Segment(kFakeNumMwmId, 1 /* feature id */, 0 /* segment idx */, false /* forward */), - RoadAccess::Type::No}, + {Segment(kFakeNumMwmId, 1, 0, false), RoadAccess::Type::No}, {Segment(kFakeNumMwmId, 2, 2, false), RoadAccess::Type::Private}, }; @@ -31,21 +31,20 @@ UNIT_TEST(RoadAccess_Serialization) {Segment(kFakeNumMwmId, 2, 0, true), RoadAccess::Type::Destination}, }; - RoadAccess roadAccessCar(kCarMask); + RoadAccess roadAccessCar(VehicleType::Car); roadAccessCar.SetTypes(m0); - RoadAccess roadAccessPedestrian(kPedestrianMask); + RoadAccess roadAccessPedestrian(VehicleType::Pedestrian); roadAccessPedestrian.SetTypes(m1); - map const ms = { - {kCarMask, roadAccessCar}, - {kPedestrianMask, roadAccessPedestrian}, - }; + RoadAccessSerializer::RoadAccessByVehicleType roadAccessAllTypes; + roadAccessAllTypes[static_cast(VehicleType::Car)] = roadAccessCar; + roadAccessAllTypes[static_cast(VehicleType::Pedestrian)] = roadAccessPedestrian; vector buf; { MemWriter writer(buf); - RoadAccessSerializer::Serialize(writer, ms); + RoadAccessSerializer::Serialize(writer, roadAccessAllTypes); } { @@ -53,7 +52,7 @@ UNIT_TEST(RoadAccess_Serialization) MemReader memReader(buf.data(), buf.size()); ReaderSource src(memReader); - RoadAccessSerializer::Deserialize(src, kCarMask, deserializedRoadAccess); + RoadAccessSerializer::Deserialize(src, VehicleType::Car, deserializedRoadAccess); TEST_EQUAL(src.Size(), 0, ()); TEST_EQUAL(roadAccessCar, deserializedRoadAccess, ()); @@ -64,7 +63,7 @@ UNIT_TEST(RoadAccess_Serialization) MemReader memReader(buf.data(), buf.size()); ReaderSource src(memReader); - RoadAccessSerializer::Deserialize(src, kPedestrianMask, deserializedRoadAccess); + RoadAccessSerializer::Deserialize(src, VehicleType::Pedestrian, deserializedRoadAccess); TEST_EQUAL(src.Size(), 0, ()); TEST_EQUAL(roadAccessPedestrian, deserializedRoadAccess, ()); diff --git a/routing/vehicle_mask.hpp b/routing/vehicle_mask.hpp index 52abfb9088..3b8277a18d 100644 --- a/routing/vehicle_mask.hpp +++ b/routing/vehicle_mask.hpp @@ -1,7 +1,6 @@ #pragma once #include -#include #include namespace routing @@ -28,35 +27,8 @@ VehicleMask constexpr kPedestrianMask = GetVehicleMask(VehicleType::Pedestrian); VehicleMask constexpr kBicycleMask = GetVehicleMask(VehicleType::Bicycle); VehicleMask constexpr kCarMask = GetVehicleMask(VehicleType::Car); -inline std::string DebugPrint(VehicleType vehicleType) -{ - switch (vehicleType) - { - case VehicleType::Pedestrian: return "Pedestrian"; - case VehicleType::Bicycle: return "Bicycle"; - case VehicleType::Car: return "Car"; - case VehicleType::Count: return "Count"; - } -} - -inline std::string DebugPrint(VehicleMask vehicleMask) -{ - std::ostringstream oss; - oss << "VehicleMask ["; - bool first = true; - for (size_t i = 0; i < static_cast(VehicleType::Count); ++i) - { - auto const vt = static_cast(i); - if ((vehicleMask & GetVehicleMask(vt)) == 0) - continue; - - if (!first) - oss << ", "; - first = false; - - oss << DebugPrint(vt); - } - oss << "]"; - return oss.str(); -} +std::string DebugPrint(VehicleType vehicleType); +std::string ToString(VehicleType vehicleType); +void FromString(std::string const & s, VehicleType & vehicleType); +std::string DebugPrint(VehicleMask vehicleMask); } // namespace routing