Replace WTF::move with WTFMove
[WebKit-https.git] / Source / JavaScriptCore / inspector / scripts / codegen / cpp_generator_templates.py
1 #!/usr/bin/env python
2 #
3 # Copyright (c) 2014, 2015 Apple Inc. All rights reserved.
4 # Copyright (c) 2014 University of Washington. All rights reserved.
5 #
6 # Redistribution and use in source and binary forms, with or without
7 # modification, are permitted provided that the following conditions
8 # are met:
9 # 1. Redistributions of source code must retain the above copyright
10 #    notice, this list of conditions and the following disclaimer.
11 # 2. Redistributions in binary form must reproduce the above copyright
12 #    notice, this list of conditions and the following disclaimer in the
13 #    documentation and/or other materials provided with the distribution.
14 #
15 # THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
16 # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17 # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
19 # BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
25 # THE POSSIBILITY OF SUCH DAMAGE.
26
27 # Generator templates, which can be filled with string.Template.
28 # Following are classes that fill the templates from the typechecked model.
29
30 class CppGeneratorTemplates:
31
32     HeaderPrelude = (
33     """#ifndef ${headerGuardString}
34 #define ${headerGuardString}
35
36 ${includes}
37
38 namespace Inspector {
39
40 ${typedefs}""")
41
42     HeaderPostlude = (
43     """} // namespace Inspector
44
45 #endif // !defined(${headerGuardString})""")
46
47     ImplementationPrelude = (
48     """#include "config.h"
49 #include ${primaryInclude}
50
51 ${secondaryIncludes}
52
53 namespace Inspector {""")
54
55     ImplementationPostlude = (
56     """} // namespace Inspector
57 """)
58
59     AlternateDispatchersHeaderPrelude = (
60     """#ifndef ${headerGuardString}
61 #define ${headerGuardString}
62
63 #if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
64
65 ${includes}
66
67 namespace Inspector {
68
69 class AlternateBackendDispatcher {
70 public:
71     void setBackendDispatcher(RefPtr<BackendDispatcher>&& dispatcher) { m_backendDispatcher = WTFMove(dispatcher); }
72     BackendDispatcher* backendDispatcher() const { return m_backendDispatcher.get(); }
73 private:
74     RefPtr<BackendDispatcher> m_backendDispatcher;
75 };
76 """)
77
78     AlternateDispatchersHeaderPostlude = (
79     """} // namespace Inspector
80
81 #endif // ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
82
83 #endif // !defined(${headerGuardString})""")
84
85     AlternateBackendDispatcherHeaderDomainHandlerInterfaceDeclaration = (
86     """class Alternate${domainName}BackendDispatcher : public AlternateBackendDispatcher {
87 public:
88     virtual ~Alternate${domainName}BackendDispatcher() { }
89 ${commandDeclarations}
90 };""")
91
92     BackendDispatcherHeaderDomainHandlerDeclaration = (
93     """${classAndExportMacro} ${domainName}BackendDispatcherHandler {
94 public:
95 ${commandDeclarations}
96 protected:
97     virtual ~${domainName}BackendDispatcherHandler();
98 };""")
99
100     BackendDispatcherHeaderDomainDispatcherDeclaration = (
101     """${classAndExportMacro} ${domainName}BackendDispatcher final : public SupplementalBackendDispatcher {
102 public:
103     static Ref<${domainName}BackendDispatcher> create(BackendDispatcher&, ${domainName}BackendDispatcherHandler*);
104     virtual void dispatch(long requestId, const String& method, Ref<InspectorObject>&& message) override;
105 ${commandDeclarations}
106 private:
107     ${domainName}BackendDispatcher(BackendDispatcher&, ${domainName}BackendDispatcherHandler*);
108     ${domainName}BackendDispatcherHandler* m_agent;
109 #if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
110 public:
111     void setAlternateDispatcher(Alternate${domainName}BackendDispatcher* alternateDispatcher) { m_alternateDispatcher = alternateDispatcher; }
112 private:
113     Alternate${domainName}BackendDispatcher* m_alternateDispatcher;
114 #endif
115 };""")
116
117     BackendDispatcherHeaderAsyncCommandDeclaration = (
118     """    ${classAndExportMacro} ${callbackName} : public BackendDispatcher::CallbackBase {
119     public:
120         ${callbackName}(Ref<BackendDispatcher>&&, int id);
121         void sendSuccess(${outParameters});
122     };
123     virtual void ${commandName}(${inParameters}) = 0;""")
124
125     BackendDispatcherImplementationSmallSwitch = (
126     """void ${domainName}BackendDispatcher::dispatch(long requestId, const String& method, Ref<InspectorObject>&& message)
127 {
128     Ref<${domainName}BackendDispatcher> protect(*this);
129
130     RefPtr<InspectorObject> parameters;
131     message->getObject(ASCIILiteral("params"), parameters);
132
133 ${dispatchCases}
134     else
135         m_backendDispatcher->reportProtocolError(BackendDispatcher::MethodNotFound, makeString('\\'', "${domainName}", '.', method, "' was not found"));
136 }""")
137
138     BackendDispatcherImplementationLargeSwitch = (
139 """void ${domainName}BackendDispatcher::dispatch(long requestId, const String& method, Ref<InspectorObject>&& message)
140 {
141     Ref<${domainName}BackendDispatcher> protect(*this);
142
143     RefPtr<InspectorObject> parameters;
144     message->getObject(ASCIILiteral("params"), parameters);
145
146     typedef void (${domainName}BackendDispatcher::*CallHandler)(long requestId, RefPtr<InspectorObject>&& message);
147     typedef HashMap<String, CallHandler> DispatchMap;
148     static NeverDestroyed<DispatchMap> dispatchMap;
149     if (dispatchMap.get().isEmpty()) {
150         static const struct MethodTable {
151             const char* name;
152             CallHandler handler;
153         } commands[] = {
154 ${dispatchCases}
155         };
156         size_t length = WTF_ARRAY_LENGTH(commands);
157         for (size_t i = 0; i < length; ++i)
158             dispatchMap.get().add(commands[i].name, commands[i].handler);
159     }
160
161     auto findResult = dispatchMap.get().find(method);
162     if (findResult == dispatchMap.get().end()) {
163         m_backendDispatcher->reportProtocolError(BackendDispatcher::MethodNotFound, makeString('\\'', "${domainName}", '.', method, "' was not found"));
164         return;
165     }
166
167     ((*this).*findResult->value)(requestId, WTFMove(parameters));
168 }""")
169
170     BackendDispatcherImplementationDomainConstructor = (
171     """Ref<${domainName}BackendDispatcher> ${domainName}BackendDispatcher::create(BackendDispatcher& backendDispatcher, ${domainName}BackendDispatcherHandler* agent)
172 {
173     return adoptRef(*new ${domainName}BackendDispatcher(backendDispatcher, agent));
174 }
175
176 ${domainName}BackendDispatcher::${domainName}BackendDispatcher(BackendDispatcher& backendDispatcher, ${domainName}BackendDispatcherHandler* agent)
177     : SupplementalBackendDispatcher(backendDispatcher)
178     , m_agent(agent)
179 #if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
180     , m_alternateDispatcher(nullptr)
181 #endif
182 {
183     m_backendDispatcher->registerDispatcherForDomain(ASCIILiteral("${domainName}"), this);
184 }""")
185
186     BackendDispatcherImplementationPrepareCommandArguments = (
187 """${inParameterDeclarations}
188     if (m_backendDispatcher->hasProtocolErrors()) {
189         m_backendDispatcher->reportProtocolError(BackendDispatcher::InvalidParams, String::format("Some arguments of method \'%s\' can't be processed", "${domainName}.${commandName}"));
190         return;
191     }
192 """)
193
194     BackendDispatcherImplementationAsyncCommand = (
195 """${domainName}BackendDispatcherHandler::${callbackName}::${callbackName}(Ref<BackendDispatcher>&& backendDispatcher, int id) : BackendDispatcher::CallbackBase(WTFMove(backendDispatcher), id) { }
196
197 void ${domainName}BackendDispatcherHandler::${callbackName}::sendSuccess(${formalParameters})
198 {
199     Ref<InspectorObject> jsonMessage = InspectorObject::create();
200 ${outParameterAssignments}
201     CallbackBase::sendSuccess(WTFMove(jsonMessage));
202 }""")
203
204     FrontendDispatcherDomainDispatcherDeclaration = (
205 """${classAndExportMacro} ${domainName}FrontendDispatcher {
206 public:
207     ${domainName}FrontendDispatcher(FrontendRouter& frontendRouter) : m_frontendRouter(frontendRouter) { }
208 ${eventDeclarations}
209 private:
210     FrontendRouter& m_frontendRouter;
211 };""")
212
213     ProtocolObjectBuilderDeclarationPrelude = (
214 """    template<int STATE>
215     class Builder {
216     private:
217         RefPtr<InspectorObject> m_result;
218
219         template<int STEP> Builder<STATE | STEP>& castState()
220         {
221             return *reinterpret_cast<Builder<STATE | STEP>*>(this);
222         }
223
224         Builder(Ref</*${objectType}*/InspectorObject>&& object)
225             : m_result(WTFMove(object))
226         {
227             COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
228         }
229         friend class ${objectType};
230     public:""")
231
232     ProtocolObjectBuilderDeclarationPostlude = (
233 """
234         Ref<${objectType}> release()
235         {
236             COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
237             COMPILE_ASSERT(sizeof(${objectType}) == sizeof(InspectorObject), cannot_cast);
238
239             Ref<InspectorObject> result = m_result.releaseNonNull();
240             return WTFMove(*reinterpret_cast<Ref<${objectType}>*>(&result));
241         }
242     };
243
244     /*
245      * Synthetic constructor:
246 ${constructorExample}
247      */
248     static Builder<NoFieldsSet> create()
249     {
250         return Builder<NoFieldsSet>(InspectorObject::create());
251     }""")
252
253     ProtocolObjectRuntimeCast = (
254 """RefPtr<${objectType}> BindingTraits<${objectType}>::runtimeCast(RefPtr<InspectorValue>&& value)
255 {
256     RefPtr<InspectorObject> result;
257     bool castSucceeded = value->asObject(result);
258     ASSERT_UNUSED(castSucceeded, castSucceeded);
259 #if !ASSERT_DISABLED
260     BindingTraits<${objectType}>::assertValueHasExpectedType(result.get());
261 #endif  // !ASSERT_DISABLED
262     COMPILE_ASSERT(sizeof(${objectType}) == sizeof(InspectorObjectBase), type_cast_problem);
263     return static_cast<${objectType}*>(static_cast<InspectorObjectBase*>(result.get()));
264 }
265 """)