matfile/matfile_concepts/src/exceptions.hh

Go to the documentation of this file.

/*
    This file is part of matfile.

    Copyright (C) 2010-2011 Andrea Arteaga <arteagaa@student.ethz.ch>

    matfile is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    matfile is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with matfile.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef EXCEPTIONS_HPP_
#define EXCEPTIONS_HPP_


class bad_MAT_code : public std::exception
{
  std::string what_;
public:
  bad_MAT_code() {
    what_ = "The code is not valid. The file could be corrupted.";
  }

  virtual ~bad_MAT_code() throw() { }

  virtual const char* what() throw() {
    return what_.c_str();
  }
};


class bad_cast : public std::exception
{
  const int type1_, type2_;
  std::string what_;

public:
  bad_cast(const int& type1, const int& type2)
  : type1_(type1), type2_(type2)
  {
    std::ostringstream descr;
    descr << "Given miMATRIX of class: " << class_to_string(type1) << ", which is not compatile with class: " << class_to_string(type2) << ".";
    what_ = descr.str();
  }

  virtual ~bad_cast() throw() { }

  virtual const char* what() const throw() {
    return what_.c_str();
  }

};


class bad_mxNUMARRAY_cast : public std::exception
{
  const int type_;
  std::string what_;

public:
  bad_mxNUMARRAY_cast(const int& type)
  : type_(type)
  {
    std::ostringstream descr;
    descr << "Given miMATRIX of class: " << class_to_string(type) << ", which is not compatile with any numeric class.";
    what_ = descr.str();
  }

  virtual ~bad_mxNUMARRAY_cast() throw() { }

  virtual const char* what() const throw() {
    return what_.c_str();
  }
};


class bad_mxSTRUCT_cast : public std::exception
{
  const int type_;
  std::string what_;

public:
  bad_mxSTRUCT_cast(const int& type)
  : type_(type)
  {
    std::ostringstream descr;
    descr << "Given miMATRIX of class: " << class_to_string(type) << ", which is not compatible with mxSTRUCT.";
    what_ = descr.str();
  }

  virtual ~bad_mxSTRUCT_cast() throw() { }

  virtual const char* what() const throw() {
    return what_.c_str();
  }
};

class bad_initializator : public std::exception
{
  std::string what_;

public:
  bad_initializator() {
    what_ = "The used initializator is not valid for this use.";
  }

  virtual ~bad_initializator() throw() { }

  virtual const char* what() const throw() {
    return what_.c_str();
  }
};


class class_not_supported : public std::exception
{
public:
  class_not_supported(const int& type)
  {
    std::ostringstream descr;
    if (type >= 1 && type <= 13) {
      descr << "The class ";
      switch(type) {
      case 1:
        descr << "mxCELL_CLASS";
        break;
      case 3:
        descr << "mxOBJECT_CLASS";
        break;
      case 4:
        descr << "mxCHAR_CLASS";
        break;
      case 5:
        descr << "mxSPARSE_CLASS";
        break;
      case 8:
        descr << "mxINT8_CLASS";
        break;
      case 9:
        descr << "mxUINT8_CLASS";
        break;
      default:
        descr << "(unrecognized class " << type << ")";
        break;
      }
      descr << " is not (yet) supported.";
    } else {
      descr << "The class you selected is not recognized.";
    }
    what_ = descr.str();
  }

  virtual ~class_not_supported() throw() { }

  virtual const char* what() const throw() {
    return what_.c_str();
  }

private:
  std::string what_;
};


class matrix_type_not_supported : public std::exception
{
private:
  std::string what_;

public:
  matrix_type_not_supported(const MATtype& type)
  {
    std::ostringstream descr;
    switch(type) {
    case miINT8:
      descr << "miINT8";
      break;
    case miUINT8:
      descr << "miUINT8";
      break;
    case miINT64:
      descr << "miINT64";
      break;
    case miUINT64:
      descr << "miUINT64";
      break;
    case miMATRIX:
      descr << "miMATRIX";
      break;
    case miCOMPRESSED:
      descr << "miCOMPRESSED";
      break;
    case miUTF8:
      descr << "miUTF8";
      break;
    case miUTF16:
      descr << "miUTF16";
      break;
    case miUTF32:
      descr << "miUTF32";
      break;
    default:
      descr << "(unrecognized type" << type << ")";
    }
    descr << " cannot be the type of a matrix";

    what_ = descr.str();
  }

  virtual ~matrix_type_not_supported() throw() { }

  virtual const char *what() const throw() {
    return what_.c_str();
  }
};

#endif /* EXCEPTIONS_HPP_ */