view-spec-dsl.hpp

Go to the documentation of this file.

/*
  VIEW-SPEC-DSL.hpp  -  configuration of view allocation patterns
 
   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_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::PApply;
          
          using Ret         = _Fun<FUN>::Ret;
          using Args        = _Fun<FUN>::Args;
          using Arg1        = Split<Args>::Head;
          using FurtherArgs = Split<Args>::Tail;
          
          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*/