element-tracker.hpp

Go to the documentation of this file.

/*
  ELEMENT-TRACKER.hpp  -  registry for tracking instances automatically

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

  **Lumiera** 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. See the file COPYING for further details.

*/


#ifndef LIB_ELEMENT_TRACKER_H
#define LIB_ELEMENT_TRACKER_H

#include "lib/p.hpp"
#include "lib/optional-ref.hpp"
#include "lib/util-foreach.hpp"
#include "lib/ref-array-impl.hpp"



namespace lib {
  
  template<typename ELM>
  class ElementTracker
    : public lib::RefArrayVector<P<ELM>>
    {
      using  _Vec = std::vector<P<ELM>>;
      using  Iter = typename _Vec::iterator;
      using CIter = typename _Vec::const_iterator;
      
    public:
     ~ElementTracker()
        {
          try { clear(); }
          catch(...) {/*ignored*/}
        }
      
      void
      clear ()
        {
          _Vec toKill;
          toKill.reserve(_Vec::size());
          toKill.swap(*this);       // prevent quadratic detach()
          ASSERT (0 == _Vec::size());
          util::for_each (toKill, unlink_it);
        }
      
      void
      append (P<ELM> const& asset)
        {
          REQUIRE (asset, "Attempt to track a NIL element");
          remove (*asset);
          this->push_back (asset);
        }
      
      void
      remove (ELM const& asset)
        {
          for (Iter i = _Vec::begin();
               i != _Vec::end() ; ++i )
            if (asset == **i)       // _Vec contains smart-ptrs
              {                    //   ELM is required to define '=='
                this->erase (i);
                return;
              }
        }
      
      bool
      isRegistered (ELM const& asset)  const
        {
          for (CIter i = _Vec::begin();
               i != _Vec::end() ; ++i )
            if (asset == **i)
              return true;
          
          return false;
        }
      
    private:
      static void
      unlink_it (P<ELM>& elm)
        {
          REQUIRE (elm);
          try { elm->detach(); }
          catch(...)
            {
              WARN (common,"problems while clearing ElementTracker, ignored.");
            }
        }
    };
  
  
  
  template<typename TAR>
  class AutoRegistered
    {
    public:
      typedef lib::ElementTracker<TAR> Registry;
      typedef lib::OptionalRef<Registry> RegistryLink;
      
      void
      detach()
        {
          if (!getRegistry) return;
          TAR& element = static_cast<TAR&> (*this);
          
          getRegistry().remove(element);
          ENSURE (!getRegistry().isRegistered(element));
        }
      
      
      typedef P<TAR> PTarget;
      
      static PTarget
      create()
        {
          REQUIRE (getRegistry);
          
          PTarget newElement (new TAR());
          getRegistry().append (newElement);
          
          ENSURE (newElement);
          ENSURE (getRegistry().isRegistered(*newElement));
          return newElement;
        }
      
      
      static void
      setRegistryInstance (Registry& registry_to_use)
        {
          getRegistry.link_to (registry_to_use);
        }
      
      static void
      deactivateRegistryLink()
        {
          getRegistry.clear();
        }
      
      static bool
      is_attached_to (Registry const& someRegistry)
        {
          return getRegistry.points_to (someRegistry);
        }
      
    protected:
      static RegistryLink getRegistry;
    };
  
  template<typename TAR>
  typename AutoRegistered<TAR>::RegistryLink  AutoRegistered<TAR>::getRegistry;
  
  
  
} // namespace lib
#endif