exceptions.hpp

Go to the documentation of this file.

/*
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program 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 General Public License for more details.
 */
#ifndef PLASK__EXCEPTIONS_H
#define PLASK__EXCEPTIONS_H
 
#include <stdexcept>
#include "utils/format.hpp"
#include "utils/string.hpp"
 
#include <plask/config.hpp>
 
namespace plask {
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning( disable : 4275 )   // Disable MSVC warnings "non - DLL-interface classkey 'identifier' used as base for DLL-interface classkey 'identifier'"
#endif
 
struct PLASK_API Exception: public std::runtime_error {
 
    Exception(const std::string& msg);
 
    template <typename... T>
    Exception(const std::string& msg, const T&... args): Exception(format(msg, args...)) {}
};
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
struct PLASK_API CriticalException: public Exception {
 
    CriticalException(const std::string& msg): Exception("Critical exception: " + msg) {}
 
    template <typename... T>
    CriticalException(const std::string& msg, const T&... args): Exception("Critical exception: " + msg, args...) {}
};
 
struct PLASK_API NotImplemented: public Exception {
    //std::string methodName;
 
    NotImplemented(const std::string& method_name)
    : Exception("Method not implemented: " + method_name)/*, methodName(method_name)*/ {}
 
    NotImplemented(const std::string& where, const std::string& method_name)
    : Exception(where + ": Method not implemented: " + method_name)/*, methodName(method_name)*/ {}
};
 
struct PLASK_API OutOfBoundsException: public Exception {
 
    OutOfBoundsException(const std::string& where, const std::string& argname)
        : Exception("{0}: argument {1} out of bounds", where, argname) {}
 
    template <typename BoundTypeWas, typename BoundTypeLo, typename BoundTypeHi>
    OutOfBoundsException(const std::string& where, const std::string& argname, const BoundTypeWas& was, const BoundTypeLo& lo, const BoundTypeHi& hi)
        : Exception("{0}: argument {1} out of bounds, should be between {2} and {3}, but was {4}", where, argname, lo, hi, was) {}
};
 
struct PLASK_API DimensionError: public Exception {
    template <typename... T>
    DimensionError(T... args) : Exception(args...) {}
};
 
struct PLASK_API BadInput: public Exception {
 
    template <typename... Params>
    BadInput(const std::string& where, const std::string& msg, Params... params)
        : Exception("{0}: {1}", where, format(msg, params...)) {};
};
 
struct PLASK_API DataError: public Exception {
 
    template <typename... Params>
    DataError(const std::string& msg, Params... params)
        : Exception("{0}", format(msg, params...)) {};
};
 
 
struct PLASK_API ComputationError: public Exception {
 
    template <typename... Params>
    ComputationError(const std::string& where, const std::string& msg, Params... params)
        : Exception("{0}: {1}", where, format(msg, params...)) {};
};
 
struct PLASK_API BadId: public Exception {
 
    BadId(const std::string& where, const char* str_to_check)
        : Exception("\"{0}\" is a bad name for a {1} (must be letters, digits, or '_' and cannot start with a digit) ", str_to_check, where) {};
 
    static void throwIfBad(const std::string& where, const char* str_to_check) {
        if (!isCid(str_to_check))
            throw BadId(where, str_to_check);
    }
 
    static void throwIfBad(const std::string& where, const std::string& str_to_check) {
        throwIfBad(where, str_to_check.c_str());
    }
 
};
 
//-------------- Connected with providers/receivers: -----------------------
 
struct PLASK_API NoProvider: public Exception {
    NoProvider(const char* provider_name): Exception("No provider nor value for {0}", provider_name) {}
};
 
struct PLASK_API NoValue: public Exception {
    NoValue(const char* provider_name): Exception("{0} cannot be provided now", [](std::string s)->std::string{s[0]=char(std::toupper(s[0]));return s;}(provider_name) ) {}
};
 
 
/*
 * Exceptions of this class are thrownwhen some string parser find errors.
 */
/*struct ParseException: public Exception {
    ParseException(): Exception("Parse error") {}
    ParseException(std::string& msg): Exception("Parse error: " + msg) {}
};*/
 
//-------------- Connected with materials: -----------------------
 
class PLASK_API NoSuchMaterial: public Exception {
 
    template <typename ComponentMap>
    std::string constructMsg(const ComponentMap& comp, const std::string dopant_name) {
        std::string result = "No material with composition consisting of:";
        for (auto c: comp) (result += ' ') += c.first;
        if (!dopant_name.empty()) (result += ", doped with: ") += dopant_name;
        return result;
    }
 
public:
    NoSuchMaterial(const std::string& material_name)
        : Exception("No such material: {0}", material_name)/*, materialName(material_name)*/ {}
 
    NoSuchMaterial(const std::string& material_name, const std::string& dopant_name)
        : Exception("No such material: {0}{1}{2}", material_name, dopant_name.empty() ? "" : ":", dopant_name)/*, materialName(material_name)*/ {}
 
