GeoReader.h

// Copyright 2012, University of Freiburg
// Anton Stepan <stepana@informatik.uni-freiburg.de>
// Marius Bethge <marius.bethge@gmail.com>

#ifndef TRUNK_GEONAMES_GEOREADER_V2_GEOREADER_H_
#define TRUNK_GEONAMES_GEOREADER_V2_GEOREADER_H_

#include <gtest/gtest.h>
#include <assert.h>
#include <chrono>
#include <unordered_map>
#include <getopt.h>
#include <algorithm>
#include <fstream>
#include <sstream>
#include <iostream>
#include <string>
#include <vector>
#include "./Location.h"
#include "./Country.h"

using std::string;

class GeoReader {
 public:
  GeoReader();

  void setStandardParameters();
  // Prints Usageinfo to error stream.
  void printUsage();
  void printError(const string& errorMessage);
  // Parses commandline arguments. Returns true on success.
  bool parseCommandlineArguments(int argc, char** argv);
  // Read countryInfo-file/asciiAdmin1-file/admin2-file and fill the
  // "_<FeatureType>" and "_<FeatureType>Lookup" maps, respectively.
  void readCountryFile();
  FRIEND_TEST(GeoReaderTest, readCountryFile);
  void readAdmin1File();
  FRIEND_TEST(GeoReaderTest, readAdmin1File);
  void readAdmin2File();
  FRIEND_TEST(GeoReaderTest, readAdmin2File);
  // Reads and processes the allCountries file. Thereby complementing the
  // _cities, _admin1s and _admin2s maps.
  void readAllCountries();
  FRIEND_TEST(GeoReaderTest, readAllCountries);
  // Marks those locations, that have the same name as other entities in the
  // ontology, e.g. the city Homer and the pilosopher Homer. Also marks
  // locations, that have the same name as countries.
  void markReservedNames();
  FRIEND_TEST(GeoReaderTest, markReservedNames);
  // Adds suffixes to locations as needed.
  void generateSuffixes();
  FRIEND_TEST(GeoReaderTest, generateSuffixes);

  // Generate files
  void generateIsA(const std::string& filename);
  void generateLocatedIn(const std::string& filename);
  void generateHasPopulation(const std::string& filename);
  void generateHasLongitude(const std::string& filename);
  void generateHasLatitude(const std::string& filename);
  void generateHasCapital(const std::string& filename);

  // Getter
  string getAllCountriesFileName() const { return _allCountriesFileName; }
  string getNoLocationFileName() const { return _noLocationFileName; }
  string getCountryInfoFileName() const { return _countryInfoFileName; }
  string getAdmin1FileName() const { return _admin1FileName; }
  string getAdmin2FileName() const { return _admin2FileName; }
  string getOutputDir() const { return _outputDir; }

 private:
  // map<"countryID", "geonamesID">
  std::unordered_map<string, int> _countryLookup;
  // map<"admin1ID", "geonamesID">
  std::unordered_map<string, int> _admin1Lookup;
  // map<"admin2ID", "geonamesID">
  std::unordered_map<string, int> _admin2Lookup;

  // map<"geonamesID", Country>
  std::unordered_map<int, Country> _countries;
  // map<"geonamesID", Location>
  std::unordered_map<int, Location> _admin1s;
  std::unordered_map<int, Location> _admin2s;
  std::unordered_map<int, Location> _cities;

  // List of pointers to capitals stored in _cities.
  std::vector<Location*> _capitals;

  // Map of all the names, that shall not be used by locations
  // because other entities already use them.
  std::unordered_map<string, bool> _blackList;
  // creating file (delets existing) with content from stream.
  void addToFile(const string& fileName, const std::ostringstream& text) const;
  // For a list of locations with the same name: gives suffixes as necessary to
  // the locations making them uniquely identifiable.
  void suffixGenerator(std::vector<Location*> duplicates);
  // Generates and returns suffix-string for given Location + FeatureType
  // combination. Does not change modify the Location.
  const string sufString(const Location* ptr, const FeatureType f) const;
  const string sufString(const Location* ptr, const FeatureType f,
                         const int& i) const;
  // helper
  const bool isBListed(const string& s) const;
  std::string _generateLatitude(Location* loc);
  std::string _generateLongitude(Location* loc);
  std::string _generatePopulation(Location* loc);
  std::string _generatePopulation(Country* loc);
  // Options
  string _allCountriesFileName = "";
  string _noLocationFileName = "";
  string _countryInfoFileName = "";
  string _admin1FileName = "";
  string _admin2FileName = "";
  string _outputDir = "./";
  std::vector<std::string> _locationClasses;
  int _populationLimit = 999;
};

#endif  // TRUNK_GEONAMES_GEOREADER_V2_GEOREADER_H_