QVdt.hh

Go to the documentation of this file.

 
#ifndef _Q_VDT_H
#define _Q_VDT_H
#include <string>
#include <iostream>
#include <set>
#include <vector>
#include "QDiana.hh"
 
 
class QVdt {
 
  public:
      
    enum QVdt_type {
      Int_QVdt = 'I',
      Double_QVdt = 'F',
      String_QVdt = 'S',
      Vector_QVdt = 'V',
      Unassigned_QVdt = 'U'
    };
 
    typedef std::vector<QVdt> QVdt_vector;
 
    QVdt (): type_internal(Unassigned_QVdt), name_s("") { }
    
    QVdt (const std::string& value, const std::string& name = "", QVdt_type type = Unassigned_QVdt);
    
    QVdt (long int value): name_s("") {  value_i = value; type_internal = Int_QVdt; fBuiltFromString = false;}
    
    QVdt (double value): name_s("") {  value_f = value; type_internal = Double_QVdt; fBuiltFromString = false;}
    
    template<typename V> QVdt (const std::vector<V, std::allocator<V> >& value): name_s("") { // This should stay in .cc file, but
                                                                                             // gcc does not have export for templates
      
      type_internal = Vector_QVdt;
      std::back_insert_iterator<std::vector<QVdt> > inserter(value_v);
      std::copy (value.begin (), value.end (), inserter);
      fBuiltFromString = false;
    }
      // Since cast is not called in some onstructor operator these methods are necessary
    QVdt (int value): name_s("") { value_i = value; type_internal = Int_QVdt; fBuiltFromString = false;}
    
    QVdt (short value): name_s("") { value_i = value; type_internal = Int_QVdt; fBuiltFromString = false;}
    
    QVdt (char value): name_s("") { value_i = value; type_internal = Int_QVdt; fBuiltFromString = false;}
    QVdt (unsigned long value): name_s("") { value_i = value; type_internal = Int_QVdt; fBuiltFromString = false;}
    QVdt (unsigned short value): name_s("") { value_i = value; type_internal = Int_QVdt; fBuiltFromString = false;}
    QVdt (unsigned char value): name_s("") { value_i = value; type_internal = Int_QVdt; fBuiltFromString = false;}
    QVdt (float value): name_s("") { value_f = value; type_internal = Double_QVdt; fBuiltFromString = false;}
 
    void SetName (const std::string& name) { name_s = name; }
    std::string GetName () const { return name_s; }
 
    const QVdt& operator= (const std::string& value); 
    const QVdt& operator= (long int value);
    const QVdt& operator= (double value);
 
    template<typename V> const QVdt& operator= (const std::vector<V, std::allocator<V> >& value) { // This should stay in .cc file, but
                                                                                                  // gcc does not have export for templates
      if (type_internal != Unassigned_QVdt) CheckType (QVdt::Vector_QVdt);
      type_internal = Vector_QVdt;
      std::back_insert_iterator<std::vector<QVdt> > inserter(value_v);
      std::copy (value.begin (), value.end (), inserter);
      fBuiltFromString = false;
      return *this;
    }
    
      // Since cast is not called in assignement operator these methods are necessary
    const QVdt& operator = (int value)      { return (*this) = (long int)(value); }
    const QVdt& operator = (short value)          { return (*this) = (long int)(value); }
    const QVdt& operator = (char value)     { return (*this) = (long int)(value); }
    const QVdt& operator = (unsigned long value) { return (*this) = (long int)(value); }
    const QVdt& operator = (unsigned short value) { return (*this) = (long int)(value); }
    const QVdt& operator = (unsigned char value) { return (*this) = (long int)(value); }
    const QVdt& operator = (float value)    { return (*this) = double(value); }
    const QVdt& operator = (const QVdt& other);
 
    bool is_valid ()     const  { return (type_internal == Unassigned_QVdt) ? 0 : 1; }
    
    QVdt_type GetType () const  { return type_internal; }
    bool IsScalar() const { return type_internal == Int_QVdt || type_internal == Double_QVdt; }
    bool IsVector() const { return type_internal == Vector_QVdt; }
    long int GetInt () const;
    double GetDouble () const;
    const std::string& GetString () const;
    bool GetBool () const { return bool (GetInt ()); }
    const QVdt_vector& GetVector () const;
    std::vector<int> GetVectorInt() const { return GetStdVector<int>(); }
    std::vector<double> GetVectorDouble() const { return GetStdVector<double>(); }
    std::vector<std::string> GetVectorString() const { return GetStdVector<std::string>(); }
    std::vector<bool> GetVectorBool() const { return GetStdVector<bool>(); }
 
    std::set<int> GetSetInt() const { return GetStdSet<int>(); }
    std::set<std::string> GetSetString() const { return GetStdSet<std::string>(); }
 
  private:
    QVdt_type type_internal;
    
    long int value_i;
    double value_f;
    mutable std::string value_s;
    QVdt_vector value_v;
    
    std::string name_s;
    bool fBuiltFromString;
    void CheckType (QVdt_type new_type) const;  // Throws an exception if the internal type 
    std::string ToString() const;
                                                  // is different from the required type
    QVdt_type SearchType (const std::string& str);
    void AssignValue (const std::string& str);
 
    template<class T> std::vector<T> GetStdVector() const
    {
        const QVdt_vector& v = GetVector();
        std::vector<T> out;
        for(size_t i = 0; i < v.size(); i++) {
            out.push_back(v[i].Get<T>());
        }
        return out;
    }
 
    template<class T> std::set<T> GetStdSet() const
    {
      const QVdt_vector &v=GetVector();
      std::set<T> out;
      for(size_t i=0; i < v.size(); i++){
        out.insert(v[i].Get<T>());
      }
      return out;
    }
 
    template<class T> T Get()  const {
        DianaThrow("QVdt::Get<T> not implemented for this type");
        T dummy;
        return dummy;
    }
};
 
template <> int QVdt::Get<int>() const;
template <> double QVdt::Get<double>() const;
template <> std::string QVdt::Get<std::string>() const;
template <> bool QVdt::Get<bool>() const;
 
std::ostream& operator<< (std::ostream&, const QVdt&);
 
 
#endif