PisaPhnxParv1.h

Go to the documentation of this file.

#ifndef __PISAPHNXPARV1_H__
#define __PISAPHNXPARV1_H__

#include "PisaPhnxPar.h"
#include <cassert>
#include <cctype>
#include <fstream>
#include <iostream>
#include <vector>

// Small traits template to give personal names to the types we use

template<typename T> class Ptraits;

template<>
class Ptraits<double>
{
 public:
  static const char* name() { return "floating point (double precision)"; }
};

template<>
class Ptraits<std::string>
{
 public:
  static const char* name() { return "character string"; }
};

template<>
class Ptraits<int>
{
 public:
  static const char* name() { return "integer"; }
};

template<>
class Ptraits<bool>
{
 public:
  static const char* name() { return "boolean"; }
};


class PisaPhnxSubParv1 : public PisaPhnxSubPar
{
 public:

  PisaPhnxSubParv1() {}
  virtual ~PisaPhnxSubParv1() {}

  bool has(const char* parname) const
  {
    return (count(parname)>0);
  }

  size_t count(const char* parname) const
  {
    return
      ( fDoubles.has(parname) ? 1:0 ) +
      ( fStrings.has(parname) ? 1:0 ) +
      ( fInts.has(parname) ? 1:0 ) +
      ( fBooleans.has(parname) ? 1:0 );
  }

  void appendBoolean(const char* parname, bool value)
  {
    setBoolean(parname,fBooleans.size(parname),value);
  }

  void appendDouble(const char* parname, double value)
  {
    setDouble(parname,fDoubles.size(parname),value);
  }

  void appendInt(const char* parname, int value)
  {
    setInt(parname,fInts.size(parname),value);
  }

  void appendString(const char* parname, const char* value)
  {
    setString(parname,fStrings.size(parname),value);
  }

  bool getBoolean(const char* parname, size_t index) const
  {
    return fBooleans.get(parname,index);
  }

  void setBoolean(const char* parname, size_t index, bool value)
  {
    return fBooleans.set(parname,index,value);
  }

  double getDouble(const char* parname, size_t index) const
  {
    return fDoubles.get(parname,index);
  }

  void setDouble(const char* parname, size_t index, double value)
  {
    fDoubles.set(parname,index,value);
  }

  int getInt(const char* parname, size_t index) const
  {
    return fInts.get(parname,index);
  }

  void setInt(const char* parname, size_t index, int value)
  {
    fInts.set(parname,index,value);
  }

  const char* getString(const char* parname, size_t index) const
  {
    return fStrings.get(parname,index).c_str();
  }

  void setString(const char* parname, size_t index, const char* value)
  {
    fStrings.set(parname,index,value);
  }

  void print(std::ostream& os) const
  {
    fDoubles.print(os);
    fStrings.print(os);
    fInts.print(os);
    fBooleans.print(os);
  }

  size_t size(const char* parname) const
  {
    size_t n = 0;
    size_t rv = 0;

    if ( (rv=fDoubles.size(parname)) )
      {
        ++n;    
      }
    if ( (rv=fStrings.size(parname)) )
      {
        ++n;
      }
    if ( (rv=fInts.size(parname)) )
      {
        ++n;
      }
    if ( (rv=fBooleans.size(parname)) )
      {
        ++n;
      }
    assert(n<=1);
    return rv;
  }

 private:

  template<typename T>
  class P
  {
  public:

    size_t size(const char* parname) const
    {
      typename TMAP::const_iterator it = fMap.find(parname);
      if (it!=fMap.end())
        {
          return it->second.size();
        }
      else
        {
          return 0;
        }
    }

    bool has(const char* parname) const
    {
      return fMap.find(parname) != fMap.end();
    }

    T get(const char* parname, size_t index) const
    {
      typename TMAP::const_iterator it = fMap.find(parname);
      if (it!=fMap.end())
        {
          typename std::map<size_t,T>::const_iterator it2;
          it2 = it->second.find(index);
          if (it2 != it->second.end())
            {
              return it2->second;
            }
        }
      std::cerr << __FILE__ << ":" << __LINE__ 
                << " unknow parameter/or index" 
                << parname << "/" << index
                << std::endl;
      return T();
    }

    void set(const char* parname, size_t index, T value)
    {
      fMap[parname][index]=value;
    }

    void print(std::ostream& os) const
    {
      if ( fMap.empty() )
        {
          return;
        }
      std::string name = Ptraits<T>::name();
      os << "Parameters of type: " << name << std::endl;
      typename TMAP::const_iterator it;
      for ( it = fMap.begin(); it != fMap.end(); ++it ) 
        {
          typename std::map<size_t,T>::const_iterator it2;
          for ( it2 = it->second.begin(); it2 != it->second.end(); ++it2 )
            {
              os << it->first << "[" << it2->first << "]="
                 << it2->second << ",";
        }
          os << std::endl;
        }
      os << std::endl;
    }

  private:
    typedef std::map<std::string, std::map<size_t,T> > TMAP;
    TMAP fMap;
  };

  P<double> fDoubles;
  P<std::string> fStrings;
  P<int> fInts;
  P<bool> fBooleans;

  ClassDef(PisaPhnxSubParv1,1)
};

class PisaPhnxParv1 : public PisaPhnxPar
{
 public:

  PisaPhnxParv1(const char* file);
  virtual ~PisaPhnxParv1() {}

  bool has(const char* subsystem) const;

  void print(std::ostream& os = std::cout) const;

  const PisaPhnxSubParv1* get(const char* subsystem) const;

 private:
  void closeParameter(const std::string& subsystem,
                      const std::string& parameter,
                      const std::string& value);

 private:
  typedef std::map<std::string,PisaPhnxSubParv1> TMAP;
  TMAP fMap;

  ClassDef(PisaPhnxParv1,1)
};

#endif