TPCCondDataExeptions.h

#ifndef TPCCONDDATA_EXCEPTION_H
#define TPCCONDDATA_EXCEPTION_H 1

#include <string>
#include <exception>

/*
 *  Define some exceptions similar to the ones used in hep.lcd.io
 *  The exceptions should be part of the corresponding namespace,
 *  therefore some exceptions were duplicated here from marlintpc/general.
 */

namespace tpcconddata
{

    class Exception : public std::exception
    {

        protected:
            std::string message;

            Exception()
            { /*no_op*/
                ;
            }


        public:
            virtual ~Exception() throw()
            { /*no_op*/
                ;
            }


            Exception(const std::string& text)
            {
                message = "tpcconddata::Exception: " + text;
            }

            Exception(const std::string& ClassName, const std::string& Message) :
                        message(std::string("marlintpc::Exception in object of class ")
                                + ClassName + " : " + Message)
            { /*no_op*/
                ;
            }

            virtual const char* what() const throw()
            {
                return (message.c_str());
            }


    };

    class ConditionsObjectException : public Exception
    {

        protected:
            ConditionsObjectException()
            { /*no_op*/
                ;
            }

        public:
            virtual ~ConditionsObjectException() throw()
            { /*no_op*/
                ;
            }


            ConditionsObjectException(std::string text)
            {
                message = "tpcconddata::ConditionsObjectException: " + text;
            }
    };

    class CondDataNotAvailableException : public ConditionsObjectException
    {

        public:
            virtual ~CondDataNotAvailableException() throw()
            { /*no_op*/
                ;
            }


            CondDataNotAvailableException(std::string text)
            {
                message = "tpcconditions::CondDataNotAvailableException: " + text;
            }

    };

    class CondDataWrongObjectException : public ConditionsObjectException
    {

        public:
            virtual ~CondDataWrongObjectException() throw()
            { /*no_op*/
                ;
            }


            CondDataWrongObjectException(std::string text)
            {
                message = "tpcconditions::CondDataWrongObjectException: " + text;
            }

    };

    class InvalidDataException : public Exception
    {
        public:
            virtual ~InvalidDataException() throw()
            { /*no_op*/
            }
            InvalidDataException() :
                    Exception("The data is not valid.")
            { /*no_op*/
            }

            InvalidDataException(const std::string &err) :
                    Exception(err)
            { /*no_op*/
            }

            InvalidDataException(const std::string& ClassName,
                    const std::string& Message) :
                    Exception(ClassName, Message)
            { /*no_op*/
            }
    };

} // namespace

#endif /* ifndef TPCCONDDATA_EXCEPTION_H */