StDbFieldI.h

/*
 * StDbFieldI.h
 *
 * Created on Aug 20, 2007
 *
 * Author: Zhengqiang Liang (Wayne State University)
 *            Valeri Fine (Brookhaven National Laboratory)
 *            Jerome Lauret (Brookhaven National Laboratory)
 *            
 *
 * This file is part of the UCM project funded under an SBIR
 * Copyright (c) 2007-2008 STAR Collaboration - Brookhaven National Laboratory
 *
 * @(#)cpp/api:$Id: StDbFieldI.h,v 1.4 2010/03/30 20:05:36 fine Exp $
 *
 *
 *
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * STAR Scheduler is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with STAR Scheduler; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
#ifndef STDBFIELD_H
#define STDBFIELD_H

#include <string>
#include <sstream>
#include <map>
#include <typeinfo>

#include "StDataException.h"
#include "FieldList.h"

namespace TxLogging {
class Init_StDbFieldI;

class StDbFieldI {
 friend class TxLogging::Init_StDbFieldI;
 public:
  enum EDataType {
    kINVALID=0,
    kBOOL,
    kINT,
    kUINT,
    kLONG,
    kULONG,
    kDOUBLE,
    kCHAR,
    kUNIXTIME,
    kSTRING,
    kEND
  };

 public:

  StDbFieldI(const char* name, StDbFieldI::EDataType type, int length=0);

    // StDbFieldI(const char* name, void *value, int length=0);

  StDbFieldI(const char* name, const char* value,
          StDbFieldI::EDataType type, int length=0);

  StDbFieldI(const StDbFieldI& );
  const StDbFieldI& operator=(const StDbFieldI& );

  virtual ~StDbFieldI();
               
  const char* getName() const;

  const char* fieldAsString() const;

   void setValue(const int           &value);
   void setValue(const unsigned int  &value);
   void setValue(const long          &value);
   void setValue(const unsigned long &value);
   void setValue(const double        &value);
   void setValue(const char          &value);
  //  void setValue(const std::string   &value);
   
   int           toInt() const;
   unsigned      toUInt() const;
   long          toLong() const;
   unsigned long toULong() const;
   double        toDouble() const;
   char          toChar() const;
   // const std::string toString() const;
  void setValueFromString(const char* strValue);

  EDataType getType() const;

  int getMaxLength() const;

  const char*getTypeAsString() const;
  
  const char*getValueAsString() const;

  bool isNull() const;

  void setNull(bool Nil);

  void setIgnore(bool ignore);

  bool isIgnore() const;
  
 protected:
   template<class T> 
   StDbFieldI(const char* name, const T &value, int length);


   template <class T>
   void setValue(const T &value);
 
   template <class T>
   T toValue() const;

 private:
  void copy(const StDbFieldI &f);
  template<class T> void typeMatches() const;

 private:
  static void MakeTypeMap();
  std::string fName;
  EDataType fType;
  std::string fEncodedValue;
  size_t fMaxLength;
  bool fNull;
  bool fIgnore;
  static std::map<EDataType,std::string> fTypeMap;
  static std::map<EDataType,std::string> fTypeMapName;
  static std::map<std::string,EDataType> fTypeMapInv;
};


//---------------
// BEGIN TEMPLATE FUNCTION DEFINITIONS:
// Note that this is required by the gcc linker to properly link templated
// functions.
//---------------

//_______________________________________________________________________________
template<class T> StDbFieldI::StDbFieldI(const char* name, const T &value, int length)
  : fType(kINVALID),
    fNull(true),
    fEncodedValue(""),
    fMaxLength(length),
    fIgnore(true),
    fName(name)
{
  if (std::string(name).empty()) {
    throw StDataException("Attempted to define field with empty name.",
                          StDataException::FIELD,
                          StUCMException::ERROR);
  }
  setValue(value);
}


//_______________________________________________________________________________
template <class T> void
StDbFieldI::setValue(const T &value)
{
  typeMatches<T>();

  // Convert value to string
  std::ostringstream encodingStream;
  encodingStream << value;

  // If we have a string type..
  if ( fType == kSTRING ) {
    if ( encodingStream.str().length() > fMaxLength ) {
      std::ostringstream lenStr;
      lenStr << fMaxLength;
      
      // Conversion to std::string is safe, but potentially redundant
      throw StDataException("Invalid value for field '" + fName
                             + "': Length of string '" + encodingStream.str() 
                             + "' is longer than variant length '" 
                             + lenStr.str() + "'.",
                            StDataException::FIELD,
                            StUCMException::ERROR);
    }
  }

  fEncodedValue = encodingStream.str();
  fNull         = false;
  fIgnore       = false;
}


//_______________________________________________________________________________
template<class T> 
T StDbFieldI::toValue() const
{
  typeMatches<T>();

  std::istringstream decodingStream(fEncodedValue);
  T realValue;

  decodingStream >> realValue;
  return realValue;
}

//_______________________________________________________________________________
template<class T> void
StDbFieldI::typeMatches() const 
{
   // Massive check: If the provided type T does not match the stored
   // data type, throw an exception.
   std::map<EDataType,std::string>::const_iterator t  =  fTypeMap.find(getType());

   if (t == fTypeMap.end()) {
   throw StDataException( "Type mismatch in field '" + fName + "': Actual type " 
           + getTypeAsString() + std::string(", requested type ") 
           + typeid(T).name(),
            StDataException::FIELD,
            StUCMException::ERROR);
  }
}
}
#endif