MonitoringSQLManager.h

Go to the documentation of this file.

#ifndef _rdet_MonitoringSQLManager_h_
#define _rdet_MonitoringSQLManager_h_

#include <map>
#include <string>
#include <algorithm>

#include <det/VManager.h>
#include <utl/ErrorLogger.h>
#include <utl/config.h>
#include <utl/ResponseMap.h>
#include <utl/LeapSeconds.h>
#include <boost/lexical_cast.hpp>

#ifdef AUGER_SQLITE_ENABLED
#  include <det/VSQLManager_SQLite.h>
#else
#  include <det/VSQLManager_MySQL.h>
#endif


namespace rdet {

  class MonitoringSQLManager : public det::VSQLManager {

  public:
    MonitoringSQLManager() { }

    virtual ~MonitoringSQLManager() { }

    void Init(const std::string& configLink);

    VMANAGER_GETDATA_CALL(InternalGetData, double)

    VMANAGER_GETDATA_NOTFOUND(int)
    //VMANAGER_GETDATA_NOTFOUND(unsigned long long int)
    VMANAGER_GETDATA_NOTFOUND(std::vector<int>)
    VMANAGER_GETDATA_NOTFOUND(std::string)
    VMANAGER_GETDATA_NOTFOUND(std::vector<double>)
    VMANAGER_GETDATA_NOTFOUND(std::vector<std::string>)
    VMANAGER_GETDATA_NOTFOUND(std::list<double>)
    VMANAGER_GETDATA_NOTFOUND(std::list<int>)
    VMANAGER_GETDATA_NOTFOUND(std::list<std::string>)
    VMANAGER_GETDATA_NOTFOUND(utl::TabulatedFunctionComplexLgAmpPhase)
    VMANAGER_GETDATA_NOTFOUND(std::map<std::string, double>)
    VMANAGER_GETDATA_NOTFOUND(std::vector<bool>)
    VMANAGER_GETDATA_NOTFOUND(std::vector<std::vector<int> >)
    VMANAGER_GETDATA_NOTFOUND(std::list<std::pair<int, int> >)
    VMANAGER_GETDATA_NOTFOUND(std::map<int, utl::TabulatedFunction>)
    VMANAGER_GETDATA_NOTFOUND(utl::TabulatedFunction)

  private:
    template<typename T>
    Status
    InternalGetData(T& returnData, const std::string& componentProperty,
                    const std::string& componentName, const IndexMap& componentIndex)
      const
    {
      if (componentProperty != "monitoring")
        return eNotFound;

      if (componentName == "temperature") {
        if (componentIndex.find("site") == componentIndex.end()) {
          WARNING("no site specified in componentIndex");
          return eNotFound;
        }

        double timeToAverage = 5 * utl::minute;
        if (componentIndex.find("timeToAverage") != componentIndex.end())
          timeToAverage = boost::lexical_cast<double>(componentIndex.find("timeToAverage")->second);
        double precision = 5 * utl::minute;
        if (componentIndex.find("precision") != componentIndex.end())
          precision = boost::lexical_cast<double>(componentIndex.find("precision")->second);
        unsigned int numberOfQueriesToBuffer = 5000;
        if (componentIndex.find("numberOfQueriesToBuffer") != componentIndex.end())
          precision = boost::lexical_cast<int>(componentIndex.find("numberOfQueriesToBuffer")->second);

        returnData = GetTemperature(componentIndex.find("site")->second, timeToAverage,
                                    numberOfQueriesToBuffer, precision);
        return eFound;
      }

      return eNotFound;
    }

    double GetTemperature(const std::string& site, const double timeToAverage,
                          const unsigned int numberOfQueriesToBuffer, const double precision) const;

    bool BufferTemperature(const std::string& site, const double timeToAverage,
                           const unsigned int numberOfQueriesToBuffer) const;

    VMANAGER_GETDATA_HANDLE_DENIED

    // <"site", < <"timestamp", "temperature"> > >
    // stores all bad periods for all station, the station id (e.g. "110" for AERA_10) is the key
    mutable std::map<std::string, std::vector<std::pair<unsigned long, double> > > fTemperatureBuffer;
    // current interval (starttime, stoptime) of temperature buffer
    mutable std::map<std::string, std::pair<unsigned long, unsigned long> > fTemperatureBufferInterval;

  };

}


#endif