AndrewShkrob/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

Review fixes.

Browse source
This commit is contained in:
Maksim Andrianov 2019-06-28 17:29:04 +03:00 • committed by mpimenov
parent 2c34655148
commit bfd51dc7f8
25 changed files with 107 additions and 150 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
generator/collector_addresses.cpp
View file

@ -36,17 +36,13 @@ void CollectorAddresses::Save()
stream << m_stringStream.str();
}
void CollectorAddresses::Merge(CollectorInterface const * collector)
void CollectorAddresses::Merge(CollectorInterface const & collector)
{
CHECK(collector, ());
collector->MergeInto(const_cast<CollectorAddresses *>(this));
collector.MergeInto(*this);
}
void CollectorAddresses::MergeInto(CollectorAddresses * collector) const
void CollectorAddresses::MergeInto(CollectorAddresses & collector) const
{
CHECK(collector, ());
collector->m_stringStream << m_stringStream.str();
collector.m_stringStream << m_stringStream.str();
}
} // namespace generator

6
generator/collector_addresses.hpp
View file

@ -16,7 +16,7 @@ class IntermediateDataReader;
class CollectorAddresses : public CollectorInterface
{
public:
CollectorAddresses(std::string const & filename);
explicit CollectorAddresses(std::string const & filename);
// CollectorInterface overrides:
std::shared_ptr<CollectorInterface>
@ -25,8 +25,8 @@ public:
void CollectFeature(feature::FeatureBuilder const & feature, OsmElement const &) override;
void Save() override;
void Merge(CollectorInterface const * collector) override;
void MergeInto(CollectorAddresses * collector) const override;
void Merge(CollectorInterface const & collector) override;
void MergeInto(CollectorAddresses & collector) const override;
private:
std::stringstream m_stringStream;

17
generator/collector_camera.cpp
View file

@ -155,24 +155,21 @@ void CameraCollector::Write(FileWriter & writer, CameraProcessor::CameraInfo con
void CameraCollector::Save()
{
LOG(LINFO, ("void CameraCollector::Save()"));
using namespace std::placeholders;
m_processor.FillCameraInWays();
FileWriter writer(GetFilename());
m_processor.ForEachCamera(std::bind(&CameraCollector::Write, this, std::ref(writer), _1, _2));
m_processor.ForEachCamera([&](auto const & camera, auto const & ways) {
Write(writer, camera, ways);
});
}
void CameraCollector::Merge(generator::CollectorInterface const * collector)
void CameraCollector::Merge(generator::CollectorInterface const & collector)
{
CHECK(collector, ());
collector->MergeInto(const_cast<CameraCollector *>(this));
collector.MergeInto(*this);
}
void CameraCollector::MergeInto(CameraCollector * collector) const
void CameraCollector::MergeInto(CameraCollector & collector) const
{
CHECK(collector, ());
collector->m_processor.Merge(this->m_processor);
collector.m_processor.Merge(this->m_processor);
}
} // namespace routing

5
generator/collector_camera.hpp
View file

@ -90,14 +90,13 @@ public:
void CollectFeature(feature::FeatureBuilder const & feature, OsmElement const & element) override;
void Save() override;
void Merge(generator::CollectorInterface const * collector) override;
void MergeInto(CameraCollector * collector) const override;
void Merge(generator::CollectorInterface const & collector) override;
void MergeInto(CameraCollector & collector) const override;
private:
void Write(FileWriter & writer, CameraProcessor::CameraInfo const & camera,
std::vector<uint64_t> const & ways);
std::vector<uint8_t> m_buffer;
CameraProcessor m_processor;
};
} // namespace routing

12
generator/collector_city_boundary.cpp
View file

@ -37,18 +37,14 @@ void CityBoundaryCollector::Save()
}
}
void CityBoundaryCollector::Merge(generator::CollectorInterface const * collector)
void CityBoundaryCollector::Merge(generator::CollectorInterface const & collector)
{
CHECK(collector, ());
collector->MergeInto(const_cast<CityBoundaryCollector *>(this));
collector.MergeInto(*this);
}
void CityBoundaryCollector::MergeInto(CityBoundaryCollector * collector) const
void CityBoundaryCollector::MergeInto(CityBoundaryCollector & collector) const
{
CHECK(collector, ());
std::copy(std::begin(m_boundaries), std::end(m_boundaries),
std::back_inserter(collector->m_boundaries));
std::back_inserter(collector.m_boundaries));
}
} // namespace generator

