tree-diff-traits.hpp

Go to the documentation of this file.

/*
  TREE-DIFF-TRAITS.hpp  -  definitions to control tree mutator binding

   Copyright (C)
     2016,            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 LIB_DIFF_TREE_DIFF_TRAITS_H
#define LIB_DIFF_TREE_DIFF_TRAITS_H


#include "lib/diff/tree-mutator.hpp"
#include "lib/diff/diff-mutable.hpp"
#include "lib/null-value.hpp"
#include "lib/util.hpp"

#include <utility>
#include <stack>

namespace lib {
namespace diff{
  
  
  /* ======= Hints / Heuristics for the required TreeMutator buffer size ======= */
  
  template<class TAR, typename SEL =void>
  struct TreeMutatorSizeTraits
    {
      enum { siz = 200 };
    };
  
  
  constexpr size_t
  treeMutatorSize (...) 
  {
    return 0;
  }
  
  
  template<typename T>
  constexpr T*
  getSelector()
    {
      return static_cast<T*> (nullptr);
    }
  
  template<typename T>
  struct defines_custom_BufferSize
    {
      enum { value = 0 < treeMutatorSize (getSelector<T>()) };
    };
  
  
  template<class TAR>
  struct TreeMutatorSizeTraits<TAR,  enable_if<defines_custom_BufferSize<TAR>> >
    {
      enum { siz = treeMutatorSize (getSelector<TAR>()) };
    };

  
  
  
  /* ======= derive TreeMutator binding for a given opaque data structure ======= */
  
  
  using meta::enable_if;
  using meta::Yes_t;
  using meta::No_t;
  using std::is_base_of;
  
  template<typename T>
  class exposes_MutatorBuilder
    {
      
      META_DETECT_FUNCTION (void, buildMutator, (TreeMutator::Handle));
      
    public:
      enum{ value = HasFunSig_buildMutator<T>::value
                    and not is_base_of<DiffMutable, T>::value};
    };
  
  
  
  
  
  template<class TAR, typename SEL =void>
  struct TreeDiffTraits
    : std::false_type
    {
      static_assert (!sizeof(TAR), "TreeDiffTraits: Unable to access or build a TreeMutator for this target data.");
    };
  
  template<class TAR>
  struct TreeDiffTraits<TAR, enable_if<is_base_of<DiffMutable, TAR>>>
    : std::true_type
    {
      using Ret = DiffMutable&;
    };
  
  template<class TAR>
  struct TreeDiffTraits<TAR, enable_if<exposes_MutatorBuilder<TAR>>>
    : std::true_type
    {
      class Wrapper
        : public DiffMutable
        {
          TAR& subject_;
          
          virtual void
          buildMutator (TreeMutator::Handle handle)
            {
              subject_.buildMutator (handle);
            }
          
        public:
          Wrapper(TAR& subj)
            : subject_(subj)
            { }
        };
      
      using Ret = Wrapper;
    };
  
  
  template<class TAR>
  typename TreeDiffTraits<TAR>::Ret
  mutatorBinding (TAR& subject)
  {
     using Wrapper = typename TreeDiffTraits<TAR>::Ret;
     return Wrapper(subject);
  }
  
  
  
  
}} // namespace lib::diff
#endif /*LIB_DIFF_TREE_DIFF_TRAITS_H*/