Exceptions.h

Go to the documentation of this file.

/*
        This file is part of the EnergyOptimizatorOfRoboticCells program.

        EnergyOptimizatorOfRoboticCells 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, either version 3 of the License, or
        (at your option) any later version.

        EnergyOptimizatorOfRoboticCells 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.

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

#ifndef HLIDAC_PES_EXCEPTIONS_H
#define HLIDAC_PES_EXCEPTIONS_H

#include <algorithm>
#include <iterator>
#include <stdexcept>
#include <string>
#include <vector>
#include <stdint.h>

std::vector<std::string> split(const std::string& toSplit, const char& delim);

std::string concat(const std::vector<std::string>& toConcat, const std::string& beforeItem, const std::string& afterItem);


class SolverException : public std::exception {
        public:
                SolverException(const std::string& caller, const std::string& msg) {
                        std::vector<std::string> splitCaller = split(caller, '\n'), splitMsg = split(msg, '\n');
                        std::copy(splitCaller.cbegin(), splitCaller.cend(), std::back_inserter(mWhat));
                        std::copy(splitMsg.cbegin(), splitMsg.cend(), std::back_inserter(mWhat));
                        mWhatStr = concat(mWhat, "", "\n");
                }

                virtual const char* what() const throw() { return mWhatStr.c_str(); }
                virtual std::string whatIndented(uint32_t level = 0) const throw() {
                        return concat(mWhat, std::string(level, '\t'), "\n");
                }

                virtual ~SolverException() throw() { }
        protected:
                std::string mWhatStr;
                std::vector<std::string> mWhat;
};

class InvalidDatasetFile : public SolverException {
        public:
                InvalidDatasetFile(const std::string& caller, const std::string& msg, int64_t lineNumber = -1) : SolverException(caller, msg), mLineNumber(lineNumber) {
                        if (mLineNumber != -1)
                                mWhat.push_back("The error occured around the line "+std::to_string(mLineNumber)+" in the input dataset file!");
                }

                virtual ~InvalidDatasetFile() throw() { }
        protected:
                int64_t mLineNumber;
};

class InvalidArgument : public SolverException {
        public:
                InvalidArgument(const std::string& caller, const std::string& msg) : SolverException(caller, msg) { }
                virtual ~InvalidArgument() throw() { }
};

class ILPSolverException : public SolverException {
        public:
                ILPSolverException(const std::string& caller, const std::string& msg) : SolverException(caller, msg) { }
                virtual ~ILPSolverException() throw() { }
};

class NoFeasibleSolutionExists : public SolverException {
        public:
                NoFeasibleSolutionExists(const std::string& caller, const std::string& msg) : SolverException(caller, msg) { }
                virtual ~NoFeasibleSolutionExists() throw() { }
};

class EmptySolutionPool : public SolverException {
        public:
                EmptySolutionPool(const std::string& caller, const std::string& msg) : SolverException(caller, msg) { }
                virtual ~EmptySolutionPool() throw() { }
};

std::string exceptionToString(const std::exception& e, uint32_t level = 0);

#endif