TextParameters.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2009 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Util/tempo/Pulsar/TextParameters.h
 
#ifndef __TextParameters_h
#define __TextParameters_h
 
#include "Pulsar/Parameters.h"
 
namespace Pulsar {
 
  class TextParameters : public Parameters {
 
  public:
 
    Parameters* clone () const;
 
    bool equals (const Parameters* that) const;
 
    void load (FILE*);
 
    void unload (FILE*) const;
 
    std::string get_name () const;
 
    //
    //
    //
 
    void set_text (const std::string& t) { text = t; }
 
    std::string get_value (const std::string& keyword) const;
 
    template<typename T>
    bool get_value (T& value, const std::string& keyword, 
                    bool exception=true) const;
 
    template<typename T>
    T get (const std::string& keyword) const
    { T value; get_value (value,keyword); return value; }
 
  protected:
 
    std::string text;
 
    struct Row
    {
      std::string keyword;
      std::string value;
      std::string flag;
 
      bool equals (const Row& that)
      { return
          keyword == that.keyword &&
          value == that.value &&
          flag == that.flag;
      }
    };
 
    mutable std::vector<Row> rows;
 
    void parse_rows () const;
  };
 
}
 
template<typename T>
T parse (const std::string& value)
{
  return fromstring<T> (value);
}
 
inline std::string defortran (std::string value)
{
  std::string::size_type D = value.find ('D');
  if (D != std::string::npos)
    value[D] = 'E';
  return value;
}
 
// specializations for float and double address Fortran formatting issue
template<>
inline float parse<float> (const std::string& value)
{
  return fromstring<float> ( defortran(value) );
}
 
template<>
inline double parse<double> (const std::string& value)
{
  return fromstring<double> ( defortran(value) );
}
 
template<typename T>
bool Pulsar::TextParameters::get_value (T& value, 
                                        const std::string& keyword, 
                                        bool exception) const
{
  std::string value_string = get_value (keyword);
 
  if (value_string.empty())
  {
    if (!exception)
      return false;
 
    throw Error (InvalidParam, "Pulsar::TextParameters::get_value<T>",
                 "keyword='" + keyword + "' not found");
  }
 
  value = parse<T> (value_string);
  return true;
}
 
#endif