exceptions.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/libxorp/exceptions.hh,v 1.12 2009/01/05 18:30:57 jtc Exp $


#ifndef __LIBXORP_EXCEPTIONS_HH__
#define __LIBXORP_EXCEPTIONS_HH__

#include "xorp.h"

#ifdef XORP_USE_USTL
#include <ustl/uexception.h>
using namespace std;
#else
#include <exception>
#endif

#include <stdarg.h>

#include "libxorp/c_format.hh"

#define xorp_throw(_class, args...) \
    throw _class(__FILE__, __LINE__, args);

#define xorp_throw0(_class) \
    throw _class(__FILE__, __LINE__);

class XorpException {
public:
    XorpException(const char* init_what, const char* file, size_t line);

    virtual ~XorpException();

    const string& what() const { return _what; }

    const string where() const;

    virtual const string why() const;

    string str() const;

protected:
    string  _what;      // The type of exception
    const char* _file;      // The file name where exception occured
    size_t  _line;      // The line number where exception occured
};

class XorpReasonedException : public XorpException {
public:
    XorpReasonedException(const char* init_what, const char* file, 
              size_t line, const string& init_why);

    const string why() const;

protected:
    string _why;        // The reason for the exception
};

// ----------------------------------------------------------------------------
// Standard XORP exceptions

class InvalidString : public XorpReasonedException {
public:
    InvalidString(const char* file, size_t line, const string& init_why = "");
};

class InvalidAddress : public XorpReasonedException {
public:
    InvalidAddress(const char* file, size_t line, const string& init_why = "");
};

class InvalidPort : public XorpReasonedException {
public:
    InvalidPort(const char* file, size_t line, const string& init_why = "");
};

class InvalidCast : public XorpReasonedException {
public:
    InvalidCast(const char* file, size_t line, const string& init_why = "");
};

class InvalidBufferOffset : public XorpReasonedException {
public:
    InvalidBufferOffset(const char* file, size_t line,
            const string& init_why = "");
};

class InvalidFamily : public XorpException {
public:
    InvalidFamily(const char* file, size_t line, int af);
    const string why() const;

protected:
    int _af;
};

class InvalidPacket : public XorpReasonedException {
public:
    InvalidPacket(const char* file, size_t line, const string& init_why = "");
};

class InvalidNetmaskLength : public XorpException {
public:
    InvalidNetmaskLength(const char* file, size_t line, int netmask_length);
    const string why() const;

protected:
    int _netmask_length;
};


// ----------------------------------------------------------------------------

void xorp_catch_standard_exceptions();

void xorp_print_standard_exceptions();

void xorp_unexpected_handler();

class XorpUnexpectedHandler {
public:
    XorpUnexpectedHandler(unexpected_handler h = xorp_unexpected_handler) {
    _oh = set_unexpected(h);
    }
    ~XorpUnexpectedHandler() { set_unexpected(_oh); }
private:
    unexpected_handler _oh;
};

#endif // __LIBXORP_EXCEPTIONS_HH__