Exceptions.h

/*
 * Copyright (c) 2015 Pavel Vainerman.
 *
 * This program 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, version 2.1.
 *
 * 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
 * Lesser General Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
#ifndef Exceptions_h_
#define Exceptions_h_
// ---------------------------------------------------------------------------
#include <ostream>
#include <iostream>
#include <string>
#include <exception>
// ---------------------------------------------------------------------
 
namespace uniset
{
    // namespase UniSetExceptions
 
    class Exception:
        public std::exception
    {
        public:
 
            Exception(const std::string& txt) noexcept: text(txt) {}
            Exception() noexcept: text("Exception") {}
            virtual ~Exception() noexcept(true) {}
 
            friend std::ostream& operator<<(std::ostream& os, const Exception& ex )
            {
                os << ex.text;
                return os;
            }
 
            virtual const char* what() const noexcept override
            {
                return text.c_str();
            }
 
        protected:
            const std::string text;
    };
 
    class OutOfRange: public Exception
    {
        public:
            OutOfRange() noexcept: Exception("OutOfRange") {}
            OutOfRange(const std::string& err) noexcept: Exception(err) {}
    };
 
    class ORepFailed: public Exception
    {
        public:
            ORepFailed() noexcept: Exception("ORepFailed") {}
 
            ORepFailed(const std::string& err) noexcept: Exception(err) {}
    };
 
 
    class SystemError: public Exception
    {
        public:
            SystemError() noexcept: Exception("SystemError") {}
 
            SystemError(const std::string& err) noexcept: Exception(err) {}
    };
 
    class CommFailed: public Exception
    {
        public:
            CommFailed() noexcept: Exception("CommFailed") {}
 
            CommFailed(const std::string& err) noexcept: Exception(err) {}
    };
 
 
    class TimeOut: public CommFailed
    {
        public:
            TimeOut() noexcept: CommFailed("TimeOut") {}
 
            TimeOut(const std::string& err) noexcept: CommFailed(err) {}
 
    };
 
    class ResolveNameError: public ORepFailed
    {
        public:
            ResolveNameError() noexcept: ORepFailed("ResolveNameError") {}
            ResolveNameError(const std::string& err) noexcept: ORepFailed(err) {}
    };
 
 
    class NSResolveError: public ORepFailed
    {
        public:
            NSResolveError() noexcept: ORepFailed("NSResolveError") {}
            NSResolveError(const std::string& err) noexcept: ORepFailed(err) {}
    };
 
 
    class ObjectNameAlready: public ResolveNameError
    {
        public:
            ObjectNameAlready() noexcept: ResolveNameError("ObjectNameAlready") {}
 
            ObjectNameAlready(const std::string& err) noexcept: ResolveNameError(err) {}
    };
 
    class IOBadParam: public Exception
    {
        public:
            IOBadParam() noexcept: Exception("IOBadParam") {}
 
            IOBadParam(const std::string& err) noexcept: Exception(err) {}
    };
 
    class InvalidObjectName: public ResolveNameError
    {
        public:
            InvalidObjectName() noexcept: ResolveNameError("InvalidObjectName") {}
            InvalidObjectName(const std::string& err) noexcept: ResolveNameError(err) {}
    };
 
    class NameNotFound: public ResolveNameError
    {
        public:
            NameNotFound() noexcept: ResolveNameError("NameNotFound") {}
            NameNotFound(const std::string& err) noexcept: ResolveNameError(err) {}
    };
 
    // end of UniSetException group
    // ---------------------------------------------------------------------
}   // end of uniset namespace
// ---------------------------------------------------------------------
#endif // Exception_h_
// ---------------------------------------------------------------------