TreeContainerTrafo.hpp

#pragma once

#include <amdis/common/RecursiveForEach.hpp>
#include <amdis/common/RecursiveMap.hpp>
#include <amdis/typetree/TreeContainer.hpp>

namespace AMDiS {
namespace Recursive {

// specializations of recursive utilities for TreeContainer entries

template <class Value>
struct Apply<TypeTree::LeafNodeStorage<Value>>
{
  template <class F, class VC>
  static auto impl(F&& f, VC const& vc)
  {
    return TypeTree::LeafNodeStorage{
      Recursive::apply(f,vc.value())};
  }
};

template <class Value, class Container>
struct Apply<TypeTree::InnerNodeStorage<Value,Container>>
{
  template <class F, class VC>
  static auto impl(F&& f, VC const& vc)
  {
    return TypeTree::InnerNodeStorage{
      Recursive::apply(f,vc.value()),
      Recursive::apply(f,vc.container())};
  }
};

template <class Container>
struct Apply<TypeTree::TreeContainerStorage<Container>>
{
  template <class F, class TC>
  static auto impl(F&& f, TC const& c)
  {
    return TypeTree::TreeContainerStorage{Recursive::apply(f,c.data())};
  }
};

// -------------------------------------------------------------------------


template <class Value>
struct ForEach<TypeTree::LeafNodeStorage<Value>>
{
  template <class VC, class F>
  static void impl(VC&& vc, F&& f)
  {
    Recursive::forEach(vc.value(),f);
  }
};

template <class Value, class Container>
struct ForEach<TypeTree::InnerNodeStorage<Value,Container>>
{
  template <class VC, class F>
  static void impl(VC&& vc, F&& f)
  {
    Recursive::forEach(vc.value(),f);
    Recursive::forEach(vc.container(),f);
  }
};

template <class Container>
struct ForEach<TypeTree::TreeContainerStorage<Container>>
{
  template <class F, class TC>
  static void impl(TC&& c, F&& f)
  {
    Recursive::forEach(c.data(),f);
  }
};

}} // end namespace AMDiS::Recursive