1
2 #ifndef RMF_AVRO2_TYPES_H
3 #define RMF_AVRO2_TYPES_H
4
5 #include "RMF/config.h"
6 #include "RMF/ID.h"
7 #include "RMF/types.h"
8 #include "RMF/internal/SharedDataHierarchy.h"
9 #include "RMF/internal/SharedDataData.h"
10 #include "RMF/internal/SharedDataFrames.h"
11 #include "RMF/internal/small_set_map.h"
12
13 #include "avrocpp/api/Specific.hh"
14 #include "avrocpp/api/Encoder.hh"
15 #include "avrocpp/api/Decoder.hh"
16
17 RMF_ENABLE_WARNINGS
18
19 namespace RMF {
20 namespace avro2 {
21
22 template <class Traits>
23 struct KeyMaps {
24 RMF_SMALL_UNORDERED_MAP<ID<Traits>, Category> category;
25 RMF_SMALL_UNORDERED_MAP<ID<Traits>, std::string> name;
26 };
27
28 template <class Traits>
clear(KeyMaps<Traits> & km)29 inline void clear(KeyMaps<Traits>& km) {
30 km.category.clear();
31 km.name.clear();
32 }
33
34 struct KeyData {
35 KeyMaps<FloatTraits> float_keys;
36 KeyMaps<IntTraits> int_keys;
37 KeyMaps<StringTraits> string_keys;
38 KeyMaps<FloatsTraits> floats_keys;
39 KeyMaps<IntsTraits> ints_keys;
40 KeyMaps<StringsTraits> strings_keys;
41 KeyMaps<Vector3Traits> vector3_keys;
42 KeyMaps<Vector4Traits> vector4_keys;
43 KeyMaps<Vector3sTraits> vector3s_keys;
44 };
45
46 // mac os < 10.9 workaround
clear(KeyData & kd)47 inline void clear(KeyData& kd) {
48 clear(kd.float_keys);
49 clear(kd.int_keys);
50 clear(kd.string_keys);
51 clear(kd.floats_keys);
52 clear(kd.ints_keys);
53 clear(kd.strings_keys);
54 clear(kd.vector3_keys);
55 clear(kd.vector4_keys);
56 clear(kd.vector3s_keys);
57 }
58
59 typedef internal::TypeData<FloatTraits> FloatData;
60 typedef internal::TypeData<StringTraits> StringData;
61 typedef internal::TypeData<IntTraits> IntData;
62 typedef internal::TypeData<FloatsTraits> FloatsData;
63 typedef internal::TypeData<StringsTraits> StringsData;
64 typedef internal::TypeData<IntsTraits> IntsData;
65 typedef internal::TypeData<Vector3Traits> Vector3Data;
66 typedef internal::TypeData<Vector4Traits> Vector4Data;
67 typedef internal::TypeData<Vector3sTraits> Vector3sData;
68
69 struct HierarchyNode {
70 NodeID id;
71 std::string name;
72 NodeType type;
73 NodeIDs parents;
74 };
75
76 struct DataTypes {
77 FloatData float_data;
78 StringData string_data;
79 IntData int_data;
80 StringsData strings_data;
81 FloatsData floats_data;
82 IntsData ints_data;
83 Vector3Data vector3_data;
84 Vector4Data vector4_data;
85 Vector3sData vector3s_data;
86 };
87
clear(DataTypes & dt)88 inline void clear(DataTypes& dt) {
89 dt.float_data.clear();
90 dt.string_data.clear();
91 dt.int_data.clear();
92 dt.strings_data.clear();
93 dt.floats_data.clear();
94 dt.ints_data.clear();
95 dt.vector3_data.clear();
96 dt.vector4_data.clear();
97 dt.vector3s_data.clear();
98 }
99
100 enum KeyType {
101 INT,
102 FLOAT,
103 STRING,
104 INTS,
105 FLOATS,
106 STRINGS,
107 VECTOR3,
108 VECTOR4,
109 VECTOR3S
110 };
111
112 struct KeyInfo {
113 std::string name;
114 Category category;
115 int32_t id;
116 KeyType type;
117 };
118
119 struct StringAccumulator : public std::string {
setStringAccumulator120 void set(std::string v) { std::string::operator=(v); }
121 };
122
123 struct FileData {
124 // only used during parsing
125 FrameID cur_id;
126 StringAccumulator description;
127 StringAccumulator producer;
128 std::vector<std::pair<Category, std::string> > categories;
129 RMF_SMALL_UNORDERED_MAP<int, std::string> extra_node_types;
130 RMF_SMALL_UNORDERED_MAP<int, std::string> extra_frame_types;
131 RMF_SMALL_UNORDERED_MAP<int32_t, RMF_SMALL_UNORDERED_SET<RMF::NodeID> >
132 node_sets;
133
134 FrameID max_id;
135 std::vector<internal::HierarchyNode<NodeID, NodeType> > nodes;
136 RMF_LARGE_UNORDERED_MAP<FrameID, internal::FrameData> frames;
137 KeyData keys;
138 DataTypes data;
139 RMF_LARGE_UNORDERED_MAP<FrameID, int64_t> frame_block_offsets;
140 };
141
142 // awkward workaround for Mac OS < 10.9
clear(FileData & fd)143 inline void clear(FileData& fd) {
144 fd.description.clear();
145 fd.producer.clear();
146 fd.categories.clear();
147 fd.extra_node_types.clear();
148 fd.extra_frame_types.clear();
149 fd.node_sets.clear();
150 fd.nodes.clear();
151 fd.frames.clear();
152 clear(fd.keys);
153 clear(fd.data);
154 fd.frame_block_offsets.clear();
155 }
156
157 struct FileDataChanges {
158 std::string description;
159 std::string producer;
160 std::vector<std::pair<Category, std::string> > categories;
161 std::vector<std::pair<NodeType, std::string> > node_types;
162 std::vector<std::pair<FrameType, std::string> > frame_types;
163 std::vector<std::pair<int32_t, RMF::NodeIDs> > node_sets;
164
165 std::vector<HierarchyNode> nodes;
166 std::vector<KeyInfo> keys;
167 DataTypes data;
168 };
169
170 struct Frame {
171 FrameID id;
172 std::string name;
173 FrameType type;
174 FrameIDs parents;
175 std::vector<HierarchyNode> nodes;
176 std::vector<KeyInfo> keys;
177 DataTypes data;
178 };
179 }
180 }
181
182 RMF_DISABLE_WARNINGS
183 #endif // RMF_AVRO2_TYPES_H
184