osberror.h

Go to the documentation of this file.

// OSB library ************************************************ -*- C++ -*-
/*
  AUTHOR(S): Stephan Broennimann (vb)
             Ramlan Rusdijanto (rr)
             Lilian Qin Lan (lan)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.81 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file 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.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _OSBERROR_H_
#define _OSBERROR_H_

// ************************************************************************
// included header files
// + standard includes
#include <string>
#include <sstream>
#include <vector>

// ************************************************************************
// namespace extensions
namespace OSB_LIB {

// ************************************************************************
// class declarations

    class BaseError {
    public:
        typedef long ErrorNo;
        typedef std::vector<std::string> Args;
        static const ErrorNo noError_ = 0;

    public:
        explicit BaseError(ErrorNo e);
        BaseError(
                  ErrorNo no,
            const Args&   args
        );
        virtual ~BaseError();

    protected:
        BaseError(const BaseError& rhs);
        BaseError& operator=(const BaseError& rhs);

    public:

        BaseError& operator<<(const char* s);
        BaseError& operator<<(const std::string& s);
        template <typename T>
        BaseError& operator<<(const T& t);

    public:
        const std::string what() const;

        bool noError() const;
        bool isError() const;

        ErrorNo no() const;
        std::string code() const;
        const std::string msg() const;

        const Args& args() const;

        virtual const char* const prefix() const = 0;
        virtual const std::string& fileName() const = 0;

    private:
        ErrorNo errorNo_;
    protected:
        Args args_;
    };                                  // class BaseError

    class OsbBaseError : public BaseError {
    public:
        explicit OsbBaseError(ErrorNo e);
        OsbBaseError(
                  ErrorNo e,
            const Args&   args
        );

        virtual ~OsbBaseError() = 0;

    protected:
        OsbBaseError(const OsbBaseError& rhs);
        OsbBaseError& operator=(const OsbBaseError& rhs);

    private:
        static const std::string fileName_;
        // doc from base
        const std::string& fileName() const;
    };                                  // class OsbBaseError

    class OsbError : public OsbBaseError {
    public:
        OsbError();
        explicit OsbError(ErrorNo e);
        OsbError(
            ErrorNo e,
            const Args& args
        );

        const char* const prefix() const;

    private:
        static const char* const prefix_;
    };

    class OsbException : public OsbBaseError {
    public:
        OsbException(ErrorNo e);
        OsbException(
                  ErrorNo e,
            const Args&   args
        );
        virtual ~OsbException() = 0;

    protected:
        OsbException(const OsbException& rhs);
        OsbException& operator=(const OsbException& rhs);

    public:
        const char* const prefix() const;

    private:
        static const char* const prefix_;
    };                                  // class OsbException

    class DefException : public OsbException {
    public:
        DefException(ErrorNo e);
        DefException(
                  ErrorNo e,
            const Args&   args
        );

    public:
        template<typename T>
        DefException& operator<<(const T& t);
    };                                  // class DefException

    // ********************************************************************
    // specialized OsbExceptions
    class ObjectNotFound : public OsbException {
    public:
        ObjectNotFound(ErrorNo e);
    };

    class ObjectModified : public OsbException {
    public:
        ObjectModified(ErrorNo e);
    };                                  // class ObjectModified

    class ObjectBusy : public OsbException {
    public:
        ObjectBusy(ErrorNo e);
    };                                  // class ObjectBusy

    class ObjectDeleted : public OsbException {
    public:
        ObjectDeleted(ErrorNo e);
    };                                  // class ObjectDeleted
}                                       // namespace OSB_LIB

// ************************************************************************
// inline definitions
namespace OSB_LIB {

    // ********************************************************************
    // class BaseError
    inline BaseError::BaseError(ErrorNo e) : errorNo_(e)
    {
        // empty
    }

    inline BaseError::BaseError(
              ErrorNo no,
        const Args&   args
    ) : errorNo_(no), args_(args)
    {
        // empty
    }

    inline BaseError::BaseError(const BaseError& rhs)
      : errorNo_(rhs.errorNo_),
        args_(rhs.args_)
    {
        // empty
    }

    inline BaseError& BaseError::operator=(const BaseError& rhs)
    {
        if (&rhs != this) {
            errorNo_  = rhs.errorNo_;
            args_     = rhs.args_;
        }
        return *this;
    }

    inline BaseError::~BaseError()
    {
        // empty
    }

    inline bool BaseError::noError() const
    {
        return noError_ == errorNo_;
    }

    inline bool BaseError::isError() const
    {
        return noError_ != errorNo_;
    }

    inline BaseError& BaseError::operator<<(const char* s)
    {
        args_.push_back(s);
        return *this;
    }

    inline BaseError& BaseError::operator<<(const std::string& s)
    {
        args_.push_back(s);
        return *this;
    }

    template <typename T>
    inline BaseError& BaseError::operator<<(const T& t)
    {
        std::ostringstream os;
        os << t;
        args_.push_back(os.str());
        return *this;
    }

    // ********************************************************************
    // class OsbBaseError
    inline OsbBaseError::OsbBaseError(ErrorNo e)
      : BaseError(e)
    {
        // empty
    }

    inline OsbBaseError::OsbBaseError(
              ErrorNo e,
        const Args&   args
    ) : BaseError(e, args)
    {
        // empty
    }

    inline OsbBaseError::OsbBaseError(const OsbBaseError& rhs)
      : BaseError(rhs)
    {
        // empty
    }

    inline OsbBaseError& OsbBaseError::operator=(const OsbBaseError& rhs)
    {
        BaseError::operator=(rhs);
        return *this;
    }

    inline OsbBaseError::~OsbBaseError()
    {
        // empty
    }

    // ********************************************************************
    // class OsbError
    inline OsbError::OsbError()
      : OsbBaseError(noError_)
    {
        // empty
    }

    inline OsbError::OsbError(ErrorNo e)
      : OsbBaseError(e)
    {
        // empty
    }

    inline OsbError::OsbError(
        ErrorNo e,
        const Args& args
    ) : OsbBaseError(e, args)
    {
        // empty
    }

    inline const char* const OsbError::prefix() const
    {
        return prefix_;
    }

    // ********************************************************************
    // class OsbException
    inline OsbException::OsbException(ErrorNo e)
      : OsbBaseError(e)
    {
        // empty
    }

    inline OsbException::OsbException(
              ErrorNo e,
        const Args&   args
    ) : OsbBaseError(e, args)
    {
        // empty
    }

    inline OsbException::OsbException(const OsbException& rhs)
      : OsbBaseError(rhs)
    {
        // empty
    }

    inline OsbException& OsbException::operator=(const OsbException& rhs)
    {
        if (this != &rhs) OsbBaseError::operator=(rhs);
        return *this;
    }

    inline OsbException::~OsbException()
    {
        // empty
    }

    inline const char* const OsbException::prefix() const
    {
        return prefix_;
    }

    // ********************************************************************
    // class DefException
    inline DefException::DefException(ErrorNo e)
      : OsbException(e)
    {
        // empty
    }

    inline DefException::DefException(
              ErrorNo e,
        const Args&   args
    ) : OsbException(e, args)
    {
        // empty
    }

    template<typename T>
    inline DefException& DefException::operator<<(const T& t)
    {
        OsbException::operator<<(t);
        return *this;
    }

    // ********************************************************************
    // specialized OsbExceptions
    inline ObjectNotFound::ObjectNotFound(ErrorNo e)
      : OsbException(e)
    {
        // empty
    }

    inline ObjectModified::ObjectModified(ErrorNo e)
      : OsbException(e)
    {
        // empty
    }

    inline ObjectBusy::ObjectBusy(ErrorNo e)
      : OsbException(e)
    {
        // empty
    }

    inline ObjectDeleted::ObjectDeleted(ErrorNo e)
      : OsbException(e)
    {
        // empty
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _OSBERROR_H

---