ui-coord-resolver.hpp

Go to the documentation of this file.

/*
  UI-COORD-RESOLVER.hpp  -  resolve UI coordinate spec against actual window topology

  Copyright (C)         Lumiera.org
    2017,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef STAGE_INTERACT_UI_COORD_RESOLVER_H
#define STAGE_INTERACT_UI_COORD_RESOLVER_H

#include "lib/error.hpp"
#include "lib/symbol.hpp"
#include "lib/format-string.hpp"
#include "stage/interact/ui-coord.hpp"
#include "lib/iter-explorer.hpp"
#include "lib/iter-source.hpp"
#include "lib/depend.hpp"
#include "lib/util.hpp"

#include <utility>
#include <memory>


namespace stage {
namespace interact {
  
  namespace error = lumiera::error;
  
  using std::unique_ptr;
  using util::unConst;
  using lib::Literal;
  using lib::Symbol;
  
  
  
  
  class TreeStructureNavigator
    : public lib::IterSource<Literal>
    {
    public:
      virtual ~TreeStructureNavigator();     
      
      virtual TreeStructureNavigator* expandChildren()  const   =0;
      
      
      static auto
      buildIterator (TreeStructureNavigator* source)
        {
          return lib::explore (source)
                        .expand([](TreeStructureNavigator& parent){ return parent.expandChildren(); });
        }
    };
  
  
  
  
  
  class LocationQuery
    {
    public:
      virtual ~LocationQuery();    
      
      static lib::Depend<LocationQuery> service;
      
      
      using ChildIter = decltype (TreeStructureNavigator::buildIterator(0));


      virtual Literal determineAnchor (UICoord const& path)           =0;


      virtual size_t determineCoverage (UICoord const& path)          =0;

      virtual ChildIter getChildren (UICoord const& path, size_t pos) =0;
    };
  
  
  
  
  
  
  class UICoordResolver
    : public UICoord::Builder
    {

      struct Resolution
        {
          const char* anchor = nullptr;
          size_t depth       = 0;
          unique_ptr<UICoord> covfefe{};
          bool isResolved    = false;
        };
      
      LocationQuery& query_;
      Resolution res_;
      
    public:
      UICoordResolver (UICoord const& uic, LocationQuery& queryAPI)
        : Builder{uic}
        , query_{queryAPI}
        , res_{}
        {
          attempt_trivialResolution();
        }
      
      UICoordResolver (UICoord && uic, LocationQuery& queryAPI)
        : Builder{std::move(uic)}
        , query_{queryAPI}
        , res_{}
        {
          attempt_trivialResolution();
        }
      
      
      /* === query functions === */
      
      bool
      isAnchored()  const
        {
          return res_.anchor
             and res_.anchor != Symbol::BOTTOM;
        }

      bool
      canAnchor()  const
        {
          return isAnchored()
              or (res_.isResolved and res_.covfefe)
              or unConst(this)->pathResolution()
              or isAnchored(); // resolution failed, but computed at least an anchor
        }

      bool
      isCoveredPartially()  const
        {
          return res_.isResolved
             and res_.depth > 0;
        }
      
      bool
      isCovered()  const
        {
          return res_.isResolved
             and res_.depth == this->uic_.size();
        }
      
      bool
      isCoveredTotally()  const
        {
          return isCovered();
        }
      
      
      bool
      canCover()  const
        {
          return isCovered()                          // either explicit coverage known
              or (res_.isResolved and res_.covfefe)   // or previous matching run found (partial) solution
              or unConst(this)->pathResolution()      // perform matching run now to find total coverage
              or (res_.covfefe);                      // or at least partial coverage was found
        }
      
      
      
      /* === mutation functions === */
      
      UICoordResolver&&
      cover()
        {
          if (isCoveredPartially() and not res_.covfefe)
            {
              ASSERT (res_.anchor);    // depth > 0 implies anchorage
              window (res_.anchor);   //  thus make this anchor explicit
              truncateTo (res_.depth);
            }
          else if (canCover())
            {
              ASSERT (res_.isResolved);
              REQUIRE (res_.covfefe);
              res_.depth = res_.covfefe->size();
              this->uic_ = std::move (*res_.covfefe);
              res_.covfefe.reset();
            }
          else
            {
              ASSERT (res_.isResolved);
              REQUIRE (res_.depth == 0);
              REQUIRE (not res_.covfefe);
              truncateTo (0);
            }
          ENSURE (isCovered());
          return std::move (*this);
        }
      
      
      UICoordResolver&&
      coverPartially()
        {
          if (isCoveredPartially() and not res_.covfefe)
            {
              ASSERT (res_.anchor);
              window (res_.anchor); // just ensure the anchor info is explicit,
            }                      //  the rest is already in place and explicit
          else if (canCover())
            {
              ASSERT (res_.isResolved);
              REQUIRE (res_.covfefe);
              REQUIRE (uic_.size() >= res_.covfefe->size());
              res_.depth = res_.covfefe->size();
              // possibly overwrite placeholders by explicitly resolved info...
              for (size_t pos = 0; pos < res_.depth; ++pos )
                overwrite (pos, (*res_.covfefe)[pos]);
              res_.covfefe.reset();
            }
          else
            {
              ASSERT (res_.isResolved);
              REQUIRE (res_.depth == 0);
              REQUIRE (not res_.covfefe);
              truncateTo (0);
            }
          ENSURE (empty() or (isCoveredPartially() and uic_.isExplicit()));
          return std::move (*this);                 // no wildcards remain
        }
      
      
      UICoordResolver&&
      anchor()
        {
          if (canAnchor())
            {
              window (res_.anchor);
              normalise();
            }
          return std::move (*this);
        }
      
      
      
      UICoordResolver&&
      extend (Literal pathExtension)
        {
          if (not isCovered())
            cover();
          ENSURE (isCovered());
          append (pathExtension);
          res_.depth = query_.determineCoverage (this->uic_); // coverage may grow
          return std::move (*this);
        }
      
      UICoordResolver&&
      extend (UICoord const& partialExtensionSpec)
        {
          if (not canCover())
            uic_ = partialExtensionSpec;
          else
            {
              REQUIRE (res_.isResolved);
              size_t coverable = res_.covfefe? res_.covfefe->size() : res_.depth;
              auto newContent = partialExtensionSpec.begin();
              size_t extensionPos = newContent? partialExtensionSpec.indexOf(*newContent) : coverable;
              if (coverable > extensionPos)
                throw error::Invalid (util::_Fmt{"Attempt to extend covered path %s with %s "
                                                 "would overwrite positions %d to %d (incl)"}
                                                % (res_.covfefe? *res_.covfefe : UICoord{uic_.rebuild().truncateTo(res_.depth)})
                                                % partialExtensionSpec
                                                % extensionPos
                                                % (coverable-1));
              cover();
              for ( ; newContent; ++newContent, ++extensionPos )
                overwrite (extensionPos, *newContent);
              normalise();
            }
          res_ = Resolution{};      // start over with pristine resolution state
          attempt_trivialResolution();
          canCover();
          return std::move (*this);
        }
      
      
      UICoordResolver&&
      existentiallyQuantify (size_t pos)
        {
          if (pos < uic_.size() and not uic_.isPresent(pos))
            overwrite (pos, UIC_ELIDED);
          return std::move (*this);
        }
      
      
      
      operator string()   const { return string(this->uic_); }
      size_t coverDepth() const { return res_.depth; }
      
      
      
    private:
      void
      attempt_trivialResolution()
        {
          res_.anchor = query_.determineAnchor  (this->uic_);
          if (not uic_.isExplicit()) return;
          res_.depth  = query_.determineCoverage(this->uic_);
          if (util::contains (this->uic_, UIC_ELIDED)) return;  // existentially quantified
          res_.isResolved = true;
        }

      bool pathResolution();
    };
  
  
  
}}// namespace stage::interact
#endif /*STAGE_INTERACT_UI_COORD_RESOLVER_H*/