exception.h

Go to the documentation of this file.

/*
 * This file is part of Quantum++.
 *
 * MIT License
 *
 * Copyright (c) 2013 - 2020 Vlad Gheorghiu.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef CLASSES_EXCEPTION1_H_
#define CLASSES_EXCEPTION1_H_

namespace qpp {
namespace exception {
class Exception : public std::exception {
  private:
    std::string where_;
    mutable std::string msg_;

  public:
    explicit Exception(const std::string& where) : where_{where}, msg_{} {}

    const char* what() const noexcept override {
        msg_.clear();
        msg_ += "In ";
        msg_ += where_;
        msg_ += ": ";
        msg_ += description();
        msg_ += "!";

        return msg_.c_str();
    }

    virtual std::string description() const = 0;
}; /* class Exception */

inline std::string Exception::description() const {
    return "qpp::exception::Exception";
}

class Unknown : public Exception {
  public:
    std::string description() const override { return "UNKNOWN EXCEPTION"; }

    using Exception::Exception;
};

class ZeroSize : public Exception {
  public:
    std::string description() const override { return "Object has zero size"; }

    using Exception::Exception;
};

class MatrixNotSquare : public Exception {
  public:
    std::string description() const override { return "Matrix is not square"; }

    using Exception::Exception;
};

class MatrixNotCvector : public Exception {
  public:
    std::string description() const override {
        return "Matrix is not a column vector";
    }

    using Exception::Exception;
};

class MatrixNotRvector : public Exception {
  public:
    std::string description() const override {
        return "Matrix is not a row vector";
    }

    using Exception::Exception;
};

class MatrixNotVector : public Exception {
  public:
    std::string description() const override {
        return "Matrix is not a vector";
    }

    using Exception::Exception;
};

class MatrixNotSquareNorCvector : public Exception {
  public:
    std::string description() const override {
        return "Matrix is not square nor column vector";
    }

    using Exception::Exception;
};

class MatrixNotSquareNorRvector : public Exception {
  public:
    std::string description() const override {
        return "Matrix is not square nor row vector";
    }

    using Exception::Exception;
};

class MatrixNotSquareNorVector : public Exception {
  public:
    std::string description() const override {
        return "Matrix is not square nor vector";
    }

    using Exception::Exception;
};

class MatrixMismatchSubsys : public Exception {
  public:
    std::string description() const override {
        return "Matrix mismatch subsystems";
    }

    using Exception::Exception;
};

class DimsInvalid : public Exception {
  public:
    std::string description() const override { return "Invalid dimension(s)"; }

    using Exception::Exception;
};

class DimsNotEqual : public Exception {
  public:
    std::string description() const override { return "Dimensions not equal"; }

    using Exception::Exception;
};

class DimsMismatchMatrix : public Exception {
  public:
    std::string description() const override {
        return "Dimension(s) mismatch matrix size";
    }

    using Exception::Exception;
};

class DimsMismatchCvector : public Exception {
  public:
    std::string description() const override {
        return "Dimension(s) mismatch column vector size";
    }

    using Exception::Exception;
};

class DimsMismatchRvector : public Exception {
  public:
    std::string description() const override {
        return "Dimension(s) mismatch row vector size";
    }

    using Exception::Exception;
};

class DimsMismatchVector : public Exception {
  public:
    std::string description() const override {
        return "Dimension(s) mismatch vector size";
    }

    using Exception::Exception;
};

class SubsysMismatchDims : public Exception {
  public:
    std::string description() const override {
        return "Subsystems mismatch dimensions";
    }

    using Exception::Exception;
};

class PermInvalid : public Exception {
  public:
    std::string description() const override { return "Invalid permutation"; }

    using Exception::Exception;
};

class PermMismatchDims : public Exception {
  public:
    std::string description() const override {
        return "Permutation mismatch dimensions";
    }

    using Exception::Exception;
};

class NotQubitMatrix : public Exception {
  public:
    std::string description() const override { return "Matrix is not 2 x 2"; }

    using Exception::Exception;
};

class NotQubitCvector : public Exception {
  public:
    std::string description() const override {
        return "Column vector is not 2 x 1";
    }

    using Exception::Exception;
};

class NotQubitRvector : public Exception {
  public:
    std::string description() const override {
        return "Row vector is not 1 x 2";
    }

    using Exception::Exception;
};

class NotQubitVector : public Exception {
  public:
    std::string description() const override {
        return "Vector is not 2 x 1 nor 1 x 2";
    }

    using Exception::Exception;
};

class NotQubitSubsys : public Exception {
  public:
    std::string description() const override {
        return "Subsystems are not qubits";
    }

    using Exception::Exception;
};

class NotBipartite : public Exception {
  public:
    std::string description() const override { return "Not bi-partite"; }

    using Exception::Exception;
};

class NoCodeword : public Exception {
  public:
    std::string description() const override {
        return "Codeword does not exist";
    }

    using Exception::Exception;
};

class OutOfRange : public Exception {
  public:
    std::string description() const override { return "Argument out of range"; }

    using Exception::Exception;
};

class TypeMismatch : public Exception {
  public:
    std::string description() const override { return "Type mismatch"; }

    using Exception::Exception;
};

class SizeMismatch : public Exception {
  public:
    std::string description() const override { return "Size mismatch"; }

    using Exception::Exception;
};

class UndefinedType : public Exception {
  public:
    std::string description() const override {
        return "Not defined for this type";
    }

    using Exception::Exception;
};

class QuditAlreadyMeasured : public Exception {
  public:
    std::string description() const override {
        return "Qudit was already measured (destructively)";
    }

    using Exception::Exception;
};

class Duplicates : public Exception {
  public:
    std::string description() const override {
        return "System (e.g. std::vector) contains duplicates";
    }

    using Exception::Exception;
};

class CustomException : public Exception {
    std::string what_{};

    std::string description() const override {
        return "CUSTOM EXCEPTION " + what_;
    }

  public:
    CustomException(const std::string& where, const std::string& what)
        : Exception{where}, what_{what} {}
};

class NotImplemented : public Exception {
  public:
    std::string description() const override { return "Not yet implemented"; }

    using Exception::Exception;
};

class InvalidIterator : public Exception {
  public:
    std::string description() const override { return "Invalid iterator"; }

    using Exception::Exception;
};

class FileNotFound : public Exception {
  public:
    std::string description() const override { return "File not found"; }

    using Exception::Exception;
};

class LexicalError : public Exception {
  public:
    std::string description() const override { return "Lexical error"; }

    using Exception::Exception;
};

class ParseError : public Exception {
  public:
    std::string description() const override { return "Parse error"; }

    using Exception::Exception;
};

class SemanticError : public Exception {
  public:
    std::string description() const override { return "Semantic error"; }

    using Exception::Exception;
};

class Undeclared : public Exception {
  public:
    std::string description() const override { return "Undeclared variable"; }

    using Exception::Exception;
};

} /* namespace exception */
} /* namespace qpp */

#endif /* CLASSES_EXCEPTION1_H_ */