4
generator/collector_city_boundary.hpp
View file

@ -25,8 +25,8 @@ public:
void CollectFeature(feature::FeatureBuilder const & feature, OsmElement const &) override;
void Save() override;
void Merge(generator::CollectorInterface const * collector) override;
void MergeInto(CityBoundaryCollector * collector) const override;
void Merge(generator::CollectorInterface const & collector) override;
void MergeInto(CityBoundaryCollector & collector) const override;
private:
std::vector<feature::FeatureBuilder> m_boundaries;

16
generator/collector_collection.cpp
View file

@ -13,7 +13,7 @@ CollectorCollection::Clone(std::shared_ptr<cache::IntermediateDataReader> const
{
auto p = std::make_shared<CollectorCollection>();
for (auto const & c : m_collection)
p->Append(c->Clone(cache));
p->Append(c->Clone(cache));
return p;
}
@ -41,20 +41,16 @@ void CollectorCollection::Save()
c->Save();
}
void CollectorCollection::Merge(CollectorInterface const * collector)
void CollectorCollection::Merge(CollectorInterface const & collector)
{
CHECK(collector, ());
collector->MergeInto(const_cast<CollectorCollection *>(this));
collector.MergeInto(*this);
}
void CollectorCollection::MergeInto(CollectorCollection * collector) const
void CollectorCollection::MergeInto(CollectorCollection & collector) const
{
CHECK(collector, ());
auto & otherCollection = collector->m_collection;
auto & otherCollection = collector.m_collection;
CHECK_EQUAL(m_collection.size(), otherCollection.size(), ());
for (size_t i = 0; i < m_collection.size(); ++i)
otherCollection[i]->Merge(m_collection[i].get());
otherCollection[i]->Merge(*m_collection[i]);
}
} // namespace generator

4
generator/collector_collection.hpp
View file

@ -33,7 +33,7 @@ public:
void CollectFeature(feature::FeatureBuilder const & feature, OsmElement const & element) override;
void Save() override;
void Merge(CollectorInterface const * collector) override;
void MergeInto(CollectorCollection * collector) const override;
void Merge(CollectorInterface const & collector) override;
void MergeInto(CollectorCollection & collector) const override;
};
} // namespace generator

24
generator/collector_interface.hpp
View file

@ -59,23 +59,23 @@ public:
virtual void CollectFeature(feature::FeatureBuilder const &, OsmElement const &) {}
virtual void Save() = 0;
virtual void Merge(CollectorInterface const *) = 0;
virtual void Merge(CollectorInterface const &) = 0;
virtual void MergeInto(CityBoundaryCollector *) const { FailIfMethodUnsuppirted(); }
virtual void MergeInto(routing::CameraCollector *) const { FailIfMethodUnsuppirted(); }
virtual void MergeInto(routing::RestrictionWriter *) const { FailIfMethodUnsuppirted(); }
virtual void MergeInto(routing::RoadAccessWriter *) const { FailIfMethodUnsuppirted(); }
virtual void MergeInto(CollectorAddresses *) const { FailIfMethodUnsuppirted(); }
virtual void MergeInto(CollectorTag *) const { FailIfMethodUnsuppirted(); }
virtual void MergeInto(MaxspeedsCollector *) const { FailIfMethodUnsuppirted(); }
virtual void MergeInto(feature::MetalinesBuilder *) const { FailIfMethodUnsuppirted(); }
virtual void MergeInto(regions::CollectorRegionInfo *) const { FailIfMethodUnsuppirted(); }
virtual void MergeInto(CollectorCollection *) const { FailIfMethodUnsuppirted(); }
virtual void MergeInto(CityBoundaryCollector &) const { FailIfMethodUnsupported(); }
virtual void MergeInto(routing::CameraCollector &) const { FailIfMethodUnsupported(); }
virtual void MergeInto(routing::RestrictionWriter &) const { FailIfMethodUnsupported(); }
virtual void MergeInto(routing::RoadAccessWriter &) const { FailIfMethodUnsupported(); }
virtual void MergeInto(CollectorAddresses &) const { FailIfMethodUnsupported(); }
virtual void MergeInto(CollectorTag &) const { FailIfMethodUnsupported(); }
virtual void MergeInto(MaxspeedsCollector &) const { FailIfMethodUnsupported(); }
virtual void MergeInto(feature::MetalinesBuilder &) const { FailIfMethodUnsupported(); }
virtual void MergeInto(regions::CollectorRegionInfo &) const { FailIfMethodUnsupported(); }
virtual void MergeInto(CollectorCollection &) const { FailIfMethodUnsupported(); }
std::string const & GetFilename() const { return m_filename; }
private:
void FailIfMethodUnsuppirted() const { CHECK(false, ("This method is unsupported.")); }
void FailIfMethodUnsupported() const { CHECK(false, ("This method is unsupported.")); }
std::string m_filename;
};

