deferred_deleter.h

Go to the documentation of this file.

/*
  This file is part of MADNESS.

  Copyright (C) 2007,2010 Oak Ridge National Laboratory

  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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

  For more information please contact:

  Robert J. Harrison
  Oak Ridge National Laboratory
  One Bethel Valley Road
  P.O. Box 2008, MS-6367

  email: harrisonrj@ornl.gov
  tel:   865-241-3937
  fax:   865-572-0680


  $Id$
*/

#ifndef MADNESS_WORLD_DEFERRED_DELETER_H__INCLUDED
#define MADNESS_WORLD_DEFERRED_DELETER_H__INCLUDED

#include <madness/world/shared_ptr.h>
#include <madness/world/typestuff.h>
#include <madness/world/deferred_cleanup.h>

namespace madness {


    template <typename ptrT, typename deleterT = void(*)(ptrT*)>
    class DeferredDeleter {
    private:
        // Hold a shared pointer to the deferred deleter object to make sure it
        // is available for all deleter objects, even if the gop object is gone.
        std::shared_ptr<detail::DeferredCleanup> deferred_; 
        deleterT deleter_;  

    public:
        template <typename D>
        static typename enable_if<std::is_same<D, void(*)(ptrT*)>, D>::type
        default_deleter() { return & madness::detail::checked_delete<ptrT>; }

        template <typename D>
        static typename disable_if<std::is_same<D, void(*)(ptrT*)>, D>::type
        default_deleter() { return D(); }


        DeferredDeleter(World& w, deleterT d = default_deleter<deleterT>()) :
            deferred_(detail::DeferredCleanup::get_deferred_cleanup(w)), deleter_(d)
        { }


        DeferredDeleter(const DeferredDeleter<ptrT, deleterT>& other) :
            deferred_(other.deferred_), deleter_(other.deleter_)
        { }


        DeferredDeleter<ptrT, deleterT>& operator=(const DeferredDeleter<ptrT, deleterT>& other) {
            deferred_ = other.deferred_;
            deleter_ = other.deleter_;
            return *this;
        }


        void operator()(ptrT* p) const {
            std::shared_ptr<ptrT> temp(p, deleter_); // do not store this pointer
                                                // that is the job of deferred_
            deferred_->add(std::static_pointer_cast<void>(temp));
        }
    }; // class DeferredDeleter


    template <typename ptrT, typename deleterT>
    inline DeferredDeleter<ptrT,deleterT> make_deferred_deleter(World& w, deleterT d) {
        return DeferredDeleter<ptrT, deleterT>(w, d);
    }


    template <typename ptrT>
    inline DeferredDeleter<ptrT> make_deferred_deleter(World& w) {
        return DeferredDeleter<ptrT>(w);
    }

}  // namespace madness

#endif // MADNESS_WORLD_DEFERRED_DELETER_H__INCLUDED