diff options
Diffstat (limited to 'ddl/out/cpp/TestData.cpp')
-rw-r--r-- | ddl/out/cpp/TestData.cpp | 246 |
1 files changed, 246 insertions, 0 deletions
diff --git a/ddl/out/cpp/TestData.cpp b/ddl/out/cpp/TestData.cpp new file mode 100644 index 0000000..466f1a7 --- /dev/null +++ b/ddl/out/cpp/TestData.cpp | |||
@@ -0,0 +1,246 @@ | |||
1 | // generated file, do not modify! | ||
2 | // 2016-11-11T11:17:03.685172000000Z | ||
3 | |||
4 | #include "TestData.hpp" | ||
5 | template<> json toJSON<std::shared_ptr<ClientInfo>>(std::shared_ptr<ClientInfo> &v) { | ||
6 | json obj({}); | ||
7 | switch (v->tag) { | ||
8 | case ::ClientInfo::tag::ClientInfo: | ||
9 | obj["tag"] = "ClientInfo"; | ||
10 | { | ||
11 | std::shared_ptr<data::ClientInfo> tv = std::static_pointer_cast<data::ClientInfo>(v); | ||
12 | obj["clientName"] = toJSON(tv->clientName); | ||
13 | obj["clientBackend"] = toJSON(tv->clientBackend); | ||
14 | } | ||
15 | break; | ||
16 | } | ||
17 | return obj; | ||
18 | } | ||
19 | |||
20 | template<> std::shared_ptr<ClientInfo> fromJSON<std::shared_ptr<ClientInfo>>(W<std::shared_ptr<ClientInfo>> v, json &obj) { | ||
21 | enum ::ClientInfo::tag tagType; | ||
22 | std::string tag = obj["tag"]; | ||
23 | if (tag == "ClientInfo") { | ||
24 | tagType = ::ClientInfo::tag::ClientInfo; | ||
25 | std::shared_ptr<data::ClientInfo> tv(new data::ClientInfo()); | ||
26 | tv->clientName = fromJSON(W<String>(), obj["clientName"]); | ||
27 | tv->clientBackend = fromJSON(W<std::shared_ptr<::Backend>>(), obj["clientBackend"]); | ||
28 | return tv; | ||
29 | } | ||
30 | else throw "unknown constructor: " + tag; | ||
31 | std::shared_ptr<::ClientInfo> o(new ::ClientInfo()); | ||
32 | o->tag = tagType; | ||
33 | return o; | ||
34 | } | ||
35 | |||
36 | template<> json toJSON<std::shared_ptr<Frame>>(std::shared_ptr<Frame> &v) { | ||
37 | json obj({}); | ||
38 | switch (v->tag) { | ||
39 | case ::Frame::tag::Frame: | ||
40 | obj["tag"] = "Frame"; | ||
41 | { | ||
42 | std::shared_ptr<data::Frame> tv = std::static_pointer_cast<data::Frame>(v); | ||
43 | obj["renderCount"] = toJSON(tv->renderCount); | ||
44 | obj["frameUniforms"] = toJSON(tv->frameUniforms); | ||
45 | obj["frameTextures"] = toJSON(tv->frameTextures); | ||
46 | } | ||
47 | break; | ||
48 | } | ||
49 | return obj; | ||
50 | } | ||
51 | |||
52 | template<> std::shared_ptr<Frame> fromJSON<std::shared_ptr<Frame>>(W<std::shared_ptr<Frame>> v, json &obj) { | ||
53 | enum ::Frame::tag tagType; | ||
54 | std::string tag = obj["tag"]; | ||
55 | if (tag == "Frame") { | ||
56 | tagType = ::Frame::tag::Frame; | ||
57 | std::shared_ptr<data::Frame> tv(new data::Frame()); | ||
58 | tv->renderCount = fromJSON(W<Int>(), obj["renderCount"]); | ||
59 | tv->frameUniforms = fromJSON(W<std::map<String, std::shared_ptr<::Value>>>(), obj["frameUniforms"]); | ||
60 | tv->frameTextures = fromJSON(W<std::map<String, Int>>(), obj["frameTextures"]); | ||
61 | return tv; | ||
62 | } | ||
63 | else throw "unknown constructor: " + tag; | ||
64 | std::shared_ptr<::Frame> o(new ::Frame()); | ||
65 | o->tag = tagType; | ||
66 | return o; | ||
67 | } | ||
68 | |||
69 | template<> json toJSON<std::shared_ptr<Scene>>(std::shared_ptr<Scene> &v) { | ||
70 | json obj({}); | ||
71 | switch (v->tag) { | ||
72 | case ::Scene::tag::Scene: | ||
73 | obj["tag"] = "Scene"; | ||
74 | { | ||
75 | std::shared_ptr<data::Scene> tv = std::static_pointer_cast<data::Scene>(v); | ||
76 | obj["objectArrays"] = toJSON(tv->objectArrays); | ||
77 | obj["renderTargetWidth"] = toJSON(tv->renderTargetWidth); | ||
78 | obj["renderTargetHeight"] = toJSON(tv->renderTargetHeight); | ||
79 | obj["frames"] = toJSON(tv->frames); | ||
80 | } | ||
81 | break; | ||
82 | } | ||
83 | return obj; | ||
84 | } | ||
85 | |||
86 | template<> std::shared_ptr<Scene> fromJSON<std::shared_ptr<Scene>>(W<std::shared_ptr<Scene>> v, json &obj) { | ||
87 | enum ::Scene::tag tagType; | ||
88 | std::string tag = obj["tag"]; | ||
89 | if (tag == "Scene") { | ||
90 | tagType = ::Scene::tag::Scene; | ||
91 | std::shared_ptr<data::Scene> tv(new data::Scene()); | ||
92 | tv->objectArrays = fromJSON(W<std::map<String, std::vector<Int>>>(), obj["objectArrays"]); | ||
93 | tv->renderTargetWidth = fromJSON(W<Int>(), obj["renderTargetWidth"]); | ||
94 | tv->renderTargetHeight = fromJSON(W<Int>(), obj["renderTargetHeight"]); | ||
95 | tv->frames = fromJSON(W<std::vector<std::shared_ptr<::Frame>>>(), obj["frames"]); | ||
96 | return tv; | ||
97 | } | ||
98 | else throw "unknown constructor: " + tag; | ||
99 | std::shared_ptr<::Scene> o(new ::Scene()); | ||
100 | o->tag = tagType; | ||
101 | return o; | ||
102 | } | ||
103 | |||
104 | template<> json toJSON<std::shared_ptr<PipelineInfo>>(std::shared_ptr<PipelineInfo> &v) { | ||
105 | json obj({}); | ||
106 | switch (v->tag) { | ||
107 | case ::PipelineInfo::tag::PipelineInfo: | ||
108 | obj["tag"] = "PipelineInfo"; | ||
109 | { | ||
110 | std::shared_ptr<data::PipelineInfo> tv = std::static_pointer_cast<data::PipelineInfo>(v); | ||
111 | obj["pipelineName"] = toJSON(tv->pipelineName); | ||
112 | obj["pipeline"] = toJSON(tv->pipeline); | ||
113 | } | ||
114 | break; | ||
115 | } | ||
116 | return obj; | ||
117 | } | ||
118 | |||
119 | template<> std::shared_ptr<PipelineInfo> fromJSON<std::shared_ptr<PipelineInfo>>(W<std::shared_ptr<PipelineInfo>> v, json &obj) { | ||
120 | enum ::PipelineInfo::tag tagType; | ||
121 | std::string tag = obj["tag"]; | ||
122 | if (tag == "PipelineInfo") { | ||
123 | tagType = ::PipelineInfo::tag::PipelineInfo; | ||
124 | std::shared_ptr<data::PipelineInfo> tv(new data::PipelineInfo()); | ||
125 | tv->pipelineName = fromJSON(W<String>(), obj["pipelineName"]); | ||
126 | tv->pipeline = fromJSON(W<std::shared_ptr<::Pipeline>>(), obj["pipeline"]); | ||
127 | return tv; | ||
128 | } | ||
129 | else throw "unknown constructor: " + tag; | ||
130 | std::shared_ptr<::PipelineInfo> o(new ::PipelineInfo()); | ||
131 | o->tag = tagType; | ||
132 | return o; | ||
133 | } | ||
134 | |||
135 | template<> json toJSON<std::shared_ptr<RenderJob>>(std::shared_ptr<RenderJob> &v) { | ||
136 | json obj({}); | ||
137 | switch (v->tag) { | ||
138 | case ::RenderJob::tag::RenderJob: | ||
139 | obj["tag"] = "RenderJob"; | ||
140 | { | ||
141 | std::shared_ptr<data::RenderJob> tv = std::static_pointer_cast<data::RenderJob>(v); | ||
142 | obj["meshes"] = toJSON(tv->meshes); | ||
143 | obj["textures"] = toJSON(tv->textures); | ||
144 | obj["schema"] = toJSON(tv->schema); | ||
145 | obj["scenes"] = toJSON(tv->scenes); | ||
146 | obj["pipelines"] = toJSON(tv->pipelines); | ||
147 | } | ||
148 | break; | ||
149 | } | ||
150 | return obj; | ||
151 | } | ||
152 | |||
153 | template<> std::shared_ptr<RenderJob> fromJSON<std::shared_ptr<RenderJob>>(W<std::shared_ptr<RenderJob>> v, json &obj) { | ||
154 | enum ::RenderJob::tag tagType; | ||
155 | std::string tag = obj["tag"]; | ||
156 | if (tag == "RenderJob") { | ||
157 | tagType = ::RenderJob::tag::RenderJob; | ||
158 | std::shared_ptr<data::RenderJob> tv(new data::RenderJob()); | ||
159 | tv->meshes = fromJSON(W<std::vector<std::shared_ptr<::Mesh>>>(), obj["meshes"]); | ||
160 | tv->textures = fromJSON(W<std::vector<String>>(), obj["textures"]); | ||
161 | tv->schema = fromJSON(W<std::shared_ptr<::PipelineSchema>>(), obj["schema"]); | ||
162 | tv->scenes = fromJSON(W<std::vector<std::shared_ptr<::Scene>>>(), obj["scenes"]); | ||
163 | tv->pipelines = fromJSON(W<std::vector<std::shared_ptr<::PipelineInfo>>>(), obj["pipelines"]); | ||
164 | return tv; | ||
165 | } | ||
166 | else throw "unknown constructor: " + tag; | ||
167 | std::shared_ptr<::RenderJob> o(new ::RenderJob()); | ||
168 | o->tag = tagType; | ||
169 | return o; | ||
170 | } | ||
171 | |||
172 | template<> json toJSON<std::shared_ptr<FrameResult>>(std::shared_ptr<FrameResult> &v) { | ||
173 | json obj({}); | ||
174 | switch (v->tag) { | ||
175 | case ::FrameResult::tag::FrameResult: | ||
176 | obj["tag"] = "FrameResult"; | ||
177 | { | ||
178 | std::shared_ptr<data::FrameResult> tv = std::static_pointer_cast<data::FrameResult>(v); | ||
179 | obj["frRenderTimes"] = toJSON(tv->frRenderTimes); | ||
180 | obj["frImageWidth"] = toJSON(tv->frImageWidth); | ||
181 | obj["frImageHeight"] = toJSON(tv->frImageHeight); | ||
182 | } | ||
183 | break; | ||
184 | } | ||
185 | return obj; | ||
186 | } | ||
187 | |||
188 | template<> std::shared_ptr<FrameResult> fromJSON<std::shared_ptr<FrameResult>>(W<std::shared_ptr<FrameResult>> v, json &obj) { | ||
189 | enum ::FrameResult::tag tagType; | ||
190 | std::string tag = obj["tag"]; | ||
191 | if (tag == "FrameResult") { | ||
192 | tagType = ::FrameResult::tag::FrameResult; | ||
193 | std::shared_ptr<data::FrameResult> tv(new data::FrameResult()); | ||
194 | tv->frRenderTimes = fromJSON(W<std::vector<Float>>(), obj["frRenderTimes"]); | ||
195 | tv->frImageWidth = fromJSON(W<Int>(), obj["frImageWidth"]); | ||
196 | tv->frImageHeight = fromJSON(W<Int>(), obj["frImageHeight"]); | ||
197 | return tv; | ||
198 | } | ||
199 | else throw "unknown constructor: " + tag; | ||
200 | std::shared_ptr<::FrameResult> o(new ::FrameResult()); | ||
201 | o->tag = tagType; | ||
202 | return o; | ||
203 | } | ||
204 | |||
205 | template<> json toJSON<std::shared_ptr<RenderJobResult>>(std::shared_ptr<RenderJobResult> &v) { | ||
206 | json obj({}); | ||
207 | switch (v->tag) { | ||
208 | case ::RenderJobResult::tag::RenderJobResult: | ||
209 | obj["tag"] = "RenderJobResult"; | ||
210 | { | ||
211 | std::shared_ptr<data::RenderJobResult> tv = std::static_pointer_cast<data::RenderJobResult>(v); | ||
212 | obj["arg0"] = toJSON(tv->_0); | ||
213 | } | ||
214 | break; | ||
215 | case ::RenderJobResult::tag::RenderJobError: | ||
216 | obj["tag"] = "RenderJobError"; | ||
217 | { | ||
218 | std::shared_ptr<data::RenderJobError> tv = std::static_pointer_cast<data::RenderJobError>(v); | ||
219 | obj["arg0"] = toJSON(tv->_0); | ||
220 | } | ||
221 | break; | ||
222 | } | ||
223 | return obj; | ||
224 | } | ||
225 | |||
226 | template<> std::shared_ptr<RenderJobResult> fromJSON<std::shared_ptr<RenderJobResult>>(W<std::shared_ptr<RenderJobResult>> v, json &obj) { | ||
227 | enum ::RenderJobResult::tag tagType; | ||
228 | std::string tag = obj["tag"]; | ||
229 | if (tag == "RenderJobResult") { | ||
230 | tagType = ::RenderJobResult::tag::RenderJobResult; | ||
231 | std::shared_ptr<data::RenderJobResult> tv(new data::RenderJobResult()); | ||
232 | tv->_0 = fromJSON(W<std::shared_ptr<::FrameResult>>(), obj["arg0"]); | ||
233 | return tv; | ||
234 | } | ||
235 | else if (tag == "RenderJobError") { | ||
236 | tagType = ::RenderJobResult::tag::RenderJobError; | ||
237 | std::shared_ptr<data::RenderJobError> tv(new data::RenderJobError()); | ||
238 | tv->_0 = fromJSON(W<String>(), obj["arg0"]); | ||
239 | return tv; | ||
240 | } | ||
241 | else throw "unknown constructor: " + tag; | ||
242 | std::shared_ptr<::RenderJobResult> o(new ::RenderJobResult()); | ||
243 | o->tag = tagType; | ||
244 | return o; | ||
245 | } | ||
246 | |||