12
generator/collector_tag.cpp
View file

@ -50,17 +50,13 @@ void CollectorTag::Save()
}
}
void CollectorTag::Merge(CollectorInterface const * collector)
void CollectorTag::Merge(CollectorInterface const & collector)
{
CHECK(collector, ());
collector->MergeInto(const_cast<CollectorTag *>(this));
collector.MergeInto(*this);
}
void CollectorTag::MergeInto(CollectorTag * collector) const
void CollectorTag::MergeInto(CollectorTag & collector) const
{
CHECK(collector, ());
collector->m_stream << this->m_stream.str();
collector.m_stream << m_stream.str();
}
} // namespace generator

4
generator/collector_tag.hpp
View file

@ -38,8 +38,8 @@ public:
void Collect(OsmElement const & el) override;
void Save() override;
void Merge(CollectorInterface const * collector) override;
void MergeInto(CollectorTag * collector) const override;
void Merge(CollectorInterface const & collector) override;
void MergeInto(CollectorTag & collector) const override;
private:
std::stringstream m_stream;
std::string m_tagKey;

8
generator/generator_tests/merge_collectors_tests.cpp
View file

@ -6,10 +6,10 @@
#include "generator/collector_interface.hpp"
#include "generator/collector_tag.hpp"
#include "base/geo_object_id.hpp"
#include "platform/platform.hpp"
#include "base/geo_object_id.hpp"
#include <fstream>
#include <memory>
#include <string>
@ -38,7 +38,7 @@ UNIT_TEST(MergeCollector_Case1)
collector2->Collect(MakeOsmElement(3 /* id */, {{"admin_level", "3"}}, OsmElement::EntityType::Relation));
collector2->Collect(MakeOsmElement(4 /* id */, {{"admin_level", "4"}}, OsmElement::EntityType::Relation));
collector1->Merge(collector2.get());
collector1->Merge(*collector2);
collector1->Save();
std::vector<std::string> const answers = {
@ -72,7 +72,7 @@ UNIT_TEST(MergeCollector_Case2)
collection2->Collect(MakeOsmElement(3 /* id */, {{"admin_level", "3"}}, OsmElement::EntityType::Relation));
collection2->Collect(MakeOsmElement(4 /* id */, {{"admin_level", "4"}}, OsmElement::EntityType::Relation));
collection1->Merge(collection2.get());
collection1->Merge(*collection2);
collection1->Save();
std::vector<std::string> const answers = {

17
generator/generator_tests/metalines_tests.cpp
View file

@ -14,7 +14,8 @@ using namespace feature;
namespace
{
OsmElement MakeHighway(uint64_t id, std::string const & name, std::vector<uint64_t> const & nodes, bool isOneway = false)
OsmElement MakeHighway(uint64_t id, std::string const & name, std::vector<uint64_t> const & nodes,
bool isOneway = false)
{
OsmElement element;
element.m_id = id;
@ -44,7 +45,7 @@ LineStringMerger::InputData MakeInputData(std::vector<OsmElement> const & elemen
return inputData;
};
bool IsEquil(LineStringMerger::LinePtr const & lineString, std::vector<int32_t> const & ways)
bool IsEqual(LineStringMerger::LinePtr const & lineString, std::vector<int32_t> const & ways)
{
auto const & w = lineString->GetWays();
return w == ways;
@ -83,7 +84,7 @@ UNIT_TEST(MetalinesTest_Case1)
auto const key = MakeKey(w1);
TEST_EQUAL(outputData.size(), 1 /* unique names roads count */, ());
TEST_EQUAL(outputData.at(key)[0]->GetWays().size(), 2 /* merged way size */, ());
TEST(IsEquil(outputData.at(key)[0], {1, 2}) /* merged way */, ());
TEST(IsEqual(outputData.at(key)[0], {1, 2}) /* merged way */, ());
}
UNIT_TEST(MetalinesTest_Case2)
@ -94,7 +95,7 @@ UNIT_TEST(MetalinesTest_Case2)
auto const key = MakeKey(w1);
TEST_EQUAL(outputData.size(), 1 /* unique names roads count */, ());
TEST_EQUAL(outputData.at(key)[0]->GetWays().size(), 3 /* merged way size */, ());
TEST(IsEquil(outputData.at(key)[0], {1, 2, 3}) /* merged way */, ());
TEST(IsEqual(outputData.at(key)[0], {1, 2, 3}) /* merged way */, ());
}
UNIT_TEST(MetalinesTest_Case3)
@ -107,10 +108,10 @@ UNIT_TEST(MetalinesTest_Case3)
TEST_EQUAL(outputData.at(key).size(), 2 /* ways count */, ());
TEST_EQUAL(outputData.at(key)[0]->GetWays().size(), 2 /* merged way size */, ());
TEST(IsEquil(outputData.at(key)[0], {1, 2}) /* merged way */, ());
TEST(IsEqual(outputData.at(key)[0], {1, 2}) /* merged way */, ());
TEST_EQUAL(outputData.at(key)[1]->GetWays().size(), 2 /* merged way size */, ());
TEST(IsEquil(outputData.at(key)[1], {4, 5}) /* merged way */, ());
TEST(IsEqual(outputData.at(key)[1], {4, 5}) /* merged way */, ());
}
UNIT_TEST(MetalinesTest_Case4)
@ -121,7 +122,7 @@ UNIT_TEST(MetalinesTest_Case4)
auto const key = MakeKey(w1);
TEST_EQUAL(outputData.size(), 1 /* unique names roads count */, ());
TEST_EQUAL(outputData.at(key).size(), 1 /* ways count */, ());
TEST(IsEquil(outputData.at(key)[0], {6, -1}) /* merged way */, ());
TEST(IsEqual(outputData.at(key)[0], {6, -1}) /* merged way */, ());
}
UNIT_TEST(MetalinesTest_Case5)
@ -132,7 +133,7 @@ UNIT_TEST(MetalinesTest_Case5)
auto const key = MakeKey(w1);
TEST_EQUAL(outputData.size(), 1 /* unique names roads count */, ());
TEST_EQUAL(outputData.at(key).size(), 1 /* ways count */, ());
TEST(IsEquil(outputData.at(key)[0], {1, 2}) /* merged way */, ());
TEST(IsEqual(outputData.at(key)[0], {1, 2}) /* merged way */, ());
}
UNIT_TEST(MetalinesTest_Case6)

