kirylkaveryn/organicmaps
1
Fork 0
forked from organicmaps/organicmaps-tmp
Code Pull requests Activity

[generator] Clang-format

Browse source
This commit is contained in:
Maksim Andrianov 2019-10-01 17:28:46 +03:00 • committed by gmoryes
parent 563826266d
commit 39eeb42b7f
18 changed files with 125 additions and 156 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
generator/generator_tool/generator_tool.cpp
View file

@ -121,8 +121,9 @@ DEFINE_string(cities_boundaries_data, "", "File with cities boundaries");
DEFINE_bool(generate_cities_ids, false, "Generate the cities ids section");
DEFINE_bool(generate_world, false, "Generate separate world file.");
DEFINE_bool(have_borders_for_whole_world, false, "If it is set to true, the optimization of checking that the "
"fb belongs to the country border will be applied.");
DEFINE_bool(have_borders_for_whole_world, false,
"If it is set to true, the optimization of checking that the "
"fb belongs to the country border will be applied.");
DEFINE_string(
nodes_list_path, "",
@ -201,7 +202,7 @@ int GeneratorToolMain(int argc, char ** argv)
CHECK(IsLittleEndian(), ("Only little-endian architectures are supported."));
google::SetUsageMessage(
"Takes OSM XML data from stdin and creates data and index files in several passes.");
"Takes OSM XML data from stdin and creates data and index files in several passes.");
google::SetVersionString(std::to_string(omim::build_version::git::kTimestamp) + " " +
omim::build_version::git::kHash);
google::ParseCommandLineFlags(&argc, &argv, true);
@ -224,8 +225,8 @@ int GeneratorToolMain(int argc, char ** argv)
feature::GenerateInfo genInfo;
genInfo.m_verbose = FLAGS_verbose;
genInfo.m_intermediateDir = FLAGS_intermediate_data_path.empty()
? path
: base::AddSlashIfNeeded(FLAGS_intermediate_data_path);
? path
: base::AddSlashIfNeeded(FLAGS_intermediate_data_path);
genInfo.m_targetDir = genInfo.m_tmpDir = path;
/// @todo Probably, it's better to add separate option for .mwm.tmp files.
@ -273,9 +274,7 @@ int GeneratorToolMain(int argc, char ** argv)
}
// Generate .mwm.tmp files.
if (FLAGS_generate_features ||
FLAGS_generate_world ||
FLAGS_make_coasts)
if (FLAGS_generate_features || FLAGS_generate_world || FLAGS_make_coasts)
{
RawGenerator rawGenerator(genInfo, threadsCount);
if (FLAGS_generate_features)

12
generator/processor_booking.hpp
View file

@ -20,8 +20,11 @@ template <typename Dataset>
class ProcessorBooking : public FeatureProcessorInterface
{
public:
ProcessorBooking(Dataset const & dataset, std::map<base::GeoObjectId, feature::FeatureBuilder> & features)
: m_dataset(dataset), m_features(features) {}
ProcessorBooking(Dataset const & dataset,
std::map<base::GeoObjectId, feature::FeatureBuilder> & features)
: m_dataset(dataset), m_features(features)
{
}
// FeatureProcessorInterface overrides:
virtual std::shared_ptr<FeatureProcessorInterface> Clone() const override
@ -38,10 +41,7 @@ public:
void Finish() override {}
void Merge(FeatureProcessorInterface const &) override
{
CHECK(false, ());
}
void Merge(FeatureProcessorInterface const &) override { CHECK(false, ()); }
private:
Dataset const & m_dataset;

13
generator/processor_coastline.cpp
View file

@ -20,7 +20,8 @@ ProcessorCoastline::ProcessorCoastline(std::shared_ptr<FeatureProcessorQueue> co
m_processingChain = std::make_shared<RepresentationCoastlineLayer>();
m_processingChain->Add(std::make_shared<PrepareCoastlineFeatureLayer>());
auto affiliation = std::make_shared<feature::SingleAffiliation>(WORLD_COASTS_FILE_NAME);
m_affiliationsLayer = std::make_shared<AffiliationsFeatureLayer<>>(kAffiliationsBufferSize, affiliation, m_queue);
m_affiliationsLayer =
std::make_shared<AffiliationsFeatureLayer<>>(kAffiliationsBufferSize, affiliation, m_queue);
m_processingChain->Add(m_affiliationsLayer);
}
@ -34,15 +35,9 @@ void ProcessorCoastline::Process(feature::FeatureBuilder & feature)
m_processingChain->Handle(feature);
}
void ProcessorCoastline::Finish()
{
m_affiliationsLayer->AddBufferToQueue();
}
void ProcessorCoastline::Finish() { m_affiliationsLayer->AddBufferToQueue(); }
void ProcessorCoastline::Merge(FeatureProcessorInterface const & other)
{
other.MergeInto(*this);
}
void ProcessorCoastline::Merge(FeatureProcessorInterface const & other) { other.MergeInto(*this); }
void ProcessorCoastline::MergeInto(ProcessorCoastline & other) const
{

22
generator/processor_country.cpp
View file

@ -10,7 +10,8 @@
namespace generator
{
ProcessorCountry::ProcessorCountry(std::shared_ptr<FeatureProcessorQueue> const & queue,
std::string const & bordersPath, std::string const & layerLogFilename,
std::string const & bordersPath,
std::string const & layerLogFilename,
bool haveBordersForWholeWorld)
: m_bordersPath(bordersPath)
, m_layerLogFilename(layerLogFilename)
@ -20,14 +21,17 @@ ProcessorCountry::ProcessorCountry(std::shared_ptr<FeatureProcessorQueue> const
m_processingChain = std::make_shared<RepresentationLayer>();
m_processingChain->Add(std::make_shared<PrepareFeatureLayer>());
m_processingChain->Add(std::make_shared<CountryLayer>());
auto affiliation = std::make_shared<feature::CountriesFilesIndexAffiliation>(bordersPath, haveBordersForWholeWorld);
m_affiliationsLayer = std::make_shared<AffiliationsFeatureLayer<>>(kAffiliationsBufferSize, affiliation, m_queue);
auto affiliation = std::make_shared<feature::CountriesFilesIndexAffiliation>(
bordersPath, haveBordersForWholeWorld);
m_affiliationsLayer =
std::make_shared<AffiliationsFeatureLayer<>>(kAffiliationsBufferSize, affiliation, m_queue);
m_processingChain->Add(m_affiliationsLayer);
}
std::shared_ptr<FeatureProcessorInterface> ProcessorCountry::Clone() const
{
return std::make_shared<ProcessorCountry>(m_queue, m_bordersPath, m_layerLogFilename, m_haveBordersForWholeWorld);
return std::make_shared<ProcessorCountry>(m_queue, m_bordersPath, m_layerLogFilename,
m_haveBordersForWholeWorld);
}
void ProcessorCountry::Process(feature::FeatureBuilder & feature)
@ -35,10 +39,7 @@ void ProcessorCountry::Process(feature::FeatureBuilder & feature)
m_processingChain->Handle(feature);
}
void ProcessorCountry::Finish()
{
m_affiliationsLayer->AddBufferToQueue();
}
void ProcessorCountry::Finish() { m_affiliationsLayer->AddBufferToQueue(); }
void ProcessorCountry::WriteDump()
{
@ -49,10 +50,7 @@ void ProcessorCountry::WriteDump()
LOG(LINFO, ("Skipped elements were saved to", m_layerLogFilename));
}
void ProcessorCountry::Merge(FeatureProcessorInterface const & other)
{
other.MergeInto(*this);
}
void ProcessorCountry::Merge(FeatureProcessorInterface const & other) { other.MergeInto(*this); }
void ProcessorCountry::MergeInto(ProcessorCountry & other) const
{

17
generator/processor_factory.hpp
View file

@ -27,20 +27,15 @@ enum class ProcessorType
};
template <class... Args>
std::shared_ptr<FeatureProcessorInterface> CreateProcessor(ProcessorType type, Args&&... args)
std::shared_ptr<FeatureProcessorInterface> CreateProcessor(ProcessorType type, Args &&... args)
{
switch (type)
{
case ProcessorType::Coastline:
return create<ProcessorCoastline>(std::forward<Args>(args)...);
case ProcessorType::Country:
return create<ProcessorCountry>(std::forward<Args>(args)...);
case ProcessorType::Simple:
return create<ProcessorSimple>(std::forward<Args>(args)...);
case ProcessorType::World:
return create<ProcessorWorld>(std::forward<Args>(args)...);
case ProcessorType::Noop:
return create<ProcessorNoop>(std::forward<Args>(args)...);
case ProcessorType::Coastline: return create<ProcessorCoastline>(std::forward<Args>(args)...);
case ProcessorType::Country: return create<ProcessorCountry>(std::forward<Args>(args)...);
case ProcessorType::Simple: return create<ProcessorSimple>(std::forward<Args>(args)...);
case ProcessorType::World: return create<ProcessorWorld>(std::forward<Args>(args)...);
case ProcessorType::Noop: return create<ProcessorNoop>(std::forward<Args>(args)...);
}
UNREACHABLE();
}

3
generator/processor_interface.hpp
View file

@ -19,7 +19,8 @@ class ProcessorNoop;
class ProcessorSimple;
class ProcessorWorld;
// Implementing this interface allows an object to process FeatureBuilder objects and broadcast them.
// Implementing this interface allows an object to process FeatureBuilder objects and broadcast
// them.
class FeatureProcessorInterface
{
public:

25
generator/processor_simple.cpp
View file

@ -9,35 +9,26 @@ namespace generator
{
ProcessorSimple::ProcessorSimple(std::shared_ptr<FeatureProcessorQueue> const & queue,
std::string const & name)
: m_name(name)
, m_queue(queue)
: m_name(name), m_queue(queue)
{
m_processingChain = std::make_shared<PreserializeLayer>();
auto affiliation = std::make_shared<feature::SingleAffiliation>(name);
m_affiliationsLayer = std::make_shared<AffiliationsFeatureLayer<
feature::serialization_policy::MinSize>>(kAffiliationsBufferSize, affiliation, m_queue);
m_affiliationsLayer =
std::make_shared<AffiliationsFeatureLayer<feature::serialization_policy::MinSize>>(
kAffiliationsBufferSize, affiliation, m_queue);
m_processingChain->Add(m_affiliationsLayer);
}
std::shared_ptr<FeatureProcessorInterface>ProcessorSimple::Clone() const
std::shared_ptr<FeatureProcessorInterface> ProcessorSimple::Clone() const
{
return std::make_shared<ProcessorSimple>(m_queue, m_name);
}
void ProcessorSimple::Process(feature::FeatureBuilder & fb)
{
m_processingChain->Handle(fb);
}
void ProcessorSimple::Process(feature::FeatureBuilder & fb) { m_processingChain->Handle(fb); }
void ProcessorSimple::Finish()
{
m_affiliationsLayer->AddBufferToQueue();
}
void ProcessorSimple::Finish() { m_affiliationsLayer->AddBufferToQueue(); }
void ProcessorSimple::Merge(FeatureProcessorInterface const & other)
{
other.MergeInto(*this);
}
void ProcessorSimple::Merge(FeatureProcessorInterface const & other) { other.MergeInto(*this); }
void ProcessorSimple::MergeInto(ProcessorSimple & other) const
{

3
generator/processor_simple.hpp
View file

@ -30,7 +30,8 @@ public:
private:
std::string m_name;
std::shared_ptr<AffiliationsFeatureLayer<feature::serialization_policy::MinSize>> m_affiliationsLayer;
std::shared_ptr<AffiliationsFeatureLayer<feature::serialization_policy::MinSize>>
m_affiliationsLayer;
std::shared_ptr<FeatureProcessorQueue> m_queue;
std::shared_ptr<LayerBase> m_processingChain;
};

16
generator/processor_world.cpp
View file

@ -10,14 +10,14 @@ namespace generator
{
ProcessorWorld::ProcessorWorld(std::shared_ptr<FeatureProcessorQueue> const & queue,
std::string const & popularityFilename)
: m_popularityFilename(popularityFilename)
, m_queue(queue)
: m_popularityFilename(popularityFilename), m_queue(queue)
{
m_processingChain = std::make_shared<RepresentationLayer>();
m_processingChain->Add(std::make_shared<PrepareFeatureLayer>());
m_processingChain->Add(std::make_shared<WorldLayer>(popularityFilename));
auto affiliation = std::make_shared<feature::SingleAffiliation>(WORLD_FILE_NAME);
m_affiliationsLayer = std::make_shared<AffiliationsFeatureLayer<>>(kAffiliationsBufferSize, affiliation, m_queue);
m_affiliationsLayer =
std::make_shared<AffiliationsFeatureLayer<>>(kAffiliationsBufferSize, affiliation, m_queue);
m_processingChain->Add(m_affiliationsLayer);
}
@ -31,15 +31,9 @@ void ProcessorWorld::Process(feature::FeatureBuilder & feature)
m_processingChain->Handle(feature);
}
void ProcessorWorld::Finish()
{
m_affiliationsLayer->AddBufferToQueue();
}
void ProcessorWorld::Finish() { m_affiliationsLayer->AddBufferToQueue(); }
void ProcessorWorld::Merge(FeatureProcessorInterface const & other)
{
other.MergeInto(*this);
}
void ProcessorWorld::Merge(FeatureProcessorInterface const & other) { other.MergeInto(*this); }
void ProcessorWorld::MergeInto(ProcessorWorld & other) const
{

8
generator/translator.cpp
View file

@ -28,7 +28,8 @@ Translator::Translator(std::shared_ptr<FeatureProcessorInterface> const & proces
Translator::Translator(std::shared_ptr<FeatureProcessorInterface> const & processor,
std::shared_ptr<cache::IntermediateData> const & cache,
std::shared_ptr<FeatureMakerBase> const & maker)
: Translator(processor, cache, maker, std::make_shared<FilterCollection>(), std::make_shared<CollectorCollection>())
: Translator(processor, cache, maker, std::make_shared<FilterCollection>(),
std::make_shared<CollectorCollection>())
{
}
@ -37,10 +38,7 @@ void Translator::SetCollector(std::shared_ptr<CollectorInterface> const & collec
m_collector = collector;
}
void Translator::SetFilter(std::shared_ptr<FilterInterface> const & filter)
{
m_filter = filter;
}
void Translator::SetFilter(std::shared_ptr<FilterInterface> const & filter) { m_filter = filter; }
void Translator::Emit(OsmElement & element)
{

4
generator/translator.hpp
View file

@ -21,8 +21,8 @@ namespace cache
class IntermediateData;
} // namespace cache
// Implementing this base class allows an object to create FeatureBuilder from OsmElement and then process it.
// You can add any collectors and filters.
// Implementing this base class allows an object to create FeatureBuilder from OsmElement and then
// process it. You can add any collectors and filters.
class Translator : public TranslatorInterface
{
public:

21
generator/translator_coastline.cpp
View file

@ -39,30 +39,25 @@ public:
};
} // namespace
TranslatorCoastline::TranslatorCoastline(std::shared_ptr<FeatureProcessorInterface> const & processor,
std::shared_ptr<cache::IntermediateData> const & cache)
TranslatorCoastline::TranslatorCoastline(
std::shared_ptr<FeatureProcessorInterface> const & processor,
std::shared_ptr<cache::IntermediateData> const & cache)
: Translator(processor, cache, std::make_shared<FeatureMaker>(cache))
{
auto filters = std::make_shared<FilterCollection>();
filters->Append(std::make_shared<FilterPlanet>());
filters->Append(std::make_shared<CoastlineFilter>());
filters->Append(std::make_shared<FilterElements>(base::JoinPath(GetPlatform().ResourcesDir(), SKIPPED_ELEMENTS_FILE)));
filters->Append(std::make_shared<FilterElements>(
base::JoinPath(GetPlatform().ResourcesDir(), SKIPPED_ELEMENTS_FILE)));
SetFilter(filters);
}
std::shared_ptr<TranslatorInterface>
TranslatorCoastline::Clone() const
std::shared_ptr<TranslatorInterface> TranslatorCoastline::Clone() const
{
return Translator::CloneBase<TranslatorCoastline>();
}
void TranslatorCoastline::Merge(TranslatorInterface const & other)
{
other.MergeInto(*this);
}
void TranslatorCoastline::Merge(TranslatorInterface const & other) { other.MergeInto(*this); }
void TranslatorCoastline::MergeInto(TranslatorCoastline & other) const
{
MergeIntoBase(other);
}
void TranslatorCoastline::MergeInto(TranslatorCoastline & other) const { MergeIntoBase(other); }
} // namespace generator

13
generator/translator_collection.cpp
View file

@ -7,8 +7,7 @@
namespace generator
{
std::shared_ptr<TranslatorInterface>
TranslatorCollection::Clone() const
std::shared_ptr<TranslatorInterface> TranslatorCollection::Clone() const
{
auto p = std::make_shared<TranslatorCollection>();
for (auto const & c : m_collection)
@ -33,15 +32,11 @@ void TranslatorCollection::Finish()
bool TranslatorCollection::Save()
{
return std::all_of(std::begin(m_collection), std::end(m_collection), [](auto & t) {
return t->Save();
});
return std::all_of(std::begin(m_collection), std::end(m_collection),
[](auto & t) { return t->Save(); });
}
void TranslatorCollection::Merge(TranslatorInterface const & other)
{
other.MergeInto(*this);
}
void TranslatorCollection::Merge(TranslatorInterface const & other) { other.MergeInto(*this); }
void TranslatorCollection::MergeInto(TranslatorCollection & other) const
{

3
generator/translator_collection.hpp
View file

@ -8,7 +8,8 @@
namespace generator
{
// This class allows you to work with a group of translators as with one.
class TranslatorCollection : public CollectionBase<std::shared_ptr<TranslatorInterface>>, public TranslatorInterface
class TranslatorCollection : public CollectionBase<std::shared_ptr<TranslatorInterface>>,
public TranslatorInterface
{
public:
// TranslatorInterface overrides:

63
generator/translator_country.cpp
View file

@ -21,8 +21,8 @@
#include "platform/platform.hpp"
#include "base/file_name_utils.hpp"
#include "base/assert.hpp"
#include "base/file_name_utils.hpp"
#include <cctype>
#include <cstdint>
@ -39,7 +39,9 @@ class RelationCollector
{
public:
explicit RelationCollector(std::shared_ptr<CollectorInterface> const & collectors)
: m_collectors(collectors) {}
: m_collectors(collectors)
{
}
template <class Reader>
base::ControlFlow operator()(uint64_t id, Reader & reader)
@ -79,35 +81,50 @@ TranslatorCountry::TranslatorCountry(std::shared_ptr<FeatureProcessorInterface>
std::shared_ptr<cache::IntermediateData> const & cache,
feature::GenerateInfo const & info, bool needMixTags)
: Translator(processor, cache, std::make_shared<FeatureMaker>(cache))
, m_tagAdmixer(std::make_shared<TagAdmixer>(info.GetIntermediateFileName("ways", ".csv"), info.GetIntermediateFileName("towns", ".csv")))
, m_tagReplacer(std::make_shared<TagReplacer>(base::JoinPath(GetPlatform().ResourcesDir(), REPLACED_TAGS_FILE)))
, m_tagAdmixer(std::make_shared<TagAdmixer>(info.GetIntermediateFileName("ways", ".csv"),
info.GetIntermediateFileName("towns", ".csv")))
, m_tagReplacer(std::make_shared<TagReplacer>(
base::JoinPath(GetPlatform().ResourcesDir(), REPLACED_TAGS_FILE)))
{
if (needMixTags)
m_osmTagMixer = std::make_shared<OsmTagMixer>(base::JoinPath(GetPlatform().ResourcesDir(), MIXED_TAGS_FILE));
{
m_osmTagMixer = std::make_shared<OsmTagMixer>(
base::JoinPath(GetPlatform().ResourcesDir(), MIXED_TAGS_FILE));
}
auto filters = std::make_shared<FilterCollection>();
filters->Append(std::make_shared<FilterPlanet>());
filters->Append(std::make_shared<FilterElements>(base::JoinPath(GetPlatform().ResourcesDir(), SKIPPED_ELEMENTS_FILE)));
filters->Append(std::make_shared<FilterElements>(
base::JoinPath(GetPlatform().ResourcesDir(), SKIPPED_ELEMENTS_FILE)));
SetFilter(filters);
auto collectors = std::make_shared<CollectorCollection>();
collectors->Append(std::make_shared<feature::MetalinesBuilder>(info.GetIntermediateFileName(METALINES_FILENAME)));
collectors->Append(std::make_shared<CityAreaCollector>(info.GetIntermediateFileName(CITIES_AREAS_TMP_FILENAME)));
// These are the four collector that collect additional information for the future building of routing section.
collectors->Append(std::make_shared<MaxspeedsCollector>(info.GetIntermediateFileName(MAXSPEEDS_FILENAME)));
collectors->Append(std::make_shared<routing::RestrictionWriter>(info.GetIntermediateFileName(RESTRICTIONS_FILENAME), cache->GetCache()));
collectors->Append(std::make_shared<routing::RoadAccessWriter>(info.GetIntermediateFileName(ROAD_ACCESS_FILENAME)));
collectors->Append(std::make_shared<routing::CameraCollector>(info.GetIntermediateFileName(CAMERAS_TO_WAYS_FILENAME)));
collectors->Append(std::make_shared<CrossMwmOsmWaysCollector>(info.m_intermediateDir, info.m_targetDir, info.m_haveBordersForWholeWorld));
collectors->Append(std::make_shared<feature::MetalinesBuilder>(
info.GetIntermediateFileName(METALINES_FILENAME)));
collectors->Append(
std::make_shared<CityAreaCollector>(info.GetIntermediateFileName(CITIES_AREAS_TMP_FILENAME)));
// These are the four collector that collect additional information for the future building of
// routing section.
collectors->Append(
std::make_shared<MaxspeedsCollector>(info.GetIntermediateFileName(MAXSPEEDS_FILENAME)));
collectors->Append(std::make_shared<routing::RestrictionWriter>(
info.GetIntermediateFileName(RESTRICTIONS_FILENAME), cache->GetCache()));
collectors->Append(std::make_shared<routing::RoadAccessWriter>(
info.GetIntermediateFileName(ROAD_ACCESS_FILENAME)));
collectors->Append(std::make_shared<routing::CameraCollector>(
info.GetIntermediateFileName(CAMERAS_TO_WAYS_FILENAME)));
collectors->Append(std::make_shared<CrossMwmOsmWaysCollector>(
info.m_intermediateDir, info.m_targetDir, info.m_haveBordersForWholeWorld));
if (info.m_genAddresses)
collectors->Append(std::make_shared<CollectorAddresses>(info.GetAddressesFileName()));
if (!info.m_idToWikidataFilename.empty())
collectors->Append(std::make_shared<CollectorTag>(info.m_idToWikidataFilename, "wikidata" /* tagKey */, WikiDataValidator));
{
collectors->Append(std::make_shared<CollectorTag>(info.m_idToWikidataFilename,
"wikidata" /* tagKey */, WikiDataValidator));
}
SetCollector(collectors);
}
std::shared_ptr<TranslatorInterface>
TranslatorCountry::Clone() const
std::shared_ptr<TranslatorInterface> TranslatorCountry::Clone() const
{
auto copy = Translator::CloneBase<TranslatorCountry>();
copy->m_tagAdmixer = m_tagAdmixer;
@ -126,15 +143,9 @@ void TranslatorCountry::Preprocess(OsmElement & element)
CollectFromRelations(element);
}
void TranslatorCountry::Merge(TranslatorInterface const & other)
{
other.MergeInto(*this);
}
void TranslatorCountry::Merge(TranslatorInterface const & other) { other.MergeInto(*this); }
void TranslatorCountry::MergeInto(TranslatorCountry & other) const
{
MergeIntoBase(other);
}
void TranslatorCountry::MergeInto(TranslatorCountry & other) const { MergeIntoBase(other); }
void TranslatorCountry::CollectFromRelations(OsmElement const & element)
{

2
generator/translator_country.hpp
View file

@ -21,7 +21,7 @@ namespace generator
// The TranslatorArea class implements translator for building countries.
class TranslatorCountry : public Translator
{
public:
public:
explicit TranslatorCountry(std::shared_ptr<FeatureProcessorInterface> const & processor,
std::shared_ptr<cache::IntermediateData> const & cache,
feature::GenerateInfo const & info, bool needMixTags = false);

11
generator/translator_factory.hpp
View file

@ -21,16 +21,13 @@ enum class TranslatorType
};
template <class... Args>
std::shared_ptr<TranslatorInterface> CreateTranslator(TranslatorType type, Args&&... args)
std::shared_ptr<TranslatorInterface> CreateTranslator(TranslatorType type, Args &&... args)
{
switch (type)
{
case TranslatorType::Coastline:
return create<TranslatorCoastline>(std::forward<Args>(args)...);
case TranslatorType::Country:
return create<TranslatorCountry>(std::forward<Args>(args)...);
case TranslatorType::World:
return create<TranslatorWorld>(std::forward<Args>(args)...);
case TranslatorType::Coastline: return create<TranslatorCoastline>(std::forward<Args>(args)...);
case TranslatorType::Country: return create<TranslatorCountry>(std::forward<Args>(args)...);
case TranslatorType::World: return create<TranslatorWorld>(std::forward<Args>(args)...);
}
UNREACHABLE();
}

30
generator/translator_world.cpp
View file

@ -3,8 +3,8 @@
#include "generator/collector_interface.hpp"
#include "generator/feature_maker.hpp"
#include "generator/filter_collection.hpp"
#include "generator/filter_planet.hpp"
#include "generator/filter_elements.hpp"
#include "generator/filter_planet.hpp"
#include "generator/filter_world.hpp"
#include "generator/generate_info.hpp"
#include "generator/intermediate_data.hpp"
@ -25,20 +25,24 @@ TranslatorWorld::TranslatorWorld(std::shared_ptr<FeatureProcessorInterface> cons
std::shared_ptr<cache::IntermediateData> const & cache,
feature::GenerateInfo const & info, bool needMixTags)
: Translator(processor, cache, std::make_shared<FeatureMaker>(cache))
, m_tagAdmixer(std::make_shared<TagAdmixer>(info.GetIntermediateFileName("ways", ".csv"), info.GetIntermediateFileName("towns", ".csv")))
, m_tagReplacer(std::make_shared<TagReplacer>(base::JoinPath(GetPlatform().ResourcesDir(), REPLACED_TAGS_FILE)))
, m_tagAdmixer(std::make_shared<TagAdmixer>(info.GetIntermediateFileName("ways", ".csv"),
info.GetIntermediateFileName("towns", ".csv")))
, m_tagReplacer(std::make_shared<TagReplacer>(
base::JoinPath(GetPlatform().ResourcesDir(), REPLACED_TAGS_FILE)))
{
if (needMixTags)
m_osmTagMixer = std::make_shared<OsmTagMixer>(base::JoinPath(GetPlatform().ResourcesDir(), MIXED_TAGS_FILE));
{
m_osmTagMixer = std::make_shared<OsmTagMixer>(
base::JoinPath(GetPlatform().ResourcesDir(), MIXED_TAGS_FILE));
}
auto filters = std::make_shared<FilterCollection>();
filters->Append(std::make_shared<FilterPlanet>());
filters->Append(std::make_shared<FilterElements>(base::JoinPath(GetPlatform().ResourcesDir(), SKIPPED_ELEMENTS_FILE)));
filters->Append(std::make_shared<FilterElements>(
base::JoinPath(GetPlatform().ResourcesDir(), SKIPPED_ELEMENTS_FILE)));
SetFilter(filters);
}
std::shared_ptr<TranslatorInterface>
TranslatorWorld::Clone() const
std::shared_ptr<TranslatorInterface> TranslatorWorld::Clone() const
{
auto copy = Translator::CloneBase<TranslatorWorld>();
copy->m_tagAdmixer = m_tagAdmixer;
@ -56,13 +60,7 @@ void TranslatorWorld::Preprocess(OsmElement & element)
m_osmTagMixer->Process(element);
}
void TranslatorWorld::Merge(TranslatorInterface const & other)
{
other.MergeInto(*this);
}
void TranslatorWorld::Merge(TranslatorInterface const & other) { other.MergeInto(*this); }
void TranslatorWorld::MergeInto(TranslatorWorld & other) const
{
MergeIntoBase(other);
}
void TranslatorWorld::MergeInto(TranslatorWorld & other) const { MergeIntoBase(other); }
} // namespace generator