del-stash.hpp

Go to the documentation of this file.

/*
  DEL-STASH.hpp  -  collect and execute deleter functions

  Copyright (C)         Lumiera.org
    2010,               Hermann Vosseler <Ichthyostega@web.de>

  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., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef LIB_DEL_STASH_H
#define LIB_DEL_STASH_H


#include "lib/error.hpp"
#include "lib/symbol.hpp"
#include "lib/nocopy.hpp"

#include <algorithm>
#include <vector>


namespace lib {
  
  
  class DelStash
    : util::NonCopyable
    {
      
      typedef void KillFun(void*);
      
      class Killer
        {
          void* target_;
          KillFun* killIt_;
          
        public:
          Killer(KillFun* f, void* t)
            : target_{t}
            , killIt_{f}
            {
              REQUIRE(f);
            }
          
          void
          trigger()
            {
              if (target_)
                killIt_(target_);
              target_ = NULL; // remember kill
            }
          
          bool operator== (const void* target)  const { return target_ == target; }
          bool operator!= (const void* target)  const { return target_ != target; }
          
          bool
          isActive()  const
            {
              return bool(target_);
            }
        };
      
      
      typedef std::vector<Killer> Killers;
      
      Killers killers_;
      
      
    public:
      DelStash (size_t elms_to_reserve =0)
        : killers_()
        {
          if (elms_to_reserve)
            {
              killers_.reserve (elms_to_reserve);
            }
        }
      
     ~DelStash ()
        try { killAll(); }
        
        catch(...)
          {
            Symbol errID = lumiera_error();
            WARN (memory, "Problems on de-allocation: %s", errID.c());
          }
      
      
      size_t
      size ()  const
        {
          size_t activeEntries = 0;
          size_t i = killers_.size();
          while (i)
            if (killers_[--i].isActive())
              ++activeEntries;
          return activeEntries;
        }
      
      
      
      template<typename TY>
      void
      manage (TY* obj)//,  __disable_if_voidPtr<TY> =0)
        {
          if (!obj) return;
          REQUIRE (!isRegistered (obj));
          killers_.push_back (Killer (how_to_kill<TY>, obj));
        }
      
      template<typename TY>
      void
      manage (TY& obj)//,  __disable_if_voidPtr<TY> =0)
        {
          REQUIRE (!isRegistered (&obj));
          killers_.push_back (Killer (how_to_kill<TY>, &obj));
        }
      
      void
      manage (void* obj, KillFun* customDeleter)
        {
          if (!obj) return;
          REQUIRE (!isRegistered (obj));
          killers_.push_back (Killer (customDeleter, obj));
        }
      
      
      template<typename TY>
      void
      kill (TY* obj)
        {
          triggerKill (obj);
        } // note: entry remains in the killer vector,
         //  but is disabled and can't be found anymore
      
      template<typename TY>
      void
      kill (TY& obj)
        {
          triggerKill (&obj);
        }
      
      void
      killAll ()
        {
          size_t i = killers_.size();
          while (i)
            killers_[--i].trigger();
        }
      
      
    private:
      template<typename X>
      static void
      how_to_kill (void* subject)
        {
          X* victim = static_cast<X*> (subject);
          ENSURE (victim);
          delete victim;
        };
      
      bool
      isRegistered (const void* objAddress)
        {
          REQUIRE (objAddress);
          return killers_.end() != findEntry (objAddress);
        }
      
      Killers::iterator
      findEntry (const void* obj)
        {
          REQUIRE (obj);
          return std::find (killers_.begin(),killers_.end(), obj);
        }
      
      void
      triggerKill (void* objAddress)
        {
          Killers::iterator pos = findEntry (objAddress);
          if (killers_.end() != pos)
            pos->trigger();
          ENSURE (!isRegistered (objAddress), "duplicate deleter registration");
        }
    };
  
  
  
  
} // namespace lib
#endif