fbthrift/thrift/lib/cpp2/reflection/demo/module_basics.cpp at perf_build · mingtaoy/fbthrift · GitHub

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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
/*
 * Copyright 2016-present Facebook, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <iostream>

#include <thrift/lib/cpp2/reflection/demo/gen-cpp2/data_fatal_types.h>
#include <thrift/lib/cpp2/reflection/reflection.h>

using namespace apache::thrift;
using namespace static_reflection::demo;

struct print_namespace {
  template <typename Language, typename Namespace, std::size_t Index>
  void operator()(fatal::indexed_pair<Language, Namespace, Index>) const {
    std::cout << "  namespace for '" << fatal::z_data<Language>() << "'\n";
  }
};

struct print_enum_member {
  template <typename Member, std::size_t Index>
  void operator()(fatal::indexed<Member, Index>) const {
    std::cout << "    " << fatal::z_data<typename Member::name>() << '\n';
  }
};

struct print_enum {
  template <typename T, typename Name, std::size_t Index>
  void operator()(fatal::indexed_pair<T, Name, Index>) const {
    using info = fatal::enum_traits<T>;
    std::cout << "  enum " << fatal::z_data<Name>() << " {\n";
    fatal::foreach<typename info::fields>(print_enum_member());
    std::cout << "  }\n\n";
  }
};

struct print_variant_member {
  template <typename Member, std::size_t Index>
  void operator()(fatal::indexed<Member, Index>) const {
    std::cout << "    " << fatal::z_data<typename Member::metadata::name>()
              << '\n';
  }
};

struct print_variant {
  template <typename T, typename Name, std::size_t Index>
  void operator()(fatal::indexed_pair<T, Name, Index>) const {
    using info = fatal::variant_traits<T>;
    std::cout << "  variant " << fatal::z_data<Name>() << " {\n";
    fatal::foreach<typename info::descriptors>(print_variant_member());
    std::cout << "  }\n\n";
  }
};

struct print_struct_member {
  template <typename Member, std::size_t Index>
  void operator()(fatal::indexed<Member, Index>) const {
    std::cout << "    " << fatal::z_data<typename Member::name>() << '\n';
  }
};

struct print_struct {
  template <typename T, typename Name, std::size_t Index>
  void operator()(fatal::indexed_pair<T, Name, Index>) const {
    using info = reflect_struct<T>;
    std::cout << "  struct " << fatal::z_data<Name>() << " {\n";
    fatal::foreach<typename info::members>(print_struct_member());
    std::cout << "  }\n\n";
  }
};

template <typename Module>
void print_module_info() {
  using info = reflect_module<Module>;
  std::cout << "module name: " << fatal::z_data<typename info::name>() << '\n';

  std::cout << '\n';

  std::cout << "namespaces declared in module\n";
  fatal::foreach<typename info::namespaces>(print_namespace());

  std::cout << '\n';

  std::cout << "enums declared in module\n";
  fatal::foreach<typename info::enums>(print_enum());

  std::cout << "variants declared in module\n";
  fatal::foreach<typename info::unions>(print_variant());

  std::cout << "structs declared in module\n";
  fatal::foreach<typename info::structs>(print_struct());
}

int main() {
  print_module_info<static_reflection::demo::data_tags::module>();

  return 0;
}