C++ Client API Reference for Oracle Coherence: coherence/lang/DetachFinalizer.hpp Source File

00001 /*
00002  * Copyright (c) 2000, 2020, Oracle and/or its affiliates.
00003  *
00004  * Licensed under the Universal Permissive License v 1.0 as shown at
00005  * http://oss.oracle.com/licenses/upl.
00006  */
00007 #ifndef COH_DETACH_FINALIZER_HPP
00008 #define COH_DETACH_FINALIZER_HPP
00009 
00010 #include "coherence/lang/compatibility.hpp"
00011 
00012 #include "coherence/lang/FinalizableBlock.hpp"
00013 
00014 COH_OPEN_NAMESPACE2(coherence,lang)
00015 
00016 
00017 /**
00018 * Finalizer which detaches from an Object upon deletion. The finalizer is
00019 * templated allowing it to work with both const and non-const attachments.
00020 */
00021 template<class T> class DetachFinalizer
00022         : public FinalizableBlock::Finalizer
00023     {
00024     // ----- constructor ----------------------------------------------------
00025 
00026     public:
00027         /**
00028         * Construct a DetachFinalizer to automatically detach from a
00029         * previously attached Object. The caller must have an unmatched
00030         * attachment to the Object.
00031         *
00032         * @param pDetach  pointer to Object to detach from during
00033         *                 finalization
00034         * @param fEscaped if the attachment was escaped
00035         */
00036         DetachFinalizer(T* pDetach = NULL, bool fEscaped = true)
00037                 : m_pDetach(pDetach), m_fEscaped(fEscaped)
00038             {
00039             }
00040 
00041         /**
00042         * Destruct the DetachFinalizer, detaching from the Object in the
00043         * process.
00044         */
00045         virtual ~DetachFinalizer()
00046             {
00047             T* pDetach = m_pDetach;
00048             if (NULL != pDetach)
00049                 {
00050                 pDetach->_detach(m_fEscaped);
00051                 }
00052             }
00053 
00054     // ----- DetachFinalizer interface --------------------------------------
00055 
00056     public:
00057         /**
00058         * Set the Object which the finalizer will detach from.  If there was
00059         * already an Object associated with this finalizer, it will be
00060         * detached as part of this call.
00061         *
00062         * @param pDetach  the Object to detach from upon destruction
00063         * @param fEscaped if the attachment was escaped
00064         *
00065         * @return a pointer to this DetachFinalizer
00066         */
00067         DetachFinalizer* set(T* pDetach, bool fEscaped = true)
00068             {
00069             T*   pOld        = m_pDetach;
00070             bool fEscapedOld = m_fEscaped;
00071 
00072             m_pDetach  = pDetach;
00073             m_fEscaped = fEscaped;
00074 
00075             if (NULL != pOld)
00076                 {
00077                 pOld->_detach(fEscapedOld);
00078                 }
00079             return this;
00080             }
00081 
00082     // ----- data members ---------------------------------------------------
00083 
00084     private:
00085         /**
00086         * Pointer to Object to detach from.
00087         */
00088         T* m_pDetach;
00089 
00090         /**
00091         * The detach escape type.
00092         */
00093         bool m_fEscaped;
00094     };
00095 
00096 COH_CLOSE_NAMESPACE2
00097 
00098 #endif // COH_DETACH_FINALIZER_HPP