TreeContainerTransformation.hpp 2.27 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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#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 <>
    struct Apply<Impl::Ignore>
    {
      template <class F>
      static auto impl(F&& /*f*/, Impl::Ignore)
      {
        return Impl::Ignore{};
      }
    };

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

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

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

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

    template <>
    struct ForEach<Impl::Ignore>
    {
      template <class F>
      static void impl(Impl::Ignore, F&& /*f*/) {}
    };

    template <class Value, class Container>
    struct ForEach<Impl::ValueAndContainer<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 Value>
    struct ForEach<Impl::ValueAndContainer<Value,void>>
    {
      template <class VC, class F>
      static void impl(VC&& vc, F&& f)
      {
        Recursive::forEach(vc.value(),f);
      }
    };

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

  } // end namespace Tools
} // end namespace AMDiS