placement-index-query-resolver.cpp

Go to the documentation of this file.

/*
  placementIndexQueryResolver  -  using PlacementIndex to resolve scope queries
 
   Copyright (C)
     2009,            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 "steam/mobject/session/placement-index-query-resolver.hpp"
#include "steam/mobject/session/scope-query.hpp"
#include "steam/mobject/placement.hpp"
#include "steam/mobject/session/clip.hpp"
#include "steam/mobject/session/effect.hpp"
 
#include "steam/mobject/test-dummy-mobject.hpp"  
 
#include <memory>
#include <stack>
 
 
namespace steam {
namespace mobject {
namespace session {
  
  using std::unique_ptr;
  
  using lumiera::Goal;
  using lumiera::Query;
  using lumiera::Resolution;
  using lumiera::getResultTypeID;
  
  
  typedef PlacementIndex::ID PID;
  typedef Goal::QueryID QueryID;
  typedef QueryID const& QID;
  
  typedef PlacementIndex& PIdx;
  typedef PlacementIndex::iterator PIter;
  
  typedef PlacementMO Pla;
  
  
  
  class Explorer
    {
    public:
      virtual ~Explorer() { };
      virtual bool exhausted ()  =0;
      virtual Pla& step ()       =0;
    };
  
  
  
  /* ==== special strategies to choose from ==== */
  
  class ChildExplorer
    : public Explorer
    {
      PIter tip_;
      
      bool
      exhausted()
        {
          return !tip_;
        }
      
      Pla&
      step ()
        {
          REQUIRE (tip_);
          Pla& pos = *tip_;
          ++tip_;
          return pos;
        }
      
    public:
      ChildExplorer(PIter start)
        : tip_(start)
        { }
    };
  
  class DeepExplorer
    : public Explorer
    {
      PIdx index_;
      std::stack<PIter> scopes_;
      
      bool
      exhausted()
        {
          while (not scopes_.empty() and not scopes_.top())
            scopes_.pop();
          return scopes_.empty();
        }
      
      Pla&
      step ()
        {
          REQUIRE (not scopes_.empty() and scopes_.top());
          Pla& pos = *scopes_.top();
          ++scopes_.top();
          scopes_.push(index_.getReferrers(pos.getID()));
          return pos;
        }
      
    public:
      DeepExplorer(PIter start, PIdx idx)
        : index_(idx)
        {
          scopes_.push(start);
        }
    };
  
  
  class UpExplorer
    : public Explorer
    {
      PIdx index_;
      Pla* tip_;
      
      bool
      exhausted()
        {
          return !tip_;
        }
      
      Pla&
      step ()
        {
          REQUIRE (tip_);
          Pla& pos = *tip_;
          tip_ = &index_.getScope(*tip_);
          if (tip_ == &pos)
            tip_ = 0;
          return pos;
        }
      
    public:
      UpExplorer(Pla& start, PIdx idx)
        : index_(idx)
        , tip_(&start)
        { }
    };
  
  
  typedef function<bool(Pla const&)> ContentFilter;
  typedef function<Explorer*()>    ExplorerBuilder;
  
  
  class ResultSet
    : public lumiera::Resolution
    {
      ContentFilter acceptable_;
      ExplorerBuilder buildExploartion_;
      unique_ptr<Explorer> explore_;
      
      
      virtual Result
      prepareResolution()
        {
          explore_.reset (buildExploartion_());
          
          Result cursor;
          exploreNext (cursor);
          return cursor;
        }
      
      virtual void
      nextResult(Result& pos)
        {
          exploreNext (pos);
        }
      
      void
      exploreNext (Result& res)
        {
          typedef Query<Pla>::Cursor Cursor;
          Cursor& cursor = static_cast<Cursor&> (res);
          
          while (!explore_->exhausted() )
            {
              Pla& elm (explore_->step());
              if (acceptable_(elm))
                {
                  cursor.point_at (elm);
                  return;
                }
            }
          
          ASSERT (explore_->exhausted());
          cursor.point_at (0);
        }
      
    public:
      ResultSet (ExplorerBuilder b
                ,ContentFilter a)
        : acceptable_(a)
        , buildExploartion_(b)
        , explore_()
        { }
    };
  
  
  
  
  namespace { // Helpers for wiring up a suitable resolutionFunction....
    
    
    bool acceptAllObjects_(Pla) { return true; }
    
    template<typename QUERY>
    ContentFilter
    getContentFilter (QUERY const& query)
    {
      return query.contentFilter();
    }
    
    ContentFilter
    getContentFilter (ScopeQuery<MObject> const&)
    {
      static ContentFilter acceptAllObjects = bind (&acceptAllObjects_, _1);
      return acceptAllObjects;
    }
    
    template<typename MO>
    QueryID
    whenQueryingFor()
      {
        QueryID qID(Goal::DISCOVERY, getResultTypeID<Placement<MO>>());
        return qID;
      }
    
    struct
    UseThisIndex
      {
        UseThisIndex (PlacementIndex& idx) : refIndex_(idx) {}
        
        PlacementIndex& refIndex_;
        PlacementIndex& operator() (void) { return refIndex_; }
      };
  } //(END) Helpers
  
  
  
  
  PlacementIndexQueryResolver::PlacementIndexQueryResolver (PlacementIndex& theIndex)
    : _getIndex(UseThisIndex (theIndex))
    {
      preGenerateInvocationContext();
    }
  
  
  PlacementIndexQueryResolver::PlacementIndexQueryResolver (function<IndexLink> const& accessIndex)
    : _getIndex(accessIndex)
    {
      preGenerateInvocationContext();
    }
  
  
  void
  PlacementIndexQueryResolver::preGenerateInvocationContext()
  {
    defineHandling<MObject>();
    defineHandling<Clip>();
    defineHandling<Effect>();
      
    defineHandling<mobject::test::DummyMO    >();
    defineHandling<mobject::test::TestSubMO1 >();
    defineHandling<mobject::test::TestSubMO2 >();
    defineHandling<mobject::test::TestSubMO21>();
  }
      
 
  bool
  PlacementIndexQueryResolver::canHandleQuery(QID qID)  const
  {
    return qID.kind == Goal::DISCOVERY
      and( qID.type == getResultTypeID<Placement<MObject>>()
        or qID.type == getResultTypeID<Placement<Clip>>()
        or qID.type == getResultTypeID<Placement<Effect>>()
         
        or qID.type == getResultTypeID<Placement<mobject::test::DummyMO    >>()
        or qID.type == getResultTypeID<Placement<mobject::test::TestSubMO1 >>()
        or qID.type == getResultTypeID<Placement<mobject::test::TestSubMO2 >>()
        or qID.type == getResultTypeID<Placement<mobject::test::TestSubMO21>>()
         );
  }
  
  
  template<typename MO>
  void
  PlacementIndexQueryResolver::defineHandling()
  {
    installResolutionCase( whenQueryingFor<MO>()
                         , bind (&PlacementIndexQueryResolver::resolutionFunction<MO>,
                                 this, _1 )
                         );
  }
  
  
  template<typename MO>
  Resolution*
  PlacementIndexQueryResolver::resolutionFunction (Goal const& goal)
  {
    QID qID = goal.getQID();
    REQUIRE (qID == whenQueryingFor<MO>());
    REQUIRE (INSTANCEOF(ScopeQuery<MO>, &goal));
    
    ScopeQuery<MO> const& query = static_cast<ScopeQuery<MO> const&> (goal);
    ScopeQueryKind direction = query.searchDirection();
    PID scopeID = query.searchScope();
    
    return new ResultSet( bind (&PlacementIndexQueryResolver::setupExploration,
                                this, scopeID, direction)
                        , getContentFilter(query)
                        );
  }
  
  
  Explorer*
  PlacementIndexQueryResolver::setupExploration (PID startID, ScopeQueryKind direction)
  {
    PIdx index = _getIndex(); // access the currently configured PlacementIndex (Session)
    switch (direction)
      {
      case CONTENTS:  return new DeepExplorer(index.getReferrers(startID), index);
      case CHILDREN:  return new ChildExplorer(index.getReferrers(startID));
      case PARENTS:   return new UpExplorer(index.getScope(startID),index);
      case PATH:      return new UpExplorer(index.find(startID),index);
      
      default:
        throw lumiera::error::Invalid("unknown query direction");    
      }
  }
  
  
  
}}} // namespace steam::mobject::session