tree-diff-traits.hpp

Go to the documentation of this file.

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

  Copyright (C)         Lumiera.org
    2016,               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 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*/