coherence/lang/DetachFinalizer.hpp

/*
* DetachFinalizer.hpp
*
* Copyright 2001-2008 by Oracle. All rights reserved.
*
* Oracle is a registered trademarks of Oracle Corporation and/or its
* affiliates.
*
* This software is the confidential and proprietary information of Oracle
* Corporation. You shall not disclose such confidential and proprietary
* information and shall use it only in accordance with the terms of the
* license agreement you entered into with Oracle.
*
* This notice may not be removed or altered.
*/
#ifndef COH_DETACH_FINALIZER_HPP
#define COH_DETACH_FINALIZER_HPP

#include "coherence/lang/compatibility.hpp"

#include "coherence/lang/FinalizableBlock.hpp"

COH_OPEN_NAMESPACE2(coherence,lang)


/**
* Finalizer which detaches from an Object upon deletion. The finalizer is
* templated allowing it to work with both const and non-const attachments.
*/
template<class T> class DetachFinalizer
        : public FinalizableBlock::Finalizer
    {
    // ----- constructor ----------------------------------------------------

    public:
        /**
        * Construct a DetachFinalizer to automatically detach from a
        * previously attached Object. The caller must have an unmatched
        * attacment to the Object.
        *
        * @param pDetach  pointer to Object to detach from during
        *                 finalization
        */
        DetachFinalizer(T* pDetach = NULL)
                : m_pDetach(pDetach)
            {
            }

        /**
        * Destruct the DetachFinalizer, detaching from the Object in the
        * process.
        */
        virtual ~DetachFinalizer()
            {
            T* pDetach = m_pDetach;
            if (NULL != pDetach)
                {
                pDetach->_detach();
                }
            }

    // ----- DetachFinalizer interface --------------------------------------

    public:
        /**
        * Set the Object which the finalizer will detach from.  If there was
        * already an Object associated with this finalizer, it will be
        * detached as part of this call.
        *
        * @param pDetach  the Object to detach from upon destruction
        *
        * @return a pointer to this DetachFinalizer
        */
        DetachFinalizer* set(T* pDetach)
            {
            T* pOld = m_pDetach;
            m_pDetach = pDetach;

            if (NULL != pOld)
                {
                pOld->_detach();
                }
            return this;
            }

    // ----- data members ---------------------------------------------------

    private:
        /**
        * Pointer to Object to detach from.
        */
        T* m_pDetach;
    };

COH_CLOSE_NAMESPACE2

#endif // COH_DETACH_FINALIZER_HPP

Copyright (c) 2000-2008 Oracle. All rights reserved.