SStationListSQLManager.cc

Go to the documentation of this file.

#include <map>
#include <boost/lexical_cast.hpp>
#include <sdet/SStationListSQLManager.h>
#include <sdet/SManagerRegister.h>
#include <utl/UTCDateTime.h>

using namespace std;
using namespace sdet;
using namespace det;
using namespace utl;
using namespace boost;


REGISTER_S_MANAGER("SStationListSQLManager", SStationListSQLManager);


namespace sdet {

  struct UTMData {
    string fEllipsoid;
    int fZone = 0;
    string fBand;
  };


  string
  Utf8To7Bit(const string& str)
  {
    ostringstream res;

    for (string::const_iterator it = str.begin(); it != str.end(); ++it) {
      const int i = (unsigned char)(*it);
      switch (i) {
      // ntilde; appears in two ways: 0xf1 and 0xc3b1
      case 195:
        ++it;
        if (it != str.end() && int((unsigned char)(*it)) == 177)
          res << "~n";
        break;
      case 241:
        res << "~n";
        break;
      default:
        // drop unprintable chars
        if (32 <= i && i < 127)
          res << *it;
        break;
      }
    }

    return res.str();
  }


  void
  SStationListSQLManager::Init(const string& configLink)
  {
    // first call shadowed VManager::Init()
    VSQLManager::Init(configLink);

    typedef map<unsigned int, UTMData> UTMDataMap;

    UTMDataMap utmMap;

    ostringstream query;
    query
      << "SELECT utm_data_id, ellipsoid, zone, band "
         "FROM utm_data "
         "ORDER BY utm_data.last_modified DESC";

    if (Query(query.str(), QueryInfoMessage("all utm_data", "utm_data")) == eNotFound ||
        NumRows() < 1) {
      const string err = "Can not find UTM data!";
      throw DataNotFoundInDBException(err);
    }

    {
      // insert only earliest entry
      tuple<int, string, int, string> utmId_ellipsoid_zone_band;
      UTMData utm;
      while (FetchNextRowMany(utmId_ellipsoid_zone_band) == eFound) {
        const int& utmId = utmId_ellipsoid_zone_band.get<0>();
        if (utmMap.find(utmId) == utmMap.end()) {
          utm.fEllipsoid = utmId_ellipsoid_zone_band.get<1>();
          utm.fZone = utmId_ellipsoid_zone_band.get<2>();
          utm.fBand = utmId_ellipsoid_zone_band.get<3>();
          utmMap[utmId] = utm;
        }
      }
    }

    query.str("");
    query
      << "SELECT "
         "utm_data_id, "
         "station_id, "
         "northing, "
         "easting, "
         "altitude, "
         "name, "
         "commission, "
         "decommission, "
         "inGrid, "
         "in_pair, "       // -> fGroupId
         "axis_1, "
         "axis_2 "
         "FROM station_list "
         "ORDER BY station_id ASC, last_modified DESC";

    if (Query(query.str(), QueryInfoMessage("all station_list", "station_list")) == eNotFound ||
        NumRows() < 1) {
      const string err = "No station_list SQL data found!";
      throw DataNotFoundInDBException(err);
    }

    // this query has to be parsed low-level since boost::tuple supports only up to
    // 10 types in template parameters
    MYSQL_ROW row;
    while ((row = FetchRow())) {

      if (NumFields() != 12) {
        const string err = "Not enogh fields while getting whole station_list";
        throw DataNotFoundInDBException(err);
      }

      int column = 0;

      const unsigned int utmId = lexical_cast<unsigned int>(row[column++]);

      SStationListManager::StationData station;

      station.fId = lexical_cast<int>(row[column++]);

      if (fStationManager.HasStationData(station.fId))
        continue;

      const UTMDataMap::const_iterator utmIt = utmMap.find(utmId);
      if (utmIt == utmMap.end()) {
        const string err = "Unknown UTM id!";
        throw DataNotFoundInDBException(err);
      }

      const UTMData& utm = utmIt->second;

      station.fEllipsoid = utm.fEllipsoid;
      station.fZone = utm.fZone;
      station.fBand = utm.fBand;

      station.fNorthing = lexical_cast<double>(row[column++]);
      station.fEasting = lexical_cast<double>(row[column++]);
      station.fAltitude = lexical_cast<double>(row[column++]);
      station.fName = Utf8To7Bit(lexical_cast<string>(row[column++]));

      station.fCommissionTime =
        lexical_cast<string>(UTCDateTime(TimeStamp(lexical_cast<int>(row[column++]))));

      station.fDecommissionTime =
        lexical_cast<string>(UTCDateTime(TimeStamp(lexical_cast<int>(row[column++]))));

      station.fInGrid = lexical_cast<int>(row[column++]);
      station.fGroupId = lexical_cast<int>(row[column++]);
      station.fAxis1 = lexical_cast<int>(row[column++]);
      station.fAxis2 = lexical_cast<int>(row[column++]);

      fStationManager.ConditionalAddStationData(station);

    }

    FreeResult();

    // close SQL to save one connection
    Close();
  }

}