//===-- CleanUp.h -----------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef liblldb_CleanUp_h_ #define liblldb_CleanUp_h_ #include "lldb/lldb-public.h" namespace lldb_utility { //---------------------------------------------------------------------- // Templated class that guarantees that a cleanup callback function will // be called. The cleanup function will be called once under the // following conditions: // - when the object goes out of scope // - when the user explicitly calls clean. // - the current value will be cleaned up when a new value is set using // set(T value) as long as the current value hasn't already been cleaned. // // This class is designed to be used with simple types for type T (like // file descriptors, opaque handles, pointers, etc). If more complex // type T objects are desired, we need to probably specialize this class // to take "const T&" for all input T parameters. Yet if a type T is // complex already it might be better to build the cleanup funcionality // into T. // // The cleanup function must take one argument that is of type T. // The calback fucntion return type is R. The return value is currently // needed for "CallbackType". If there is an easy way to get around the // need for the return value we can change this class. // // The two template parameters are: // T - The variable type of value that will be stored and used as the // sole argument for the cleanup callback. // R - The return type for the cleanup function. // // EXAMPLES // // Use with file handles that get opened where you want to close // // them. Below we use "int open(const char *path, int oflag, ...)" // // which returns an integer file descriptor. -1 is the invalid file // // descriptor so to make an object that will call "int close(int fd)" // // automatically we can use: // // CleanUp <int, int> fd(open("/tmp/a.txt", O_RDONLY, 0), -1, close); // // // malloc/free example // CleanUp <void *, void> malloced_bytes(malloc(32), NULL, free); //---------------------------------------------------------------------- template <typename T, typename R = void> class CleanUp { public: typedef T value_type; typedef R (*CallbackType)(value_type); //---------------------------------------------------------------------- // Constructor that sets the current value only. No values are // considered to be invalid and the cleanup function will be called // regardless of the value of m_current_value. //---------------------------------------------------------------------- CleanUp (value_type value, CallbackType callback) : m_current_value (value), m_invalid_value (), m_callback (callback), m_callback_called (false), m_invalid_value_is_valid (false) { } //---------------------------------------------------------------------- // Constructor that sets the current value and also the invalid value. // The cleanup function will be called on "m_value" as long as it isn't // equal to "m_invalid_value". //---------------------------------------------------------------------- CleanUp (value_type value, value_type invalid, CallbackType callback) : m_current_value (value), m_invalid_value (invalid), m_callback (callback), m_callback_called (false), m_invalid_value_is_valid (true) { } //---------------------------------------------------------------------- // Automatically cleanup when this object goes out of scope. //---------------------------------------------------------------------- ~CleanUp () { clean(); } //---------------------------------------------------------------------- // Access the value stored in this class //---------------------------------------------------------------------- value_type get() { return m_current_value; } //---------------------------------------------------------------------- // Access the value stored in this class //---------------------------------------------------------------------- const value_type get() const { return m_current_value; } //---------------------------------------------------------------------- // Reset the owned value to "value". If a current value is valid and // the cleanup callback hasn't been called, the previous value will // be cleaned up (see void CleanUp::clean()). //---------------------------------------------------------------------- void set (const value_type value) { // Cleanup the current value if needed clean (); // Now set the new value and mark our callback as not called m_callback_called = false; m_current_value = value; } //---------------------------------------------------------------------- // Checks is "m_current_value" is valid. The value is considered valid // no invalid value was supplied during construction of this object or // if an invalid value was supplied and "m_current_value" is not equal // to "m_invalid_value". // // Returns true if "m_current_value" is valid, false otherwise. //---------------------------------------------------------------------- bool is_valid() const { if (m_invalid_value_is_valid) return m_current_value != m_invalid_value; return true; } //---------------------------------------------------------------------- // This function will call the cleanup callback provided in the // constructor one time if the value is considered valid (See is_valid()). // This function sets m_callback_called to true so we don't call the // cleanup callback multiple times on the same value. //---------------------------------------------------------------------- void clean() { if (m_callback && !m_callback_called) { m_callback_called = true; if (is_valid()) m_callback(m_current_value); } } //---------------------------------------------------------------------- // Cancels the cleanup that would have been called on "m_current_value" // if it was valid. This function can be used to release the value // contained in this object so ownership can be transfered to the caller. //---------------------------------------------------------------------- value_type release () { m_callback_called = true; return m_current_value; } private: value_type m_current_value; const value_type m_invalid_value; CallbackType m_callback; bool m_callback_called; bool m_invalid_value_is_valid; // Outlaw default constructor, copy constructor and the assignment operator DISALLOW_COPY_AND_ASSIGN (CleanUp); }; template <typename T, typename R, typename A0> class CleanUp2 { public: typedef T value_type; typedef R (*CallbackType)(value_type, A0); //---------------------------------------------------------------------- // Constructor that sets the current value only. No values are // considered to be invalid and the cleanup function will be called // regardless of the value of m_current_value. //---------------------------------------------------------------------- CleanUp2 (value_type value, CallbackType callback, A0 arg) : m_current_value (value), m_invalid_value (), m_callback (callback), m_callback_called (false), m_invalid_value_is_valid (false), m_argument(arg) { } //---------------------------------------------------------------------- // Constructor that sets the current value and also the invalid value. // The cleanup function will be called on "m_value" as long as it isn't // equal to "m_invalid_value". //---------------------------------------------------------------------- CleanUp2 (value_type value, value_type invalid, CallbackType callback, A0 arg) : m_current_value (value), m_invalid_value (invalid), m_callback (callback), m_callback_called (false), m_invalid_value_is_valid (true), m_argument(arg) { } //---------------------------------------------------------------------- // Automatically cleanup when this object goes out of scope. //---------------------------------------------------------------------- ~CleanUp2 () { clean(); } //---------------------------------------------------------------------- // Access the value stored in this class //---------------------------------------------------------------------- value_type get() { return m_current_value; } //---------------------------------------------------------------------- // Access the value stored in this class //---------------------------------------------------------------------- const value_type get() const { return m_current_value; } //---------------------------------------------------------------------- // Reset the owned value to "value". If a current value is valid and // the cleanup callback hasn't been called, the previous value will // be cleaned up (see void CleanUp::clean()). //---------------------------------------------------------------------- void set (const value_type value) { // Cleanup the current value if needed clean (); // Now set the new value and mark our callback as not called m_callback_called = false; m_current_value = value; } //---------------------------------------------------------------------- // Checks is "m_current_value" is valid. The value is considered valid // no invalid value was supplied during construction of this object or // if an invalid value was supplied and "m_current_value" is not equal // to "m_invalid_value". // // Returns true if "m_current_value" is valid, false otherwise. //---------------------------------------------------------------------- bool is_valid() const { if (m_invalid_value_is_valid) return m_current_value != m_invalid_value; return true; } //---------------------------------------------------------------------- // This function will call the cleanup callback provided in the // constructor one time if the value is considered valid (See is_valid()). // This function sets m_callback_called to true so we don't call the // cleanup callback multiple times on the same value. //---------------------------------------------------------------------- void clean() { if (m_callback && !m_callback_called) { m_callback_called = true; if (is_valid()) m_callback(m_current_value, m_argument); } } //---------------------------------------------------------------------- // Cancels the cleanup that would have been called on "m_current_value" // if it was valid. This function can be used to release the value // contained in this object so ownership can be transfered to the caller. //---------------------------------------------------------------------- value_type release () { m_callback_called = true; return m_current_value; } private: value_type m_current_value; const value_type m_invalid_value; CallbackType m_callback; bool m_callback_called; bool m_invalid_value_is_valid; A0 m_argument; // Outlaw default constructor, copy constructor and the assignment operator DISALLOW_COPY_AND_ASSIGN (CleanUp2); }; } // namespace lldb_utility #endif // #ifndef liblldb_CleanUp_h_