gen-node-location-query.hpp

Go to the documentation of this file.

/*
  GEN-NODE-LOCATION-QUERY.hpp  -  pose UI-coordinate location queries against a GenNode structure

   Copyright (C)
     2017,            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 STAGE_INTERACT_GEN_NODE_LOCATION_QUERY_H
#define STAGE_INTERACT_GEN_NODE_LOCATION_QUERY_H

#include "lib/error.hpp"
#include "lib/symbol.hpp"
#include "stage/interact/ui-coord-resolver.hpp"
#include "lib/diff/gen-node.hpp"
#include "lib/format-string.hpp"
#include "lib/iter-explorer.hpp"
#include "lib/iter-source.hpp"
#include "lib/itertools.hpp"
#include "lib/util.hpp"

#include <utility>
#include <string>


namespace stage {
namespace interact {
  
  namespace error = lumiera::error;
  
  using lib::Symbol;
  using lib::Literal;
  using lib::diff::Rec;
  using util::isnil;
  using util::_Fmt;
  using std::forward;
  using std::string;
  

  
  
  class GenNodeLocationQuery
    : public LocationQuery
    {
      Rec tree_;
      
    public:
      template<class REC>
      GenNodeLocationQuery(REC&& backingStructure)
        : tree_(std::forward<REC>(backingStructure))
        { }
      
      
      /* === LocationQuery interface === */
      
      virtual Literal
      determineAnchor (UICoord const& path)  override
        {
          if (isnil(tree_) or not path.isPresent(UIC_WINDOW))
            return Symbol::BOTTOM;
          if (UIC_FIRST_WINDOW == path.getWindow())
            return getFirstWindow();
          if (UIC_CURRENT_WINDOW == path.getWindow())
            return getCurrentWindow();
          if (not tree_.hasAttribute(string{path.getWindow()}))         
            return Symbol::BOTTOM;
          return path.getWindow();
        }


      virtual size_t
      determineCoverage (UICoord const& path)  override
        {
          size_t depth = 0;
          drillDown (tree_, path, path.size(), depth);
          return depth;
        }

      virtual ChildIter
      getChildren (UICoord const& path, size_t pos)  override
        {
          size_t depth = 0;
          Rec const& node = drillDown (tree_, path, pos, depth);
          if (depth != pos)
            throw error::State(_Fmt{"unable to drill down to depth %d: "
                                    "element %s at pos %d in path %s is in "
                                    "contradiction to actual UI structure"}
                                   % pos
                                   % (depth<path.size()? path[depth] : Symbol::BOTTOM)
                                   % depth
                                   % path
                              );
          return TreeStructureNavigator::buildIterator(
                   childNavigator (node, depth));
        }
      
    private:
      Literal
      getFirstWindow()
        {
          return Symbol{*tree_.keys()};                        
        }
      Literal
      getCurrentWindow()
        {
          return Symbol{lib::pull_last (tree_.keys())};        
        }            // special convention for unit-tests
      
      Literal
      resolveElm (UICoord const& path, size_t depth)
        {
          REQUIRE (path.isPresent(depth));
          return depth==UIC_WINDOW? GenNodeLocationQuery::determineAnchor(path)
                                  : path[depth];
        }
      
      
      Rec const&
      drillDown (Rec const& tree, UICoord const& path, size_t maxDepth, size_t& depth)
        {
          if (depth<maxDepth and path.isPresent(depth))
            {
              const char* pathElm = resolveElm (path, depth);
              if (hasNode (tree, pathElm, depth))
                {
                  ++depth;
                  return drillDown (descendInto(tree,depth-1,pathElm), path, maxDepth, depth);
                }
            }
          return tree;
        }
      
      static bool
      hasNode (Rec const& tree, const char* pathElm, size_t depth)
        {
          return depth==UIC_PERSP? pathElm == tree.getType()
                                 : tree.hasAttribute(pathElm);
        }
      
      static Rec const&
      descendInto (Rec const& tree, size_t depth, const char* pathElm)
        {
          return depth==UIC_PERSP? tree // perspective info is attached as type at the parent node
                                 : tree.get(pathElm).data.get<Rec>();
        }
      
      
      
      
      /* ==== iterate over siblings with the ability to expand one node's children ==== */
      
      static TreeStructureNavigator*
      childNavigator (Rec const& node, size_t depth)
        {
          auto internedString = [](string const& id) -> Literal
                                  {
                                    return Symbol{id};
                                  };
          return depth==UIC_PERSP? buildNavigator (node, depth, singleValIterator (internedString (node.getType())))
                                 : buildNavigator (node, depth, transformIterator (node.keys(), internedString));
        }
      
      
      template<class PAR>
      class GenNodeNavigator
        : public PAR
        {
          Rec const& pos_;
          size_t depth_;
          
          virtual TreeStructureNavigator*
          expandChildren()  const override
            {
              return childNavigator (descendInto (pos_,depth_, currentChild_), depth_+1);
            }
          
          // The design of IterSource attempts to be too clever, and we have to pay for it now...
          // If IterSource would just work like a StateCore and expose the "current element" via API call,
          // then we'd be able to retrieve the name of the current child node. Unfortunately it doesn't
          // and thus we rig a "wire tap" here and capture the node names whenever an iteration happens.
          // 
          Literal currentChild_ = Symbol::BOTTOM;
          
          using Pos = typename PAR::Pos;
          
          virtual Pos
          firstResult ()  override
            {
              Pos pos = PAR::firstResult();
              if (pos) currentChild_ = *pos;
              return pos;
            }
          
          virtual void
          nextResult(Pos& pos)  override
            {
              PAR::nextResult (pos);
              if (pos) currentChild_ = *pos;
            }

          
        public:
          template<class IT>
          GenNodeNavigator(Rec const& node, size_t depth, IT&& rawChildIter)
            : PAR{forward<IT> (rawChildIter)}
            , pos_{node}
            , depth_{depth}
            { }
        };
      
      
      template<class IT>
      static TreeStructureNavigator*
      buildNavigator (Rec const& node, size_t depth, IT && rawIterator)
        {
          return new GenNodeNavigator<
                    lib::WrappedLumieraIter<IT,
                      TreeStructureNavigator>> {node, depth, forward<IT> (rawIterator)};
        }
    };
  
  
  
}}// namespace stage::interact
#endif /*STAGE_INTERACT_GEN_NODE_LOCATION_QUERY_H*/