RChannelSQLManager.h

Go to the documentation of this file.

#ifndef _rdet_RChannelSQLManager_h_
#define _rdet_RChannelSQLManager_h_

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

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

#include <det/Detector.h>
#include <rdet/RDetector.h>
#include <rdet/Station.h>
#include <rdet/RSimulationStationListManager.h>

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


namespace utl {
  class TabulatedFunction;
  class TabulatedFunctionComplexLgAmpPhase;
}

namespace rdet {

  class RChannelSQLManager : public det::VSQLManager {

    struct ChannelIdList {
      std::vector<int> fChannelIds;
      unsigned long int fGpsSecondComission;
      unsigned long int fGpsSecondDecomission;
    };

  public:
    virtual ~RChannelSQLManager() { }

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

    VMANAGER_GETDATA_CALL(InternalGetData, double)
    VMANAGER_GETDATA_CALL(InternalGetData, int)
    VMANAGER_GETDATA_CALL(InternalGetData, std::string)
    VMANAGER_GETDATA_CALL(GetChannelListFromBuffer, std::vector<int>)
    VMANAGER_GETDATA_CALL(GetTFCLAPData, utl::TabulatedFunctionComplexLgAmpPhase)
    VMANAGER_GETDATA_CALL(GetDataMap, std::map<std::string, double>)

    //VMANAGER_GETDATA_NOTFOUND(unsigned long long int)
    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(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)

    Status GetChannelListFromBuffer(std::vector<int>& returnData,
                                    const std::string& componentProperty,
                                    const std::string& componentName,
                                    const IndexMap& componentIndex) const;

    Status GetTFCLAPData(utl::TabulatedFunctionComplexLgAmpPhase& returnData,
                   const std::string& componentProperty,
                   const std::string& componentName,
                   const IndexMap& componentIndex) const;

    Status GetDataMap(std::map<std::string,double>& returnData,
                   const std::string& componentProperty,
                   const std::string& componentName,
                   const IndexMap& componentIndex) const;

    VMANAGER_GETDATA_HANDLE_DENIED

  private:
    typedef std::map<std::string, std::string> ComponentMap;
    typedef std::pair<std::string, std::string> Index;

    template<typename T>
    Status
    InternalGetData(T& returnData,
                    const std::string& componentProperty,
                    const std::string& componentName,
                    const IndexMap& componentIndex) 
      const
    {
      if (componentProperty == "addSStationList") {
        returnData = boost::lexical_cast<T>(0);
        return eFound;
      }

      if (componentName != "RChannel" && componentName != "RADC" && componentName != "RResponseMapList")
        return eNotFound;
      
      // if ComponentMap is not filled for this Station/Channel given by IndexMap
      Index currentComponent(componentIndex.find("station")->second,
                             componentIndex.find("channel")->second);

      // returns eNotFound if the station description is not suppose to be from SQL
      if (RSimulationStationListManager::GetSourceType(currentComponent.first) != "SQL")
        return eNotFound;

      // std::cout << "ChannelSQL InternalGetData: " << componentProperty << " " << componentName << std::endl;

      std::string temp = "";
      Status resultStatus = GetComponentFromBuffer(temp, currentComponent, componentProperty);
      if (resultStatus == eFound) {
        returnData = boost::lexical_cast<T>(temp);
        return eFound;
      }
      return eNotFound;
    }

    void FillComponentMap(const IndexMap& componentIndex) const;

    void BufferComponentMap() const;

    VManager::Status GetComponentFromBuffer(std::string& returnData,
                                            const Index& componentIndex,
                                            const std::string& componentProperty) const;

    void BufferChannelList() const;

    mutable ComponentMap fComponentMap; 
    mutable IndexMap fIndexMap;         
    mutable std::map<Index, ComponentMap> fBuffer; // buffer for channel data

    mutable std::map<int, ChannelIdList> fBufferChannelIdLists;

  };

}


#endif