SimpleTableCondition.h

 
#ifndef FRAMEWORK_SIMPLETABLECONDITION_H_
#define FRAMEWORK_SIMPLETABLECONDITION_H_
 
#include <ostream>
#include <vector>
 
#include "Framework/ConditionsObject.h"
#include "Framework/Exception/Exception.h"
 
namespace conditions {
 
class BaseTableCondition : public framework::ConditionsObject {
 public:
  BaseTableCondition(const std::string& name,
                     const std::vector<std::string>& columns)
      : framework::ConditionsObject{name},
        columns_{columns},
        idMask_{0xFFFFFFFFu} {
    columnCount_ = (unsigned int)(columns.size());
  }
 
  unsigned int getColumnNumber(const std::string& colname) const {
    for (unsigned int i = 0; i < columnCount_; i++)
      if (colname == columns_[i]) return i;
    return columnCount_;
  }
 
  unsigned int getColumnCount() const { return columnCount_; }
 
  const std::string& getColumnName(unsigned int icol) const {
    if (icol >= columnCount_) {
      EXCEPTION_RAISE("ConditionsException",
                      std::string("Column index out of range in ") + getName());
    }
    return columns_[icol];
  }
 
  unsigned int getRowId(unsigned int irow) const {
    if (irow >= getRowCount()) {  // raise exception
      EXCEPTION_RAISE("ConditionsException",
                      "Row out of range: " + std::to_string(irow));
    }
    return keys_[irow];
  }
 
  const std::vector<std::string>& getColumnNames() const { return columns_; }
 
  std::size_t getRowCount() const { return keys_.size(); }
 
  void setIdMask(unsigned int mask) { idMask_ = mask; }
 
  unsigned int getIdMask() const { return idMask_; }
 
  virtual std::ostream& streamRow(std::ostream& s, int irow) const {
    return s << keys_[irow];
  }
 
 protected:
  std::size_t findKey(unsigned int id) const;
 
  std::size_t findKeyInsert(unsigned int id) const;
 
  std::vector<std::string> columns_;
  unsigned int columnCount_;
  std::vector<uint32_t> keys_;
  unsigned int idMask_;
};
 
template <class T>
class HomogenousTableCondition : public BaseTableCondition {
 public:
  HomogenousTableCondition(const std::string& name,
                           const std::vector<std::string>& columns)
      : BaseTableCondition(name, columns) {}
 
  virtual ~HomogenousTableCondition() {}
 
  void clear() {
    keys_.clear();
    values_.clear();
  }
 
  void add(unsigned int id, const std::vector<T>& values) {
    if (values.size() != columnCount_) {
      EXCEPTION_RAISE("ConditionsException",
                      getName() + ": Attempted to insert a row with " +
                          std::to_string(values.size()) +
                          " columns into a table with " +
                          std::to_string(columnCount_) + " columns");
    }
    std::size_t loc = findKey(id);
    if (loc != getRowCount()) {
      EXCEPTION_RAISE("ConditionsException",
                      "Attempted to add condition in " + getName() +
                          " for existing id " + std::to_string(id));
    }
    loc = findKeyInsert(id);  // where to put it
 
    // insert into the keys
    keys_.insert(keys_.begin() + loc, id);
    // insert into the values
    values_.insert(values_.begin() + loc * columnCount_, values.begin(),
                   values.end());
  }
 
  T get(unsigned int id, unsigned int col) const {
    std::size_t irow = findKey(id);
    if (col >= columnCount_ || irow == getRowCount()) {  // raise exception
      EXCEPTION_RAISE("ConditionsException",
                      "No such column " + std::to_string(col) + " or id " +
                          std::to_string(id));
    }
    return values_[irow * columnCount_ + col];
  }
 
  std::pair<unsigned int, std::vector<T> > getRow(unsigned int irow) const {
    if (irow >= getRowCount()) {  // raise exception
      EXCEPTION_RAISE("ConditionsException",
                      "Row out of range: " + std::to_string(irow));
    }
    std::vector<T> rv(&(values_[irow * columnCount_]),
                      &(values_[(irow + 1) * columnCount_]));
    return std::pair<unsigned int, std::vector<T> >(keys_[irow], rv);
  }
 
  T getByName(unsigned int id, const std::string& colname) const {
    return get(id, getColumnNumber(colname));
  }
 
  virtual std::ostream& streamRow(std::ostream& s, int irow) const {
    if (irow >= getRowCount()) {  // raise exception
      EXCEPTION_RAISE("ConditionsException",
                      "Row out of range: " + std::to_string(irow));
    }
    s << keys_[irow];
    for (int i = 0; i < columnCount_; i++)
      s << ',' << values_[irow * columnCount_ + i];
    return s << std::endl;
  }
 
 private:
  std::vector<T> values_;  // unrolled array
};
 
class DoubleTableCondition : public HomogenousTableCondition<double> {
 public:
  DoubleTableCondition(const std::string& name,
                       const std::vector<std::string>& columns)
      : HomogenousTableCondition<double>(name, columns) {}
 
  virtual ~DoubleTableCondition() {}
};
 
class IntegerTableCondition : public HomogenousTableCondition<int> {
 public:
  IntegerTableCondition(const std::string& name,
                        const std::vector<std::string>& columns)
      : HomogenousTableCondition<int>(name, columns) {}
 
  virtual ~IntegerTableCondition() {}
};
 
}  // namespace conditions
 
std::ostream& operator<<(std::ostream&, const conditions::BaseTableCondition&);
 
#endif