18
generator/maxspeeds_collector.cpp
View file

@ -39,10 +39,10 @@ MaxspeedsCollector::MaxspeedsCollector(string const & filename)
: CollectorInterface(filename) {}
std::shared_ptr<CollectorInterface>
MaxspeedsCollector::Clone(std::shared_ptr<cache::IntermediateDataReader> const &) const
shared_ptr<CollectorInterface>
MaxspeedsCollector::Clone(shared_ptr<cache::IntermediateDataReader> const &) const
{
return std::make_shared<MaxspeedsCollector>(GetFilename());
return make_shared<MaxspeedsCollector>(GetFilename());
}
void MaxspeedsCollector::CollectFeature(FeatureBuilder const &, OsmElement const & p)
@ -125,17 +125,13 @@ void MaxspeedsCollector::Save()
LOG(LINFO, ("Wrote", m_data.size(), "maxspeed tags to", GetFilename()));
}
void MaxspeedsCollector::Merge(CollectorInterface const * collector)
void MaxspeedsCollector::Merge(CollectorInterface const & collector)
{
CHECK(collector, ());
collector->MergeInto(const_cast<MaxspeedsCollector *>(this));
collector.MergeInto(*this);
}
void MaxspeedsCollector::MergeInto(MaxspeedsCollector * collector) const
void MaxspeedsCollector::MergeInto(MaxspeedsCollector & collector) const
{
CHECK(collector, ());
copy(begin(m_data), end(m_data), back_inserter(collector->m_data));
copy(begin(m_data), end(m_data), back_inserter(collector.m_data));
}
} // namespace generator

4
generator/maxspeeds_collector.hpp
View file

@ -31,8 +31,8 @@ public:
void CollectFeature(feature::FeatureBuilder const &, OsmElement const & p) override;
void Save() override;
void Merge(CollectorInterface const * collector) override;
void MergeInto(MaxspeedsCollector * collector) const override;
void Merge(CollectorInterface const & collector) override;
void MergeInto(MaxspeedsCollector & collector) const override;
private:
// |m_data| contains strings with maxspeed tags value for corresponding features in one of the

