output-mapping.hpp

Go to the documentation of this file.

/*
  OUTPUT-MAPPING.hpp  -  generic interface for translation of output designations

   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 STEAM_MOBJECT_OUTPUT_MAPPING_H
#define STEAM_MOBJECT_OUTPUT_MAPPING_H

#include "lib/error.hpp"
#include "lib/util.hpp"
#include "lib/hash-value.h"
#include "steam/asset/pipe.hpp"
#include "common/query.hpp"

#include <boost/operators.hpp>
#include <map>



namespace steam {
namespace mobject {
  
  namespace { // Helper to extract and rebind definition types
    
    template<class DEF>
    class _def
      {
        typedef asset::ID<asset::Pipe> PId;
        
        template<typename FUN>
        struct Rebind;
        
        template<typename RET>
        struct Rebind<RET(DEF::*)(PId)>
          {
            typedef RET Res;
          };
        
        using OutputMappingMemberFunc = decltype(&DEF::output) ;
        using Rebinder = Rebind<OutputMappingMemberFunc>;
        
      public:
        using Target = typename Rebinder::Res;
        
      };
  }//(End) type rebinding helper
  
  namespace error = lumiera::error;
  using lumiera::Query;
  using lib::HashVal;
  
  
  
  
  template<class DEF>
  class OutputMapping
    : public DEF
    {
      typedef _def<DEF> Setup;
      
      using PId   = asset::ID<asset::Pipe>;
      using PPipe = asset::PPipe;
      
      /* == mapping table storage == */
      std::map<HashVal,HashVal> table_;
      
    public:
      using Target = typename Setup::Target;
      
      // using default ctor and copy operations
      
      size_t size() const { return table_.size(); }
      bool empty()  const { return 0 == size(); }
      void clear()        { table_.clear(); }
      
      
      class Resolver
        : public boost::equality_comparable<Resolver, Target   //  final mapping result can be compared to Target...
        , boost::equality_comparable<Resolver>>               //   mapping values can be compared.
        {
          OutputMapping& thisMapping_;
          HashVal& pID_;
          
          Resolver (OutputMapping& container, HashVal& resultVal)
            : thisMapping_(container)
            , pID_(resultVal)
            { }
          
          friend class OutputMapping;
          
          /* copy by clients prohibited */
          Resolver& operator= (Resolver const&);
          
          
          Target
          resolve()  const
            {
              REQUIRE (pID_);
              PId targetPipeID (pID_);
              return thisMapping_.resolveTarget (targetPipeID);
            }
          
        public:
          void
          operator= (PId newId2map)
            {
              pID_ = newId2map;
            }
          
          void
          operator= (PPipe newPipe2map)
            {
              REQUIRE (newPipe2map);
              pID_ = newPipe2map->getID();
            }
          
          void
          disconnect() 
            {
              pID_ = 0;
            }
          
          operator Target()
            {
              if (not isValid())
                throw error::Logic{"attempt to resolve an unconnected output mapping"
                                  , LERR_(UNCONNECTED)};
              return resolve();
            }
          
          bool
          isValid()  const    
            {
              return bool(pID_);
            }
          
          explicit
          operator bool()  const
            {
              return isValid();
            }
          
          
          /* === equality comparisons (boost::operators) === */
          
          friend bool
          operator== (Resolver const& a, Resolver const& b)
          {
            return a.pID_ == b.pID_;
          }                 // note: Resolver depends on template parameter DEF
                           //        All instances of DEF are considered equivalent!
          friend bool
          operator== (Resolver const& rr, Target const& tval)
          {
            return rr.resolve() == tval;
          }
        };
      
      
      
      /* === Map-style access for clients === */
      
      Resolver operator[] (PId sourcePipeID);
      Resolver operator[] (PPipe const& pipe);
      Resolver operator[] (Query<asset::Pipe> query4pipe);
      
      bool
      contains (PId mapping4sourcePipeID)
        {
          return util::contains (table_, mapping4sourcePipeID);
        }
      
      bool
      contains (PPipe sourcePipe)
        {
          return !sourcePipe
              or this->contains (sourcePipe->getID());
        }
      
      
      
    private:
      Target
      resolveTarget (PId mappedPipeID)
        {
          return DEF::output (mappedPipeID);
        }
      
      Resolver
      buildResolutionWrapper (HashVal tableSlot)
        {
          ASSERT (this->contains (tableSlot));
          return Resolver (*this, table_[tableSlot]);
        }
    };
  
  
  
  
  /* ===== Implementation details ===== */
  
  namespace _mapping {
    
    HashVal slot (Query<asset::Pipe> const&);
    
    HashVal resolveQuery (Query<asset::Pipe> const&);
    
    uint is_defaults_query_with_channel (Query<asset::Pipe> const&);
    
    Query<asset::Pipe> build_corresponding_sourceQuery (Query<asset::Pipe> const&);
  }
  
  
  template<class DEF>
  inline typename OutputMapping<DEF>::Resolver
  OutputMapping<DEF>::operator[] (PId sourcePipeID)
  {
    if (not contains (sourcePipeID))
      {
        // issue a defaults query to resolve this mapping first
        Query<asset::Pipe> query4pipe = DEF::buildQuery (sourcePipeID);
        table_[sourcePipeID] = _mapping::resolveQuery (query4pipe);
      }
    return buildResolutionWrapper (sourcePipeID);
  }
  
  
  template<class DEF>
  inline typename OutputMapping<DEF>::Resolver
  OutputMapping<DEF>::operator[] (PPipe const& pipe)
  {
    REQUIRE (pipe);
    return (*this) [pipe->getID()];
  }
  
  
  template<class DEF>
  inline typename OutputMapping<DEF>::Resolver
  OutputMapping<DEF>::operator[] (Query<asset::Pipe> query4pipe)
  {
    HashVal hash4query = _mapping::slot (query4pipe);
    if (not contains (hash4query))
      {
        // need to resolve this query first
        auto addEntry = [&](auto query)
                          {
                            table_[hash4query] = _mapping::resolveQuery (query);
                          };
        
        if (uint seqNr = _mapping::is_defaults_query_with_channel (query4pipe))
          {
            // treat the special case
            // when actually requesting the "Nth default of this kind"
            PPipe corresponding_sourcePipe
              = asset::Struct::retrieve (
                  _mapping::build_corresponding_sourceQuery (query4pipe));
            ENSURE (corresponding_sourcePipe);
            
            PId sourcePipeID = corresponding_sourcePipe->getID();
            addEntry (DEF::buildQuery (sourcePipeID, seqNr));
          }
        else
          addEntry (query4pipe);
      }
    
    ENSURE (this->contains (hash4query));
    return buildResolutionWrapper (hash4query);
  }
  
  
}} // namespace steam::mobject
#endif