/usr/include/Poco/ErrorHandler.h is in libpoco-dev 1.8.0.1-1ubuntu4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 | //
// ErrorHandler.h
//
// Library: Foundation
// Package: Threading
// Module: ErrorHandler
//
// Definition of the ErrorHandler class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_ErrorHandler_INCLUDED
#define Foundation_ErrorHandler_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Exception.h"
#include "Poco/Mutex.h"
namespace Poco {
class Foundation_API ErrorHandler
/// This is the base class for thread error handlers.
///
/// An unhandled exception that causes a thread to terminate is usually
/// silently ignored, since the class library cannot do anything meaningful
/// about it.
///
/// The Thread class provides the possibility to register a
/// global ErrorHandler that is invoked whenever a thread has
/// been terminated by an unhandled exception.
/// The ErrorHandler must be derived from this class and can
/// provide implementations of all three exception() overloads.
///
/// The ErrorHandler is always invoked within the context of
/// the offending thread.
{
public:
ErrorHandler();
/// Creates the ErrorHandler.
virtual ~ErrorHandler();
/// Destroys the ErrorHandler.
virtual void exception(const Exception& exc);
/// Called when a Poco::Exception (or a subclass)
/// caused the thread to terminate.
///
/// This method should not throw any exception - it would
/// be silently ignored.
///
/// The default implementation just breaks into the debugger.
virtual void exception(const std::exception& exc);
/// Called when a std::exception (or a subclass)
/// caused the thread to terminate.
///
/// This method should not throw any exception - it would
/// be silently ignored.
///
/// The default implementation just breaks into the debugger.
virtual void exception();
/// Called when an exception that is neither a
/// Poco::Exception nor a std::exception caused
/// the thread to terminate.
///
/// This method should not throw any exception - it would
/// be silently ignored.
///
/// The default implementation just breaks into the debugger.
static void handle(const Exception& exc);
/// Invokes the currently registered ErrorHandler.
static void handle(const std::exception& exc);
/// Invokes the currently registered ErrorHandler.
static void handle();
/// Invokes the currently registered ErrorHandler.
static ErrorHandler* set(ErrorHandler* pHandler);
/// Registers the given handler as the current error handler.
///
/// Returns the previously registered handler.
static ErrorHandler* get();
/// Returns a pointer to the currently registered
/// ErrorHandler.
protected:
static ErrorHandler* defaultHandler();
/// Returns the default ErrorHandler.
private:
static ErrorHandler* _pHandler;
static FastMutex _mutex;
};
//
// inlines
//
inline ErrorHandler* ErrorHandler::get()
{
return _pHandler;
}
} // namespace Poco
#endif // Foundation_ErrorHandler_INCLUDED
|