RecordHelper.h

Go to the documentation of this file.

#ifndef CondTools_L1Trigger_RecordHelper_h
#define CondTools_L1Trigger_RecordHelper_h
// -*- C++ -*-
//
// Package:     L1Trigger
// Class  :     RecordHelper
// 
#include <boost/type_traits.hpp>

#include "RelationalAccess/ICursor.h"
#include "CoralBase/AttributeList.h"
#include "CoralBase/AttributeSpecification.h"
#include "CoralBase/Attribute.h"


std::string upcaseString(std::string aString);

template <class TOutput> class FieldHandlerBase {
public:
  typedef coral::AttributeList AttributeList;
  FieldHandlerBase(const std::string& name) : name_(name) { }

  const std::string& getName() { return name_ ; }

  virtual const std::string getColumnName() { return upcaseString(name_); }

  virtual void  extractValue(const AttributeList& src, TOutput& dest ) = 0;

  virtual ~FieldHandlerBase() { } 
private:
  
  /* The (case sensitive!) name of the field. */
  std::string name_;
};


template <class TOutput, class TCField, class TDBField> class FieldHandler : public FieldHandlerBase<TOutput> {
 public:
  typedef coral::AttributeList AttributeList;
  typedef void (TOutput::*TSetMethod)(const TCField);

  FieldHandler(const std::string& fieldName, 
           TSetMethod setter) : FieldHandlerBase<TOutput>(fieldName), setter_(setter) 
  { }

  virtual void extractValue(const AttributeList& src, TOutput& dest) { 
#ifdef RECORDHELPER_DEBUG
    std::cout << "Parsing field " << this->getName() << " with type " << typeid(TCField).name() ;
#endif
    typedef typename boost::remove_cv<typename boost::remove_reference<TDBField>::type>::type TDBFieldT;
    const TDBFieldT & value = src[this->getColumnName()].template data< TDBFieldT >();
    ((dest).*setter_)(TCField(value));

#ifdef RECORDHELPER_DEBUG
    std::cout << "=" << TCField(value) << std::endl ; 
#endif
  }

 protected:
  TSetMethod setter_;
};

template <class TOutput, char FalseCharacter> class ASCIIBoolFieldHandler : public FieldHandler<TOutput, bool, char> 
{
 public:
  typedef coral::AttributeList AttributeList;
  ASCIIBoolFieldHandler(const std::string& fieldName,
            typename FieldHandler<TOutput,bool,char>::TSetMethod setter) 
    : FieldHandler<TOutput, bool, char>(fieldName, setter)
    {   }

  virtual void extractValue(const AttributeList& src, TOutput& dest)
  {
    char value = src[this->getColumnName()].template data<char>();
#ifdef RECORDHELPER_DEBUG
    std::cout << " .. and "  << this->getColumnName() << " is (in integers) " << (int) value << std::endl;
#endif
    ((dest).*(this->setter_))(value != FalseCharacter);
  }
};


class TStandardGroup;

template <typename TOutput> struct Group {
  typedef TStandardGroup Type;
};

#define RH_ASSIGN_GROUP(TOutput, TGroup) template <> struct Group<TOutput> { \
  typedef TGroup Type;                                                       \
};

/* Generically: We don't mess with types and expect the field types to
   exactly match the database types (sadly, CORAL is rather anal about
   such things). */
template <typename TOutput, 
      typename TGroup, 
      typename TCType> 
struct GroupFieldHandler { 
  typedef FieldHandler<TOutput, TCType, TCType> Type;
};


template <class TOutput> class RecordHelper {
 public: 
  typedef coral::AttributeList AttributeList;
  typedef std::vector<FieldHandlerBase<TOutput>*> FieldVector;

  template <typename TField> void addField(const std::string& fieldName,
                       void (TOutput::*setter)(const TField)) { 
#ifdef RECORDHELPER_DEBUG
    std::cout << "Adding field " << fieldName << ", type = " << typeid(TField).name() << std::endl;    
#endif
    this->fields_.push_back(new typename GroupFieldHandler<TOutput, typename Group<TOutput>::Type , TField>::Type(fieldName, setter));

  }
  
  virtual void extractRecord(const AttributeList& source, TOutput& dest) { 
    for(typename FieldVector::const_iterator it = fields_.begin(); 
    it != fields_.end() ; ++it) { 
      (*it)->extractValue(source, dest);
    }
  }

  virtual std::vector<std::string> getColumnList() {
    std::vector<std::string> colList;
    for(typename FieldVector::const_iterator it = fields_.begin();
    it != fields_.end() ; ++it) {
      colList.push_back((*it)->getColumnName());
    }
    
    return colList;
  }

  virtual ~RecordHelper() { 
    for(typename FieldVector::iterator it = fields_.begin();
    it < fields_.end() ; ++it) { 
      delete *it;
    }
  }
protected:
  FieldVector fields_;
};

#define ADD_FIELD(HELPER, OUTPUT_NAME, FIELD_NAME) \
    HELPER.addField(#FIELD_NAME, &OUTPUT_NAME::set##FIELD_NAME);


#endif