ui-location-solver.hpp

Go to the documentation of this file.

/*
  UI-LOCATION-SOLVER.hpp  -  decide upon a possible location for some UI component

   Copyright (C)
     2018,            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_UI_LOCATION_SOLVER_H
#define STAGE_INTERACT_UI_LOCATION_SOLVER_H

#include "lib/error.hpp"
#include "lib/symbol.hpp"
#include "lib/format-util.hpp"
#include "stage/interact/ui-coord.hpp"
#include "stage/interact/ui-coord-resolver.hpp"
#include "lib/nocopy.hpp"

#include <utility>
#include <vector>
#include <string>


namespace stage {
namespace interact {
  
  using lib::Literal;
  using std::string;
  using std::move;
  
  
  class LocationQuery;
  using LocationQueryAccess = std::function<LocationQuery&()>;
  
  
  
  
  struct LocationClause
    : util::NonCopyable
    {
      UICoord pattern;
      bool createParents;
      
      
      LocationClause (UICoord && locationPattern, bool allowCreate =false)
        : pattern{move (locationPattern)}
        , createParents{allowCreate}
        { }
      LocationClause (LocationClause && rr)
        : pattern{move (rr.pattern)}
        , createParents{rr.createParents}
        { }
      
      operator string() const;
    };
  
  
  class LocationRule
    : util::NonCopyable
    {
      using Clauses = std::vector<LocationClause>;
      
      Clauses clauses_;
      
    public:
      LocationRule (LocationClause && firstRule)
        : clauses_{}
        {
          this->append (move (firstRule));
        }
      LocationRule (LocationRule && rr)
        : clauses_{move (rr.clauses_)}
        { }
      
      
      LocationRule&&
      append (LocationClause && furtherRule)
        {
          clauses_.emplace_back (move (furtherRule));
          return move (*this);
        }
      
      
      using iterator = lib::RangeIter<Clauses::const_iterator>;
      iterator begin() const { return iterator{clauses_.begin(), clauses_.end()}; }
      iterator end()   const { return iterator(); }
      
      operator string() const;
    };
  
  
  
  
  /* ==== Support of UI-Coordinate notation within the ViewSpec-DSL ==== */
  
  inline
  UICoord::Builder::operator LocationClause()
  {
    return LocationClause{move(*this), false};
  }
  
  inline LocationClause
  UICoord::Builder::create()
  {
    return LocationClause{move(*this), true};
  }
  
  
  inline LocationRule
  operator or (UICoord::Builder && firstRule, UICoord secondRule)
  {
    return LocationRule{move (firstRule)}
            .append (move (secondRule));
  }
  
  inline LocationRule&&
  operator or (LocationRule && ruleSet, UICoord furtherRule)
  {
    ruleSet.append (move (furtherRule));
    return move(ruleSet);
  }
  
  
  
  /* === diagnostics === */
  
  inline
  LocationClause::operator string()  const
  {
    return string{pattern}
         + (createParents? " create!":"");
  }
  inline
  LocationRule::operator string()  const
  {
    return "=~\t.. "
         + util::join(clauses_, "\n\tOR ");
  }
  
  
  
  
  class UILocationSolver
    : util::NonCopyable
    {
      LocationQueryAccess getLocationQuery;
      
    public:
      explicit
      UILocationSolver (LocationQueryAccess accessor)
        : getLocationQuery{accessor}
        { }
      
      explicit
      UILocationSolver (LocationQuery& locationQueryService)
        : getLocationQuery{[&]() -> LocationQuery& { return locationQueryService; }}
        { }
      
      
      UICoord
      solve (LocationRule const& rule, size_t depth, Literal elementTypeID)
        {
          for (auto& clause : rule)
            {
              // Clauses which do not at least describe an element at parent level
              // will never lead to a solution and can thus be skipped
              if (depth+1 < clause.pattern.size()
                  or depth > clause.pattern.size())
                continue;
              
              // try to solve the current Clause by matching against real UI topology
              UICoordResolver resolver{clause.pattern, getLocationQuery()};
              preprocess (resolver, clause);
              resolver.coverPartially(); // now either holds a solution or is empty
              
              if (not isnil(resolver)                     // Solution found!
                  and (clause.createParents              //  The "create" case requires only some part to exist,
                       or resolver.isCoveredTotally())) //   while in the default case we demand complete coverage
                {
                  if (depth == clause.pattern.size())
                    // append ID of the new element to be created
                    // unless it's already there (and thus exists)
                    resolver.append (elementTypeID);
                  return move (resolver);
                      // use the first suitable solution and exit
                }
              else
                if (clause.createParents and clause.pattern.isExplicit())
                  // allow creation of a totally new path from scratch
                  // as long as it is complete and explicitly given
                  {
                    if (depth == clause.pattern.size())
                      return clause.pattern.append (elementTypeID);
                    else
                      return clause.pattern;
                  }
            }
           //all clauses tried without success...
          return UICoord();
        }
      
    private:
      void
      preprocess (UICoordResolver& builder, LocationClause const& clause)
        {
          if (clause.createParents
              and clause.pattern.isComplete())
            {
              builder.existentiallyQuantify (UIC_PERSP);
            }
        }
    };
  
  
  
  
}}// namespace stage::interact
#endif /*STAGE_INTERACT_UI_LOCATION_SOLVER_H*/