exception.h

用c++包装好的线程库,直接拿来使用,提高效率.

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

/**
 * Copyright (c) 2000
 *
 * A C++ implementation of Asynchronous Input/Output, using threaded
 * objects to handle the data.
 *
 */

#ifndef THREAD_EXCEPTION
#define THREAD_EXCEPTION

#include <string>
#include <exception>

extern "C" {

#include <setjmp.h>

};

namespace cpp_threads {

  /**
   * Exception
   *
   * A common class, that holds all kinds of errors that can be
   * cought by an exception handler.  The handler, can than
   * act on the error reported.
   *
   * Some compilers, do not make the actual data in the class
   * until after the constructor has finished.  This does
   * constitute a problem in some cases, which introduces for
   * us more types of exceptions.  A fatal exception, will be
   * thrown right away, inside the constructor, while other
   * kinds must be thrown by the user.
   *
   * @short Abstract class for exceptions.
   * @author Orn E. Hansen <[e-mail]>
   */
  class exception : public std::exception {
  public:
    /**
     * These are the kinds of exceptions, that are defined.  In
     * C++ there is only one possible exception, a fatal one,
     * as it is not possible to return from the exception handler,
     * but this just *may* be possible in future version, and is
     * the intention of these exception types.
     */
    enum tType {
      /** Undefined exception... same as none. */
      ex_none,
      /** A fatal exception, that will always result in a throw. */
      ex_fatal,
      /** Reserved for future expansion, non fatal warning. */
      ex_warning,
      /** Reserved for future expansion, non fatal interception requested. */
      ex_intercept
    };

  private:
    std::string mTextMessage;
    void       *mBuffer;
    tType       mErrorKind;
    int         mErrno;
    bool        mState;
    sigjmp_buf  mEnv;

  public:
    /**
     * The typical construction of an exception, will merely
     * hold a textual message, and throw an error.  The
     * constructor takes two parameters, one being the message
     * and the other the type of exception.  The type, as
     * give in the enumeration above, will determine wether the
     * exception creation will terminate immediately or
     * wait until the programmer determines it should.
     *
     * @param s String message
     * @param t Type of exception
     */
    exception(const std::string&,tType t=ex_fatal);
    virtual ~exception() throw();

    /**
     * Each exception may hold a numerical error, in accordance
     * with C errno variable.  This is to set this error number
     * to a specific value.  Setting the errno to 0, in an exception
     * handler that has already been thrown, and is not a fatal
     * exception, will return to the point where it was thrown.  Thus
     * giving the user the ability to correct an error.
     *
     * @param n The error number value.
     */
    void setError(int);
    /**
     * Return the value of the error variable, as set during the
     * exceptioon process.
     *
     * @return The error value.
     */
    int error();

    /**
     * Set the message, this exception will contain.  Usually a
     * textual representation of the error.
     *
     * @param t String containing the error message
     */
    void setMessage(const std::string&);

    /**
     * Obtain the error message, this is the std::exception
     * method for this.
     *
     * @return Error message.
     */
    const char *what();

    /**
     * Obtain the error message, set during the exception
     * process.
     *
     * @return Error message.
     */
    std::string message() const;

    /**
     * Set the exception type, if different from the
     * created one.  How useful this is, not very... but when
     * exceptions become recoverable, on class may be reusable
     * for error processing/recovering.
     *
     * @param t The exception type.
     */
    virtual void setException(tType);
    /**
     * Obtain the severity of the exception, as stated during the
     * exception processing.
     *
     * @return Error severity, exception type.
     */
    tType severity();

    /**
     * A static member, that creates a textual exception with some
     * specific type.  The exception will be throw immediately upon
     * creation.
     *
     * @param s String message for the error.
     * @param t The type of exception to create.
     */
    static void staticException(const std::string&,tType);
    /**
     * This static member, creates an error with an integer value
     * that is assumed to be in accordance with the C errno variable,
     * and the textual message of this error is loaded as the
     * text message, before throwing the exception.
     *
     * @param n Error value, according to errno values.
     * @param t The exception type to create.
     */
    static void staticException(int,tType);

    static void fatal(int e)               
      { staticException(e,ex_fatal);     };
    static void fatal(const std::string& p)     
      { staticException(p,ex_fatal);     };
    static void warning(int e)             
      { staticException(e,ex_warning);   };
    static void warning(const std::string& p)   
      { staticException(p,ex_warning);   };
    static void intercept(int e)           
      { staticException(e,ex_intercept); };
    static void intercept(const std::string& p) 
      { staticException(p,ex_intercept); };
  };

};

#endif