TreeContainerTrafo.hpp 1.75 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#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