view-spec-dsl.hpp

Go to the documentation of this file.

/*
  VIEW-SPEC-DSL.hpp  -  configuration of view allocation patterns

  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_VIEW_SPEC_DSL_H
#define STAGE_INTERACT_VIEW_SPEC_DSL_H

#include "lib/error.hpp"
#include "lib/symbol.hpp"
#include "lib/depend.hpp"
#include "lib/meta/function.hpp"
#include "lib/meta/tuple-helper.hpp"
#include "lib/meta/function-closure.hpp"
#include "stage/interact/ui-location-solver.hpp"
#include "stage/interact/ui-coord.hpp"

#include <functional>
#include <utility>
#include <string>


namespace stage {
namespace interact {
  
  using std::forward;
  using std::string;
  
  
  
  using Locator = std::function<UICoord(Literal)>;
  
  
  template<size_t depth>
  class LocatorSpec
    : public Locator
    {
      LocationRule rules_;
      
    public:
      LocatorSpec(LocationRule && ruleToDetermineLocation)
        : Locator([&](Literal componentID) -> UICoord
                    {
                      lib::Depend<UILocationSolver> locationSolver;
                      return locationSolver().solve (rules_, depth, componentID);
                    })
        , rules_{move (ruleToDetermineLocation)}
        { }
      
      LocatorSpec(UICoord::Builder&& simpleLocationSpec)
        : LocatorSpec{
            LocationRule{
              LocationClause{
                UICoord{std::move (simpleLocationSpec)}}}}
        { }
      
      operator string()  const
        {
          return string{rules_};
        }
    };
  
  using ViewSpec = LocatorSpec<UIC_VIEW>;
  
  
  using Allocator = std::function<UICoord(UICoord)>;
  
  
  template<typename... ARGS>
  class AllocSpec
    : public std::function<Allocator(ARGS&&...)>
    {
      template<class FUN>
      static auto
      buildPartialApplicator (FUN&& fun)
        {
          using lib::meta::_Fun;
          using lib::meta::Split;
          using lib::meta::Tuple;
          using lib::meta::Types;
          using lib::meta::func::_Sig;
          using lib::meta::func::PApply;
          
          typedef typename _Fun<FUN>::Ret Ret;
          typedef typename _Fun<FUN>::Args Args;
          typedef typename Split<Args>::Head Arg1;
          typedef typename Split<Args>::Tail FurtherArgs;
          
          static_assert (std::is_convertible<UICoord, Arg1>::value,
                         "Allocator function must accept UICoordinates (where to create/locate) as first argument");
          static_assert (std::is_convertible<Ret, UICoord>::value,
                         "Allocator function must produce UICoordinates (of the actually allocated UI element)");
          static_assert (std::is_convertible<FurtherArgs, Types<ARGS...>>::value,
                         "Additional parameters of the allocator function must match the AllocSpec<ARGS> template parameters");
          
          
          using ArgTuple = Tuple<FurtherArgs>;
          
          return [=](auto&&... args) -> Allocator
                    {
                      ArgTuple params {forward<decltype(args)> (args)...};
                      return PApply<FUN,FurtherArgs>::bindBack (fun, params);
                    };
        }
      
      
    public:
      template<class FUN>
      AllocSpec(FUN&& fun)
        : std::function<Allocator(ARGS&&...)> {buildPartialApplicator (forward<FUN> (fun))}
        { }
    };
  
  
} // namespace interact
namespace idi {
//bring definitions into scope for DSL use...
  using interact::ViewSpec;
  using interact::Allocator;
  
  using interact::AllocSpec;
  
  extern AllocSpec<uint> limitAllocation;
  
  
  template<class V>
  struct Descriptor
    {
      static_assert (not sizeof(V), "unknown generic view type");
    };
   // for the actual specialisations: see id-scheme.hpp
  
  
  template<class VIEW>
  inline Descriptor<VIEW>&
  viewSpec()
  {
    static Descriptor<VIEW> dslInstance;
    return dslInstance;
  }
  
  
}}// namespace stage::idi
#endif /*STAGE_INTERACT_VIEW_SPEC_DSL_H*/