14
generator/metalines_builder.cpp
View file

@ -16,11 +16,12 @@
#include "defines.hpp"
#include <cstdint>
#include <limits>
#include <map>
namespace
{
uint8_t const kMetaLinesSectionVersion = 1;
uint8_t constexpr kMetaLinesSectionVersion = 1;
} // namespace
namespace feature
@ -212,17 +213,14 @@ void MetalinesBuilder::Save()
"ways] with OSM IDs for the entire planet to", GetFilename()));
}
void MetalinesBuilder::Merge(generator::CollectorInterface const * collector)
void MetalinesBuilder::Merge(generator::CollectorInterface const & collector)
{
CHECK(collector, ());
collector->MergeInto(const_cast<MetalinesBuilder *>(this));
collector.MergeInto(*this);
}
void MetalinesBuilder::MergeInto(MetalinesBuilder * collector) const
void MetalinesBuilder::MergeInto(MetalinesBuilder & collector) const
{
CHECK(collector, ());
collector->m_data.insert(std::begin(m_data), std::end(m_data));
collector.m_data.insert(std::begin(m_data), std::end(m_data));
}
// Functions --------------------------------------------------------------------------------

11
generator/metalines_builder.hpp
View file

@ -5,10 +5,12 @@
#include "generator/osm_element.hpp"
#include <cstdlib>
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
namespace generator
{
@ -48,9 +50,12 @@ public:
using LinePtr = std::shared_ptr<LineString>;
using InputData = std::unordered_multimap<size_t, LinePtr>;
using OutputData = std::map<size_t, std::vector<LinePtr>>;
using Buffer = std::unordered_map<uint64_t, LinePtr>;
static OutputData Merge(InputData const & data);
private:
using Buffer = std::unordered_map<uint64_t, LinePtr>;
static bool TryMerge(LinePtr const & lineString, Buffer & buffer);
static bool TryMergeOne(LinePtr const & lineString, Buffer & buffer);
static OutputData OrderData(InputData const & data);
@ -70,8 +75,8 @@ public:
void CollectFeature(FeatureBuilder const & feature, OsmElement const & element) override;
void Save() override;
void Merge(generator::CollectorInterface const * collector) override;
void MergeInto(MetalinesBuilder * collector) const override;
void Merge(generator::CollectorInterface const & collector) override;
void MergeInto(MetalinesBuilder & collector) const override;
private:
std::unordered_multimap<size_t, std::shared_ptr<LineString>> m_data;

14
generator/regions/collector_region_info.cpp
View file

@ -100,19 +100,15 @@ void CollectorRegionInfo::Save()
WriteMap(writer, m_mapIsoCode);
}
void CollectorRegionInfo::Merge(CollectorInterface const * collector)
void CollectorRegionInfo::Merge(CollectorInterface const & collector)
{
CHECK(collector, ());
collector->MergeInto(const_cast<CollectorRegionInfo *>(this));
collector.MergeInto(*this);
}
void CollectorRegionInfo::MergeInto(CollectorRegionInfo * collector) const
void CollectorRegionInfo::MergeInto(CollectorRegionInfo & collector) const
{
CHECK(collector, ());
collector->m_mapRegionData.insert(std::begin(m_mapRegionData), std::end(m_mapRegionData));
collector->m_mapIsoCode.insert(std::begin(m_mapIsoCode), std::end(m_mapIsoCode));
collector.m_mapRegionData.insert(std::begin(m_mapRegionData), std::end(m_mapRegionData));
collector.m_mapIsoCode.insert(std::begin(m_mapIsoCode), std::end(m_mapIsoCode));
}
void CollectorRegionInfo::FillRegionData(base::GeoObjectId const & osmId, OsmElement const & el,

4
generator/regions/collector_region_info.hpp
View file

@ -132,8 +132,8 @@ public:
void Save() override;
void Merge(CollectorInterface const * collector) override;
void MergeInto(CollectorRegionInfo * collector) const override;
void Merge(CollectorInterface const & collector) override;
void MergeInto(CollectorRegionInfo & collector) const override;
private:
template <typename Sink, typename Map>

13
generator/restriction_writer.cpp
View file

@ -102,7 +102,6 @@ RestrictionWriter::RestrictionWriter(std::string const & filename,
std::shared_ptr<generator::CollectorInterface>
RestrictionWriter::Clone(std::shared_ptr<generator::cache::IntermediateDataReader> const & cache) const
{
// auto c = cache ? cache : m_cache;
return std::make_shared<RestrictionWriter>(GetFilename(), *cache);
}
@ -212,18 +211,14 @@ void RestrictionWriter::Save()
stream << m_stream.str();
}
void RestrictionWriter::Merge(generator::CollectorInterface const * collector)
void RestrictionWriter::Merge(generator::CollectorInterface const & collector)
{
CHECK(collector, ());
collector->MergeInto(const_cast<RestrictionWriter *>(this));
collector.MergeInto(*this);
}
void RestrictionWriter::MergeInto(RestrictionWriter * collector) const
void RestrictionWriter::MergeInto(RestrictionWriter & collector) const
{
CHECK(collector, ());
collector->m_stream << m_stream.str();
collector.m_stream << m_stream.str();
}
std::string DebugPrint(RestrictionWriter::ViaType const & type)

4
generator/restriction_writer.hpp
View file

@ -44,8 +44,8 @@ public:
void CollectRelation(RelationElement const & relationElement) override;
void Save() override;
void Merge(generator::CollectorInterface const * collector) override;
void MergeInto(RestrictionWriter * collector) const override;
void Merge(generator::CollectorInterface const & collector) override;
void MergeInto(RestrictionWriter & collector) const override;
static ViaType ConvertFromString(std::string const & str);

12
generator/road_access_generator.cpp
View file

@ -420,18 +420,14 @@ void RoadAccessWriter::Save()
out << stream.str();
}
void RoadAccessWriter::Merge(generator::CollectorInterface const * collector)
void RoadAccessWriter::Merge(generator::CollectorInterface const & collector)
{
CHECK(collector, ());
collector->MergeInto(const_cast<RoadAccessWriter *>(this));
collector.MergeInto(*this);
}
void RoadAccessWriter::MergeInto(RoadAccessWriter * collector) const
void RoadAccessWriter::MergeInto(RoadAccessWriter & collector) const
{
CHECK(collector, ());
auto & otherProcessors = collector->m_tagProcessors;
auto & otherProcessors = collector.m_tagProcessors;
CHECK_EQUAL(m_tagProcessors.size(), otherProcessors.size(), ());
for (size_t i = 0; i < otherProcessors.size(); ++i)

9
generator/road_access_generator.hpp
View file

@ -12,10 +12,12 @@
#include <cstdint>
#include <fstream>
#include <map>
#include <memory>
#include <ostream>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>
struct OsmElement;
@ -69,7 +71,7 @@ private:
class RoadAccessWriter : public generator::CollectorInterface
{
public:
RoadAccessWriter(std::string const & filename);
explicit RoadAccessWriter(std::string const & filename);
// CollectorInterface overrides:
std::shared_ptr<CollectorInterface>
@ -78,8 +80,9 @@ public:
void CollectFeature(feature::FeatureBuilder const & fb, OsmElement const & elem) override;
void Save() override;
void Merge(generator::CollectorInterface const * collector) override;
void MergeInto(RoadAccessWriter * collector) const override;
void Merge(generator::CollectorInterface const & collector) override;
void MergeInto(RoadAccessWriter & collector) const override;
private:
std::ofstream m_stream;
std::vector<RoadAccessTagProcessor> m_tagProcessors;

10
generator/translator.cpp
View file

@ -64,18 +64,8 @@ void Translator::AddCollector(std::shared_ptr<CollectorInterface> collector)
m_collectors.Append(collector);
}
void Translator::AddCollectorCollection(CollectorCollection const & collectors)
{
m_collectors.AddCollection(collectors);
}
void Translator::AddFilter(std::shared_ptr<FilterInterface> filter)
{
m_filters.Append(filter);
}
void Translator::AddFilterCollection(FilterCollection const & filters)
{
m_filters.AddCollection(filters);
}
} // namespace generator

3
generator/translator.hpp
View file

@ -40,10 +40,7 @@ public:
void GetNames(std::vector<std::string> & names) const override;
void AddCollector(std::shared_ptr<CollectorInterface> collector);
void AddCollectorCollection(CollectorCollection const & collectors);
void AddFilter(std::shared_ptr<FilterInterface> filter);
void AddFilterCollection(FilterCollection const & filters);
protected:
FilterCollection m_filters;