toolbox/inputOutput.hh

Go to the documentation of this file.

/* -*- c++ -*-
 * parsing an input file, holding parameters, producing output
 */

#ifndef inputOutput_hh
#define inputOutput_hh

#include <iostream>
#include <string>
#include <cstring>
#include <map>
#include <complex>
#include <limits.h>

#include "basics/exceptions.hh"
#include "basics/outputOperator.hh"
#include "toolbox/multiArray.hh"

namespace concepts {

  // ****************************************************** MissingParameter **

  class MissingParameter : public MissingFeature {
  public:
    MissingParameter(const std::string& parameter) throw();
  protected:
    virtual std::ostream& info(std::ostream& os) const throw();
  };

  // ******************************************************* InOutParameters **

  struct ltstr {
    bool operator()(const char* s1, const char* s2) const {
      return std::strcmp(s1, s2) < 0;
    }
  };

  struct ltidx {
    bool operator()(const MultiIndex<2>& i1, const MultiIndex<2>& i2) const {
      return (i1[0] < i2[0]) || (i1[0] == i2[0] && i1[1] < i2[1]);
    }
  };

  class InOutParameters : public OutputOperator {
  public:
    InOutParameters() {}
    InOutParameters(const InOutParameters& i);
    virtual ~InOutParameters();
    void append(const InOutParameters& inout, bool arrayAppend = true);

    void addDouble(const char* name, const double value);
    void addComplex(const char* name, const std::complex<double> value);
    void addString(const char* name, const char* value);
    void addInt(const char* name, const int value);
    void addBool(const char* name, const int value);

    double getDouble(const char* name) const;
    std::complex<double> getComplex(const char* name) const;
    std::string getString(const char* name, const char* value = 0) const;
    int getInt(const char* name, const int value = INT_MAX) const;
    bool getBool(const char* name) const;
    bool getBool(const char* name, const bool value) const;

    void addArrayDouble(const char* array, const bool newArray = false);
    void addArrayComplex(const char* array, const bool newArray = false);
    void addArrayString(const char* array, const bool newArray = false);
    void addArrayInt(const char* array, const bool newArray = false);
    void addArrayBool(const char* array, const bool newArray = false);

    void addArrayDouble(const char* array, const int number, 
      const double value);
    void addArrayComplex(const char* array, const int number, 
       const std::complex<double> value);
    void addArrayString(const char* array, const int number, 
      const char* value);
    void addArrayInt(const char* array, const int number, const int value);
    void addArrayBool(const char* array, const int number, const int value);

    double getArrayDouble(const char* array, const int number) const;
    std::complex<double> getArrayComplex(const char* array,
           const int number) const;
    std::string getArrayString(const char* array, const int number) const;
    int getArrayInt(const char* array, const int number) const;
    bool getArrayBool(const char* array, const int number) const;

    const std::map<int, double>& getMapDouble(const char* array) const;
    const std::map<int, std::complex<double> >&
    getMapComplex(const char* array) const;
    const std::map<int, std::string>& getMapString(const char* array) const;
    const std::map<int, int>& getMapInt(const char* array) const;
    const std::map<int, bool>& getMapBool(const char* array) const;


    void addMatrixDouble(const char* array, const bool newMatrix = false); 
    void addMatrixInt(const char* array, const bool newMatrix = false); 
    
    void addMatrixDouble(const char* matrix, const int i, const int j, 
       const double value);
    void addMatrixInt(const char* matrix, const int i, const int j, 
          const int value);
      
    double getMatrixDouble(const char* array, const int i, const int j) const;
    int getMatrixInt(const char* array, const int i, const int j) const;
    

    void clear();
    void storeMatlab(const char* filename,
         const std::string description = "") const;
    std::ostream& storeMatlab(std::ostream& os, const char* name, 
            const std::string description = "") const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    std::map<const char*, double, ltstr> double_;
    std::map<const char*, std::complex<double>, ltstr> complex_;
    std::map<const char*, std::string, ltstr> string_;
    std::map<const char*, int, ltstr> int_;
    std::map<const char*, bool, ltstr> bool_;

    std::map<const char*, std::map<int, double>*, ltstr> doubleArrays_;
    std::map
    <const char*, std::map<int, std::complex<double> >*, ltstr> complexArrays_;
    std::map<const char*, std::map<int, std::string>*, ltstr> stringArrays_;
    std::map<const char*, std::map<int, int>*, ltstr> intArrays_;
    std::map<const char*, std::map<int, bool>*, ltstr> boolArrays_;
    
    std::map<const char*,
       std::map<MultiIndex<2>, double, ltidx>*, ltstr> doubleMatrices_;
    std::map<const char*,
       std::map<MultiIndex<2>, int, ltidx>*, ltstr> intMatrices_;
    
    template<class F>
    void mapOutputMatlab_(std::ostream& os,
        const std::map<const char*, F, ltstr>& map) const;
    template<class F>
    void mapArrayOutputMatlab_(std::ostream& os, const std::map
             <const char*, std::map<int, F>*, ltstr> & map,
             const std::string brackets = "[]") const;
    template<class F>
    void mapMatrixOutputMatlab_
    (std::ostream& os, const std::map
     <const char*, std::map<MultiIndex<2>, F, ltidx>*, ltstr> & map,
     const std::string brackets = "[]") const;

    template<class F>
    void add_(std::map<const char*, F, ltstr>& map, const char* name,
        const F value);

    template<class F>
    F get_(const std::map<const char*, F, ltstr>& map, const char* name) const;

    template<class F, class G, class H>
    void addArray_(std::map<const char*, std::map<F, G, H>*, ltstr>& map,
       const char* array, const bool newArray = false);

    template<class F, class G, class H>
    void addArray_(std::map<const char*, std::map<F, G, H>*, ltstr>& map,
       const char* array, const F number, const G value);

    template<class F, class G, class H>
    G getArray_(const std::map<const char*, std::map<F, G, H>*, ltstr>& map,
    const char* array, const F number) const; 

    template<class F>
    const std::map<int, F>& 
    getMap_(const std::map<const char*, std::map<int, F>*, ltstr>& map, 
      const char* array) const;

    template<class F>
    void clear_(std::map<const char*, F, ltstr>& map);

    template<class F, class G>
    void clear_(std::map<const char*, std::map<G, F>*, ltstr>& map);
  };

  // *********************************************************** InputParser **

  class InputParser : public OutputOperator {
  public:
    InputParser(bool quiet = false);

    virtual ~InputParser();

    void parse();
    void parse(std::string file);

    InOutParameters& inputParameters() { return input_; }

    InOutParameters& outputParameters() { return output_; }

    typedef struct yy_buffer_state *YY_BUFFER_STATE;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    YY_BUFFER_STATE current_buffer_;

    InOutParameters input_;

    InOutParameters output_;

    bool quiet_;
  };

} // namespace

#endif // inputOutput_hh