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 AccessDenied: public Exception
    {
        public:
            AccessDenied() noexcept: AccessDenied("AccessDenied") {}
            AccessDenied(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_
// ---------------------------------------------------------------------