CoolProp/include/Exceptions.h

#ifndef CPEXCEPTIONS_H
#define CPEXCEPTIONS_H

#include <exception>
#include <iostream>

namespace CoolProp
{

class CoolPropBaseError: public std::exception
{
protected:
    std::string err; // Can be accessed by subclasses since it is protected
public:
    CoolPropBaseError() throw() {};
    ~CoolPropBaseError() throw() {};
    virtual const char* what() const throw(){ return err.c_str(); }
};

class NotImplementedError: public CoolPropBaseError
{
public:
    NotImplementedError() throw() {};
    NotImplementedError(std::string errstring) throw(){err=errstring;};
    ~NotImplementedError() throw() {};
    virtual const char* what() const throw(){ return err.c_str(); }
};

class SolutionError: public CoolPropBaseError
{
public:
    SolutionError()throw() {};
    SolutionError(std::string errstring) throw(){err=errstring;};
    ~SolutionError() throw() {};
    virtual const char* what() const throw(){ return err.c_str(); }
};

class ValueError: public CoolPropBaseError
{
public:
    ValueError() throw() {};
    ValueError(std::string errstring) throw(){err=errstring;};
    ~ValueError() throw() {};
    virtual const char* what() const throw(){ return err.c_str(); }
};

class AttributeError: public CoolPropBaseError
{
public:
    AttributeError() throw() {};
    AttributeError(std::string errstring) throw() {err=errstring;};
    ~AttributeError() throw() {};
    virtual const char* what() const throw(){ return err.c_str(); }
};

class OutOfRangeError: public ValueError
{
public:
    OutOfRangeError() throw() {};
    OutOfRangeError(std::string errstring) throw() {err=errstring;};
    ~OutOfRangeError() throw() {};
    virtual const char* what() const throw(){ return err.c_str(); }
};

class WrongFluidError: public ValueError
{
public:
    WrongFluidError() throw() {};
    WrongFluidError(std::string errstring) throw() {err=errstring;};
    ~WrongFluidError() throw() {};
    virtual const char* what() const throw(){ return err.c_str(); }
};

class CompositionError: public ValueError
{
public:
    CompositionError() throw() {};
    CompositionError(std::string errstring) throw() {err=errstring;};
    ~CompositionError() throw() {};
    virtual const char* what() const throw(){ return err.c_str(); }
};

class InputError: public ValueError
{
public:
    InputError() throw() {};
    InputError(std::string errstring) throw() {err=errstring;};
    ~InputError() throw() {};
    virtual const char* what() const throw(){ return err.c_str(); }
};

class NotAvailableError: public ValueError
{
public:
    NotAvailableError() throw() {};
    NotAvailableError(std::string errstring) throw() {err=errstring;};
    ~NotAvailableError() throw() {};
    virtual const char* what() const throw(){ return err.c_str(); }
};

}; /* namespace CoolProp */
#endif