JDBReader.hh

Go to the documentation of this file.

#ifndef __JDB_JDBREADER__
#define __JDB_JDBREADER__

#include <string>
#include <vector>

#include "dbclient/KM3NeTDBClient.h"

#include "JLang/JNullStream.hh"
#include "JLang/JEquationParameters.hh"
#include "JLang/JRedirectString.hh"
#include "JROOT/JRootClass.hh"
#include "JROOT/JRootDictionary.hh"
#include "JROOT/JRootStreamer.hh"

#include "JDB/JDBDictionary.hh"



/**
 * \author mdejong
 */
namespace JDATABASE {}
namespace JPP { using namespace JDATABASE; }

namespace JDATABASE {

  using KM3NeT::DB::ResultSet;

  /**
   * Special characters.
   */
  static const std::string SPECIAL_CHARACTERS  =  "!@#$%^&*()-+=[]{};:'\"\\|,.<>/?";


  /**
   * Auxiliary class to read ROOT object from database.
   *
   * Note that the list of columns associated to the template parameter is considered to be permanent.\n
   * If not, the method JDBReader::reset should be called before the next operation.
   */
  template<class T>
  struct JDBReader {
    /**
     * Default constructor.
     */
    JDBReader() :
      object(),
      reader(JLANG::null, JLANG::JEquationParameters(), JDBDictionary::getInstance())
    {}


    /**
     * Reset.
     */
    void reset()
    {
      buffer.clear();
    }


    /**
     * Read ROOT object from result set.
     *
     * \param  rs            result set
     * \return               object
     */
    const T& operator()(ResultSet& rs) 
    {
      using namespace std;
      using namespace JPP;

      object = T();

      if (buffer.empty()) {

        JRootReadableClass cls(object);

        for (size_t i = 0; i != rs.FieldCount(); ++i) {

          string parameter = rs.FieldName(i);

          for (string::const_iterator i = SPECIAL_CHARACTERS.begin(); i != SPECIAL_CHARACTERS.end(); ++i) {
            for (string::size_type pos; (pos = parameter.find(*i)) != string::npos; ) {
              parameter.erase(pos);
            }
          }
        
          buffer.push_back(cls.find(parameter.c_str()));
        }
      }

      for (unsigned int i = 0; i != rs.FieldCount(); ++i) {

        if (buffer[i].is_valid()) {     

          JRedirectString redirect(reader, rs.GetString(i));
      
          reader.getObject(buffer[i]);
        }
      }

      return object;
    }

  private:
    T                  object;
    JROOT::JRootReader reader;

    std::vector<JROOT::JRootReadableClass> buffer;  // field count -> data member
  };


  /**
   * Read ROOT object from result set.
   *
   * \param  rs            result set
   * \param  object        object
   * \return               true if read; else false
   */
  template<class T>
  inline bool operator>>(ResultSet& rs, T& object)
  {
    static JDBReader<T> reader;

    if (rs.Next()) {

      object = reader(rs);

      return true;
    }

    return false;
  }


  /**
   * Read vector of ROOT objects from result set.
   *
   * \param  rs            result set
   * \param  buffer
   * \return               true if read; else false
   */
  template<class JElement_t, class JAllocator_t>
  inline bool operator>>(ResultSet& rs, std::vector<JElement_t, JAllocator_t>& buffer)
  {
    for (JElement_t object; rs >> object; ) {
      buffer.push_back(object);
    }

    return true;
  }
}

#endif