matfile/matlabMatfile.hh

Go to the documentation of this file.

#ifndef matlabinterface_hh
#define matlabinterface_hh

#include <iostream>

#include "basics/exceptions.hh"
#include "operator.hh"

#include "mat.h"
#include "matrix.h"

namespace concepts {

  // forward declaration
  class MatlabMatfile;

  // **************************************************** MatlabMatfileError **

  class MatlabMatfileError : public ExceptionBase {
  public:
    MatlabMatfileError(const MatlabMatfile& matfile) throw();

    virtual ~MatlabMatfileError() throw() {};
  protected:
    virtual std::ostream& info(std::ostream& os) const throw();
  private:
    std::string errorMessage_;
  };

  // ******************************************************** MatlabMatfile **

  class MatlabMatfile {

  public:
    MatlabMatfile() : file_(0) { }

    MatlabMatfile(const std::string& filename) : file_(0), filename_(filename) {
      openFile( filename, "u" );

      if( !isOpen() ) {
        openFile( filename, "w" );
        closeFile();
        openFile( filename, "u" );
      }
    }

    MatlabMatfile(const std::string& filename, const std::string& mode) 
      : file_(0), filename_(filename) {
      openFile( filename, mode );
    }

    inline bool isOpen() const { return (file_!=NULL); }

    inline std::string filename() const { return filename_; }

    virtual ~MatlabMatfile() {
      closeFile();
    }

    // returned if there was not error.
    std::string getErrorMessage() const {
      return errorMessage_.str();
    }

    void openFile(const std::string& filename, const std::string& mode);

    void closeFile() {
      if( isOpen() ) {
        matClose( file_ );
        file_     = 0;
        filename_ = "";
      }
    }

    template<typename F>
    int addMatrix(Matrix<F>* p_matrix, const std::string& varname);

    void deleteMatrix(const std::string& varname) {
      if( isOpen() ) {
        int retval = matDeleteVariable(file_, varname.c_str());
        if( retval!=0 ){
          setErrorMessage_("Could not delete Variable. No such variable name.");
        }
      } else {
        setErrorMessage_("Could not delete Variable. No MAT-file opened.");
      }
    }

    template<typename F>
    Matrix<F>* getMatrix(const std::string& varname);

    template<typename F>
    SparseMatrix<F>* getSparseMatrix(const std::string& varname);

    template<typename F>
    DenseMatrix<F>* getDenseMatrix(const std::string& varname);

    template<typename F>
    Vector<F>* getVector(const std::string& varname) const;

    template<typename F>
    F getScalar(const std::string& varname);

    bool exists(const std::string& varname) const;

    void assertExistence(const std::string& varname) const throw();

    bool isReal(const std::string& varname) const;

    bool isCmplx(const std::string& varname) const;

    void assertCmplx(const std::string& varname) const throw();

    bool isScalar(const std::string& varname) const;

    uint lengthVector(const std::string& varname) const;

    friend std::ostream& operator<<(std::ostream& out, const MatlabMatfile& mm);

  private:
    MATFile* file_;
    std::string filename_;

    mutable std::stringstream errorMessage_;

    void clearErrorMessage_() const {
      errorMessage_.clear();
      errorMessage_.str("");
    }

    void setErrorMessage_(const std::string& newErrorMessage) const {
      errorMessage_.clear();
      errorMessage_.str(newErrorMessage);
    }

    void assertScalar_(const std::string& varname) const throw();

    void assertVector_(const std::string& varname, uint& length) const throw();

    template<typename F>
    struct NumTr{
      const static bool is_complex = false;
    };

    template<typename F>
    struct NumTr< std::complex<F> >{
      const static bool is_complex = true;
    };

  };

} // namespace concepts

#endif