xrl_error.hh

// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-
// vim:set sts=4 ts=8:

// Copyright (c) 2001-2011 XORP, Inc and Others
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License, Version
// 2.1, June 1999 as published by the Free Software Foundation.
// Redistribution and/or modification of this program under the terms of
// any other version of the GNU Lesser General Public License is not
// permitted.
// 
// 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. For more details,
// see the GNU Lesser General Public License, Version 2.1, a copy of
// which can be found in the XORP LICENSE.lgpl file.
// 
// XORP, Inc, 2953 Bunker Hill Lane, Suite 204, Santa Clara, CA 95054, USA;
// http://xorp.net

// $XORP: xorp/libxipc/xrl_error.hh,v 1.21 2008/10/02 21:57:24 bms Exp $

#ifndef __LIBXIPC_XRL_ERROR_HH__
#define __LIBXIPC_XRL_ERROR_HH__

#include "libxorp/xorp.h"
#include "libxorp/c_format.hh"


class XrlErrlet;

enum XrlErrorCode {
    OKAY          = 100,
    BAD_ARGS          = 101,
    COMMAND_FAILED    = 102,

    NO_FINDER         = 200,
    RESOLVE_FAILED    = 201,
    NO_SUCH_METHOD    = 202,

    SEND_FAILED       = 210,
    REPLY_TIMED_OUT   = 211,
    SEND_FAILED_TRANSIENT = 212,

    INTERNAL_ERROR    = 220
};

class XrlError {
public:
    static const XrlError& OKAY();

    static const XrlError& BAD_ARGS();

    static const XrlError& COMMAND_FAILED();

    static const XrlError& NO_FINDER();

    static const XrlError& RESOLVE_FAILED();

    static const XrlError& NO_SUCH_METHOD();

    static const XrlError& SEND_FAILED();

    static const XrlError& REPLY_TIMED_OUT();

    static const XrlError& SEND_FAILED_TRANSIENT();

    static const XrlError& INTERNAL_ERROR();

    XrlErrorCode error_code() const;

    bool isOK() const { return error_code() == ::OKAY; }

    const char* error_msg() const;

    const string& note() const { return _note; }

    string str() const {
    string r = c_format("%d ", error_code()) + error_msg();
    return note().size() ? (r + " " + note()) : r;
    }

    static bool known_code(uint32_t code);

    XrlError();
    XrlError(XrlErrorCode error_code, const string& note = "");
    XrlError(const XrlError& xe) : _errlet(xe._errlet), _note(xe._note) {}

    /* Strictly for classes that have access to XrlErrlet to construct
       XrlError's */
    XrlError(const XrlErrlet& x, const string& note = "") :
    _errlet(&x), _note(note) {}

    XrlError(const XrlErrlet*);

protected:
    const XrlErrlet* _errlet;
    string       _note;
};


struct XrlCmdError {
public:
    static const XrlCmdError& OKAY() { return _xce_ok; }

    static const XrlCmdError BAD_ARGS(const string& reason = "") {
    return XrlError(XrlError::BAD_ARGS().error_code(), reason);
    }

    static const XrlCmdError COMMAND_FAILED(const string& reason = "") {
    return XrlError(XrlError::COMMAND_FAILED().error_code(), reason);
    }

    operator XrlError() const { return _xrl_error; }

    string str() const { return string("XrlCmdError ") + _xrl_error.str(); }

    XrlErrorCode error_code() const { return _xrl_error.error_code(); }

    bool isOK() const { return _xrl_error.isOK(); }

    const string& note() const { return _xrl_error.note(); }

private:
    XrlCmdError(const XrlError& xe) : _xrl_error(xe) {}
    XrlError _xrl_error;
    static XrlCmdError _xce_ok;
};


inline bool operator==(const XrlError& e1, const XrlError& e2)
{
    return e1.error_code() == e2.error_code();
}

inline bool operator!=(const XrlError& e1, const XrlError& e2)
{
    return e1.error_code() != e2.error_code();
}

#endif // __LIBXIPC_XRL_ERROR_HH__