inputOutput.hh

Go to the documentation of this file.

 
#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 virtual 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;
    double getDouble(const char* name, const double value) 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 virtual 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