JDB/JSelector.hh

Go to the documentation of this file.

#ifndef __JDB_JSELECTOR__
#define __JDB_JSELECTOR__
 
#include <istream>
#include <ostream>
#include <string>
#include <vector>
 
#include "JLang/JException.hh"
#include "JLang/JLangToolkit.hh"
#include "JMath/JMath.hh"
 
#include "KM3NeTDBClient.h"
 
 
/**
 * \author mdejong
 */
 
namespace JDATABASE {};
namespace JPP { using namespace JDATABASE; }
 
namespace JDATABASE {
 
  using JLANG::JIndexOutOfRange;
  using KM3NeT::DB::Selector;
 
 
  /**
   * Available operands.
   */
  static const Selector::RelOp* const OPERAND[] = 
    {
      &Selector::RelOp::Equal,
      &Selector::RelOp::Different,
      &Selector::RelOp::Less,
      &Selector::RelOp::LessEqual,
      &Selector::RelOp::Greater,
      &Selector::RelOp::GreaterEqual
    };
 
 
  /**
   * Number of available operands.
   */
  static const int NUMBER_OF_OPERANDS = sizeof(OPERAND) / sizeof(OPERAND[0]);
 
 
  /**
   * Get operand.
   *
   * \param  index          index
   * \return                operand
   */
  inline const Selector::RelOp& getOperand(const int index)
  {
    if (index >= 0 && index <= NUMBER_OF_OPERANDS)
      return *OPERAND[index];
    else
      THROW(JIndexOutOfRange, "Invalid index " << index);
  }
 
 
  /**
   * Auxiliary class for specifying selection of database data.
   */
  class JSelector :
    public std::vector<Selector>,
    public JMATH::JMath<JSelector>
  {
  public:
    /**
     * End-of-line.
     */
    static const char EOL = ';';    
 
 
    /**
     * Default constructor.
     */
    JSelector()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  key            key
     * \param  value          value
     * \param  operand        operand
     */
    template<class T>
    JSelector(const std::string& key, const T value, const Selector::RelOp& operand = Selector::RelOp::Equal) 
    {
      add(key, value, operand);
    }
 
 
    /**
     * Constructor.
     *
     * \param  data_member    data member
     * \param  value          value
     * \param  operand        operand
     */
    template<class JClass_t, class JType_t>
    JSelector(JType_t JClass_t::*data_member, const JType_t value, const Selector::RelOp& operand = Selector::RelOp::Equal) 
    {
      add(data_member, value, operand);
    }
 
 
    /**
     * Constructor.
     *
     * \param  data_member    data member
     * \param  value          value
     * \param  operand        operand
     */
    template<class JClass_t>
    JSelector(std::string JClass_t::*data_member, const std::string value, const Selector::RelOp& operand = Selector::RelOp::Equal) 
    {
      add(data_member, value, operand);
    }
 
 
    /**
     * Add selection.
     *
     * \param  selection      selection
     * \return                this selection
     */
    JSelector& add(const JSelector& selection)
    {
      using namespace std;
 
      copy(selection.begin(), selection.end(), back_inserter(*this));
 
      return *this;
    }
 
 
    /**
     * Add selection.
     *
     * \param  key            key
     * \param  value          value
     * \param  operand        operand
     * \return                this selection
     */
    template<class T>
    JSelector& add(const std::string& key, const T value, const Selector::RelOp& operand = Selector::RelOp::Equal) 
    {
      using namespace std;
 
      ostringstream os;
 
      os << value;
 
      push_back(Selector(key.c_str(), os.str().c_str(), operand));
 
      return *this;
    }
 
 
    /**
     * Add selection.
     *
     * \param  data_member    data member
     * \param  value          value
     * \param  operand        operand
     * \return                this selection
     */
    template<class JClass_t, class JType_t>
    inline JSelector& add(JType_t JClass_t::*data_member, const JType_t value, const Selector::RelOp& operand = Selector::RelOp::Equal) 
    {
      return add(getColumn(data_member), value, operand);
    }
 
 
    /**
     * Add selection.
     *
     * \param  data_member    data member
     * \param  value          value
     * \param  operand        operand
     * \return                this selection
     */
    template<class JClass_t>
    inline JSelector& add(std::string JClass_t::*data_member, const std::string& value, const Selector::RelOp& operand = Selector::RelOp::Equal) 
    {
      return add(getColumn(data_member), value, operand);
    }
 
 
    /**
     * Read selector from input stream.
     *
     * \param  in             input stream
     * \param  selector       selector
     * \return                input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JSelector& selector) 
    {
      using namespace std;
      using namespace JPP;
 
      string buffer;
 
      getline(in, buffer, JSelector::EOL);
 
      int operand = -1;
 
      for (int i = 0; i != NUMBER_OF_OPERANDS; ++i) {
 
        string::size_type pos = buffer.find(getOperand(i).Render());
 
        if (pos != string::npos && (operand == -1 || getOperand(i).Render().length() > getOperand(operand).Render().length())) {
          operand = i;
        }
      }
 
      if (operand != -1) {
 
        string::size_type pos = buffer.find(getOperand(operand).Render());
 
        selector.push_back(Selector(JPP::trim(buffer.substr(0, pos)).c_str(),
                                    JPP::trim(buffer.substr(pos + getOperand(operand).Render().length())).c_str(),
                                    getOperand(operand)));
 
      } else {
 
        in.setstate(ios::badbit);
      }
 
      return in;
    }
    
    
    /**
     * Write selector to output stream.
     *
     * \param  out            output stream
     * \param  selector       selector
     * \return                output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JSelector& selector) 
    {
      for (const_iterator i = selector.begin(); i != selector.end(); ++i) {
        out << i->Name << i->RelationalOperator.Render()  << i->Value << JSelector::EOL << std::endl;
      }
 
      return out;
    }
  };
}
 
#endif