advice.cpp

Go to the documentation of this file.

/*
  Advice  -  generic loosely coupled interaction guided by symbolic pattern
 
   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.
 
* *****************************************************************/
 
 
#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/del-stash.hpp"
#include "lib/depend.hpp"
#include "lib/symbol.hpp"
#include "lib/sync.hpp"
#include "lib/util.hpp"
#include "include/logging.h"
#include "common/advice.hpp"
#include "common/advice/index.hpp"
 
 
using lib::Literal;
using lib::DelStash;
using util::unConst;
 
typedef void (DeleterFunc)(void*);
 
 
namespace lumiera{
namespace advice {
  
  namespace { // ======= implementation of the AdviceSystem ============
    
    class AdviceSystem
      : public lib::Sync<>
      , util::NonCopyable
      {
        
        DelStash adviceDataRegistry_;
        Index<PointOfAdvice> index_;
        
      public:
        AdviceSystem()
          : index_()
          {
            TRACE (library, "Initialising Advice Index tables.");
          }
        
       ~AdviceSystem()
          {
            TRACE (library, "Shutting down Advice system.");
          }
        
        
        
        /* == Advice data storage management == */
        
        void*
        allocateBuffer(size_t siz)
          {
            try { return new char[siz]; } 
            
            catch(std::bad_alloc&)
              {
                throw error::Fatal("Unable to store Advice due to memory exhaustion");
              }
            ERROR_LOG_AND_IGNORE (memory, "Storing a piece of Advice")
            throw error::Fatal("Unable to store Advice data");
          }
        
        void
        releaseBuffer (void* buff, size_t)                                   
          {
            delete[] (char*)buff;
          }
        
        void
        manageAdviceData (PointOfAdvice* entry, DeleterFunc* how_to_delete)
          {
            Lock sync{this};
            adviceDataRegistry_.manage (entry, how_to_delete);
          }
        
      private:
        void
        discardEntry (PointOfAdvice* storedProvision)  
          {
            if (storedProvision)
              {
                adviceDataRegistry_.kill (storedProvision);
          }   }
        
        
        
      public:
        /* == forward additions and retractions to the index == */
        
        void
        publishRequestBindingChange(PointOfAdvice & req,
                                    HashVal previous_bindingKey)
          {
            Lock sync{this};
            index_.modifyRequest(previous_bindingKey, req);
          }
        
        void
        registerRequest(PointOfAdvice & req)
          {
            Lock sync{this};
            index_.addRequest (req);
          }
        
        void
        deregisterRequest(PointOfAdvice const& req)
          {
            try
              {
                Lock sync{this};
                index_.removeRequest (req);
              }
            
            catch(...)
              {
                Literal errID = lumiera_error();
                WARN (library, "Problems on deregistration of advice request: %s", errID.c());
              }
          }
        
        
        void
        publishProvision (PointOfAdvice* newProvision, const PointOfAdvice* previousProvision)
          {
            Lock sync{this};
            
            if (not previousProvision and newProvision)
              index_.addProvision (*newProvision);
            else
            if (previousProvision and newProvision)
              index_.modifyProvision (*previousProvision, *newProvision);
            else
            if (previousProvision and not newProvision)
              index_.removeProvision (*previousProvision);
            
            discardEntry (unConst(previousProvision));
          }
        
        void
        discardSolutions (const PointOfAdvice* existingProvision)
          {
            Lock sync{this};
            
            if (existingProvision)
              index_.removeProvision (*existingProvision);
            
            discardEntry (unConst(existingProvision));
          }
      };
    
    
    lib::Depend<AdviceSystem> aSys;
    
    
  } //(End) AdviceSystem implementation
  
  
  
  
  
  
  /*  ====== AdviceLink : access point for Provisions and Requests ====== */
  
  
  void*
  AdviceLink::getBuffer(size_t siz)
  {
    return aSys().allocateBuffer(siz);
  }
  
  
  void
  AdviceLink::releaseBuffer (void* buff, size_t siz)
  {
    aSys().releaseBuffer(buff, siz);
  }
  
  
  void
  AdviceLink::manageAdviceData (PointOfAdvice* entry, DeleterFunc* how_to_delete)
  {
    aSys().manageAdviceData (entry,how_to_delete);
  }
  
  
  
  
  void
  AdviceLink::publishProvision (PointOfAdvice* newProvision)
  {
    const PointOfAdvice* previousProvision (getSolution());
    this->setSolution (newProvision);
    
    aSys().publishProvision (newProvision, previousProvision);
  }
  
  
  void
  AdviceLink::discardSolutions ()
  {
    const PointOfAdvice* existingProvision (getSolution());
    this->setSolution ( NULL );
    aSys().discardSolutions (existingProvision);
  }
  
  
  void
  AdviceLink::publishRequestBindingChange(HashVal previous_bindingKey)
  {
    aSys().publishRequestBindingChange (*this, previous_bindingKey);
  }
  
  
  void
  AdviceLink::registerRequest()
  {
    aSys().registerRequest (*this);
  }
  
  
  void
  AdviceLink::deregisterRequest()
  {
    aSys().deregisterRequest (*this);
  }
  
  
  
  
  
}} // namespace lib::advice