    template <typename ComponentMap>
    NoSuchMaterial(const ComponentMap& comp, const std::string dopant_name)
        : Exception(constructMsg(comp, dopant_name)) {}
 
};
 
struct PLASK_API MaterialMethodNotImplemented: public NotImplemented {
 
    MaterialMethodNotImplemented(const std::string& material_name, const std::string& method_name)
    : NotImplemented("Material " + material_name, method_name) {
    }
 
};
 
struct PLASK_API MaterialParseException: public Exception {
    MaterialParseException(): Exception("Material parse error") {}
    MaterialParseException(const std::string& msg): Exception(msg) {}
 
    template <typename... T>
    MaterialParseException(const std::string& msg, const T&... args): Exception(msg, args...) {
    }
};
 
class PLASK_API MaterialCantBeMixedException: public Exception {
 
    /*template <typename ComponentMap>
    std::string constructMsg(const ComponentMap& comp, const std::string dopant_name) {
        std::string result = "material with composition consisting of:";
        for (auto c: comp) (result += ' ') += c.first;
        if (!dopant_name.empty()) (result += ", doped with: ") += dopant_name;
        return result;
    }*/
 
public:
    MaterialCantBeMixedException(const std::string& material1name_with_components, const std::string& material2name_with_components, const std::string& common_dopant = "")
        : Exception("Material \"{0}{2}\" can not be mixed with material \"{1}{2}\"",
              material1name_with_components, material2name_with_components, common_dopant.empty() ? "" : ':' + common_dopant)
              {}
 
};
 
 
//-------------- Connected with geometry: -----------------------
 
struct PLASK_API GeometryException: public Exception {
    template <typename... T>
    GeometryException(const T&... args): Exception(args...) {}
};
 
struct PLASK_API NoGeometryException: public GeometryException {
    NoGeometryException(const std::string& where): GeometryException("{0}: No geometry specified", where) {}
};
 
struct PLASK_API NoChildException: public GeometryException {
    NoChildException(): GeometryException("Incomplete geometry tree") {}
};
 
struct PLASK_API NotUniqueObjectException: public GeometryException {
    NotUniqueObjectException(): GeometryException("Unique object instance required") {}
    NotUniqueObjectException(const std::string& msg): GeometryException(msg) {}
 
    template <typename... T>
    NotUniqueObjectException(const std::string& msg, const T&... args): GeometryException(msg, args...) {}
};
 
struct PLASK_API CyclicReferenceException: public GeometryException {
    CyclicReferenceException(): GeometryException("Detected cycle in geometry tree") {}
};
 
struct PLASK_API NoSuchGeometryObjectType: public GeometryException {
    //std::string materialName;
 
    NoSuchGeometryObjectType(const std::string& object_type_name)
        : GeometryException("No geometry object with given type name \"" + object_type_name + "\"")/*, materialName(material_name)*/ {}
};
 
struct PLASK_API NamesConflictException: public GeometryException {
 
    NamesConflictException(const std::string& what, const std::string& object_name):
        GeometryException(what + " with name \"" + object_name + "\" already exists") {}
};
 
struct PLASK_API NoSuchGeometryObject: public GeometryException {
    //std::string materialName;
 
    NoSuchGeometryObject(const std::string& object_name)
    : GeometryException("No geometry object with name \"" + object_name + "\"") {}
 
    NoSuchGeometryObject()
    : GeometryException("No geometry object found") {}
};
 
struct PLASK_API NoSuchGeometry: public GeometryException {
    NoSuchGeometry(const std::string& object_name)
    : GeometryException("No geometry of required type with name \"" + object_name + "\"") {}
};
 
struct PLASK_API NoSuchPath: public GeometryException {
    NoSuchPath(const std::string& object_name)
    : GeometryException("No path with name \"" + object_name + "\"") {}
};
 
struct PLASK_API UnexpectedGeometryObjectTypeException: public GeometryException {
    UnexpectedGeometryObjectTypeException(): GeometryException("Geometry object has unexpected type") {}
};
 
struct PLASK_API NoSuchAxisNames: public GeometryException {
    //std::string materialName;
 
    NoSuchAxisNames(const std::string& axis_names)
        : GeometryException("No such axis names \"{0}\"", axis_names) {}
};
 
 
//-------------- Connected with meshes: -----------------------
 
struct PLASK_API NoMeshException: public Exception {
    NoMeshException(const std::string& where): Exception("{0}: No mesh specified", where) {}
};
 
 
struct PLASK_API BadMesh: public Exception {
 
    template <typename... Params>
    BadMesh(const std::string& where, const std::string& msg, Params... params)
        : Exception("{0}: Bad mesh: {1}", where, format(msg, params...)) {};
};
 
 
 
 
} // namespace plask
 
#endif  //PLASK__EXCEPTIONS_H