defs-registry.hpp

Go to the documentation of this file.

/*
  DEFS-REGISTRY.hpp  -  implementation of the default object store
 
   Copyright (C)
     2008,            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 LUMIERA_QUERY_DEFS_REGISTRY_H
#define LUMIERA_QUERY_DEFS_REGISTRY_H
 
 
#include "lib/p.hpp"
#include "lib/util.hpp"
#include "lib/util-foreach.hpp"
#include "lib/sync-classlock.hpp"
#include "lib/format-string.hpp"
#include "lib/query-util.hpp"
#include "common/query.hpp"
#include "lib/nocopy.hpp"
 
#include <set>
#include <vector>
#include <memory>
 
 
namespace lumiera{
namespace query  {
  
  using lib::P;
  using lib::ClassLock;
  using std::weak_ptr;
  using std::string;
  
  namespace impl {
    
    namespace {
      using util::_Fmt;
      
      uint maxSlots (0); 
      _Fmt dumpRecord ("%2i| %64s --> %s\n");
    }
    
    
    struct TableEntry
      {
        virtual ~TableEntry() {};
      };
    
    using Table = std::vector< P<TableEntry> >;
    
    
    template<class TAR>
    struct Record
      {
        QueryKey queryKey;
        weak_ptr<TAR> objRef;
        uint degree;
        
        Record (Query<TAR> const& q, P<TAR> const& obj)
          : queryKey (q)
          , objRef (obj)
          , degree(queryKey.degree())
          { }
        
        
        struct Search  
          {
            Search (P<TAR> const& obj)
              : obj_(obj) { }
            
            P<TAR> const& obj_;
            
            bool
            operator() (Record const& rec)
            {
              P<TAR> storedObj (rec.objRef.lock());
              return storedObj and (storedObj == obj_);
            }
          };
        
        friend bool
        operator< (Record one, Record two) 
        {
          return one.queryKey < two.queryKey;
        }
        
        operator string ()  const { return dumpRecord % degree % queryKey.display() % dumpObj(); }
        string  dumpObj ()  const { P<TAR> o (objRef.lock()); return o? string(*o):"dead"; }
      };
      
    template<class TAR>
    struct Slot
      : public TableEntry
      {
        using Registry = std::set<Record<TAR>>;
        
        Registry registry;
        static size_t index; 
        
        static Registry&
        access (Table& table)
          {
            if (  not index
               or     index > table.size()
               or not table[index-1])
              createSlot (table);
            
            ASSERT (0 < index and index<=table.size() and table[index-1]);
            Slot* item = static_cast<Slot*> (table[index-1].get());
            return item->registry;
          }
        
      private:
        static void
        createSlot (Table& table)
          {
            ClassLock<TableEntry> guard;
            if (!index)
              index = ++maxSlots;
            if (index > table.size())
              table.resize (index);
            table[index-1].reset(new Slot);
          }
      };
      
      
    // static vars to organise one Table Slot per type....
    template<class TAR>
    size_t Slot<TAR>::index (0);
    
    
    
    
    class DefsRegistry
      : util::NonCopyable
      {
        Table table_;
        
      public:
        template<class TAR>
        class Iter
          {
            friend class DefsRegistry;
            using II = Slot<TAR>::Registry::iterator;
            
            II p,i,e;
            P<TAR> next, ptr;
            
            Iter (II from, II to) 
              : p(from), i(from), e(to)
              {
                if (i!=e) ++i;  // p is next to be tested, i always one ahead
                operator++ ();
              }
            
            Iter (II match, II from, II to) 
              : p(match), i(from), e(to)
              {
                operator++ ();  // init to first element (or to null if empty)
              }
            
            P<TAR>
            findNext ()  
              {
                while (!next)
                  {
                    if (p==e) break;
                    next = p->objRef.lock();
                    p = i++;
                  }
                return next;
              }
            
          
          public:
            P<TAR> operator* ()    { return ptr; }
            bool  hasNext ()       { return next or findNext(); }
            Iter& operator++ ()
              {
                ptr=findNext();
                next.reset();
                return *this;
              }
          };
        
        template<class TAR>
        Iter<TAR>
        candidates (Query<TAR> const& query)
          {
            P<TAR> dummy;
            Record<TAR> entry (query, dummy);
            using Registry = Slot<TAR>::Registry;
            Registry& registry = Slot<TAR>::access(table_);
            
            // try to get a possible direct match (same query)
            auto pos = registry.find (entry);
            auto end = registry.end();
            
            if (pos==end)
              return Iter<TAR> (registry.begin(), end);        // just enumerate contents
            else
              return Iter<TAR> (pos, registry.begin(), end); // start with direct match
          }
        
        
        template<class TAR>
        bool
        put (P<TAR> const& obj, Query<TAR> const& query)
          {
            Record<TAR> entry (query, obj);
            using Registry = Slot<TAR>::Registry;
            using RIter    = Registry::iterator;
            
            Registry& registry = Slot<TAR>::access(table_);
            RIter pos = registry.lower_bound (entry);
            if (pos!=registry.end() and
                pos->queryKey == query)
              {
                P<TAR> storedObj (pos->objRef.lock());
                if (storedObj)
                  return (storedObj == obj);
                else
                  // use the opportunity to purge the expired entry
                  registry.erase(pos++);
              }
            // no existing entry....
            registry.insert(pos, entry);
            ENSURE (registry.find (entry) != registry.end());
            return true;
          }
        
        
        template<class TAR>
        bool
        forget (P<TAR> const& obj)
          {
            using Registry = Slot<TAR>::Registry;
            using SearchFunc = Record<TAR>::Search;
            
            Registry& registry = Slot<TAR>::access(table_);
            return util::remove_if(registry, SearchFunc (obj));
          }
        
        
        template<class TAR>
        string
        dump ()
          {
            string res;
            util::for_each ( Slot<TAR>::access(table_)
                           , [&] (Record<TAR>& entry)
                                 {
                                   res += string(entry);
                                 }
                           );
            return res;
          }
      };
    
    
    
  } // (End) impl namespace
  
  using impl::DefsRegistry;
  
  
}} // namespace lumiera::query
#endif