[WTF] Import std::optional reference implementation as WTF::Optional
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestObj.h
1 /*
2     This file is part of the WebKit open source project.
3     This file has been generated by generate-bindings.pl. DO NOT MODIFY!
4
5     This library is free software; you can redistribute it and/or
6     modify it under the terms of the GNU Library General Public
7     License as published by the Free Software Foundation; either
8     version 2 of the License, or (at your option) any later version.
9
10     This library is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13     Library General Public License for more details.
14
15     You should have received a copy of the GNU Library General Public License
16     along with this library; see the file COPYING.LIB.  If not, write to
17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18     Boston, MA 02110-1301, USA.
19 */
20
21 #pragma once
22
23 #include "JSDOMConvert.h"
24 #include "JSDOMWrapper.h"
25 #include "TestObj.h"
26 #include <wtf/NeverDestroyed.h>
27
28 namespace WebCore {
29
30 class JSTestObj : public JSDOMWrapper<TestObj> {
31 public:
32     using Base = JSDOMWrapper<TestObj>;
33     static JSTestObj* create(JSC::Structure* structure, JSDOMGlobalObject* globalObject, Ref<TestObj>&& impl)
34     {
35         JSTestObj* ptr = new (NotNull, JSC::allocateCell<JSTestObj>(globalObject->vm().heap)) JSTestObj(structure, *globalObject, WTFMove(impl));
36         ptr->finishCreation(globalObject->vm());
37         return ptr;
38     }
39
40     static JSC::JSObject* createPrototype(JSC::VM&, JSC::JSGlobalObject*);
41     static JSC::JSObject* prototype(JSC::VM&, JSC::JSGlobalObject*);
42     static TestObj* toWrapped(JSC::JSValue);
43     static bool getOwnPropertySlot(JSC::JSObject*, JSC::ExecState*, JSC::PropertyName, JSC::PropertySlot&);
44     static bool getOwnPropertySlotByIndex(JSC::JSObject*, JSC::ExecState*, unsigned propertyName, JSC::PropertySlot&);
45     static void destroy(JSC::JSCell*);
46
47     DECLARE_INFO;
48
49     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
50     {
51         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
52     }
53
54     static void getOwnPropertyNames(JSC::JSObject*, JSC::ExecState*, JSC::PropertyNameArray&, JSC::EnumerationMode = JSC::EnumerationMode());
55     static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);
56     mutable JSC::WriteBarrier<JSC::Unknown> m_cachedAttribute1;
57     mutable JSC::WriteBarrier<JSC::Unknown> m_cachedAttribute2;
58     static void visitChildren(JSCell*, JSC::SlotVisitor&);
59
60
61     // Custom attributes
62     JSC::JSValue customAttr(JSC::ExecState&) const;
63     void setCustomAttr(JSC::ExecState&, JSC::JSValue);
64
65     // Custom functions
66     JSC::JSValue customMethod(JSC::ExecState&);
67     JSC::JSValue customMethodWithArgs(JSC::ExecState&);
68     static JSC::JSValue classMethod2(JSC::ExecState&);
69     JSC::JSValue testCustomPromiseFunction(JSC::ExecState&);
70 public:
71     static const unsigned StructureFlags = JSC::HasStaticPropertyTable | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames | Base::StructureFlags;
72 protected:
73     JSTestObj(JSC::Structure*, JSDOMGlobalObject&, Ref<TestObj>&&);
74
75     void finishCreation(JSC::VM&);
76 };
77
78 class JSTestObjOwner : public JSC::WeakHandleOwner {
79 public:
80     virtual bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&);
81     virtual void finalize(JSC::Handle<JSC::Unknown>, void* context);
82 };
83
84 inline JSC::WeakHandleOwner* wrapperOwner(DOMWrapperWorld&, TestObj*)
85 {
86     static NeverDestroyed<JSTestObjOwner> owner;
87     return &owner.get();
88 }
89
90 inline void* wrapperKey(TestObj* wrappableObject)
91 {
92     return wrappableObject;
93 }
94
95 JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, TestObj&);
96 inline JSC::JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject* globalObject, TestObj* impl) { return impl ? toJS(state, globalObject, *impl) : JSC::jsNull(); }
97 JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject*, Ref<TestObj>&&);
98 inline JSC::JSValue toJSNewlyCreated(JSC::ExecState* state, JSDOMGlobalObject* globalObject, RefPtr<TestObj>&& impl) { return impl ? toJSNewlyCreated(state, globalObject, impl.releaseNonNull()) : JSC::jsNull(); }
99
100 template<> struct JSDOMWrapperConverterTraits<TestObj> {
101     using WrapperClass = JSTestObj;
102     using ToWrappedReturnType = TestObj*;
103 };
104 template<> JSC::JSString* convertEnumerationToJS(JSC::ExecState&, TestObj::EnumType);
105
106 template<> std::optional<TestObj::EnumType> parseEnumeration<TestObj::EnumType>(JSC::ExecState&, JSC::JSValue);
107 template<> TestObj::EnumType convertEnumeration<TestObj::EnumType>(JSC::ExecState&, JSC::JSValue);
108 template<> const char* expectedEnumerationValues<TestObj::EnumType>();
109
110 template<> JSC::JSString* convertEnumerationToJS(JSC::ExecState&, TestObj::Optional);
111
112 template<> std::optional<TestObj::Optional> parseEnumeration<TestObj::Optional>(JSC::ExecState&, JSC::JSValue);
113 template<> TestObj::Optional convertEnumeration<TestObj::Optional>(JSC::ExecState&, JSC::JSValue);
114 template<> const char* expectedEnumerationValues<TestObj::Optional>();
115
116 template<> JSC::JSString* convertEnumerationToJS(JSC::ExecState&, AlternateEnumName);
117
118 template<> std::optional<AlternateEnumName> parseEnumeration<AlternateEnumName>(JSC::ExecState&, JSC::JSValue);
119 template<> AlternateEnumName convertEnumeration<AlternateEnumName>(JSC::ExecState&, JSC::JSValue);
120 template<> const char* expectedEnumerationValues<AlternateEnumName>();
121
122 #if ENABLE(Condition1)
123
124 template<> JSC::JSString* convertEnumerationToJS(JSC::ExecState&, TestObj::EnumA);
125
126 template<> std::optional<TestObj::EnumA> parseEnumeration<TestObj::EnumA>(JSC::ExecState&, JSC::JSValue);
127 template<> TestObj::EnumA convertEnumeration<TestObj::EnumA>(JSC::ExecState&, JSC::JSValue);
128 template<> const char* expectedEnumerationValues<TestObj::EnumA>();
129
130 #endif
131
132 #if ENABLE(Condition1) && ENABLE(Condition2)
133
134 template<> JSC::JSString* convertEnumerationToJS(JSC::ExecState&, TestObj::EnumB);
135
136 template<> std::optional<TestObj::EnumB> parseEnumeration<TestObj::EnumB>(JSC::ExecState&, JSC::JSValue);
137 template<> TestObj::EnumB convertEnumeration<TestObj::EnumB>(JSC::ExecState&, JSC::JSValue);
138 template<> const char* expectedEnumerationValues<TestObj::EnumB>();
139
140 #endif
141
142 #if ENABLE(Condition1) || ENABLE(Condition2)
143
144 template<> JSC::JSString* convertEnumerationToJS(JSC::ExecState&, TestObj::EnumC);
145
146 template<> std::optional<TestObj::EnumC> parseEnumeration<TestObj::EnumC>(JSC::ExecState&, JSC::JSValue);
147 template<> TestObj::EnumC convertEnumeration<TestObj::EnumC>(JSC::ExecState&, JSC::JSValue);
148 template<> const char* expectedEnumerationValues<TestObj::EnumC>();
149
150 #endif
151
152 template<> JSC::JSString* convertEnumerationToJS(JSC::ExecState&, TestObj::Kind);
153
154 template<> std::optional<TestObj::Kind> parseEnumeration<TestObj::Kind>(JSC::ExecState&, JSC::JSValue);
155 template<> TestObj::Kind convertEnumeration<TestObj::Kind>(JSC::ExecState&, JSC::JSValue);
156 template<> const char* expectedEnumerationValues<TestObj::Kind>();
157
158 template<> JSC::JSString* convertEnumerationToJS(JSC::ExecState&, TestObj::Size);
159
160 template<> std::optional<TestObj::Size> parseEnumeration<TestObj::Size>(JSC::ExecState&, JSC::JSValue);
161 template<> TestObj::Size convertEnumeration<TestObj::Size>(JSC::ExecState&, JSC::JSValue);
162 template<> const char* expectedEnumerationValues<TestObj::Size>();
163
164 template<> JSC::JSString* convertEnumerationToJS(JSC::ExecState&, TestObj::Confidence);
165
166 template<> std::optional<TestObj::Confidence> parseEnumeration<TestObj::Confidence>(JSC::ExecState&, JSC::JSValue);
167 template<> TestObj::Confidence convertEnumeration<TestObj::Confidence>(JSC::ExecState&, JSC::JSValue);
168 template<> const char* expectedEnumerationValues<TestObj::Confidence>();
169
170 template<> TestObj::Dictionary convertDictionary<TestObj::Dictionary>(JSC::ExecState&, JSC::JSValue);
171
172 template<> TestObj::DictionaryThatShouldNotTolerateNull convertDictionary<TestObj::DictionaryThatShouldNotTolerateNull>(JSC::ExecState&, JSC::JSValue);
173
174 template<> TestObj::DictionaryThatShouldTolerateNull convertDictionary<TestObj::DictionaryThatShouldTolerateNull>(JSC::ExecState&, JSC::JSValue);
175
176 template<> AlternateDictionaryName convertDictionary<AlternateDictionaryName>(JSC::ExecState&, JSC::JSValue);
177
178 template<> TestObj::ParentDictionary convertDictionary<TestObj::ParentDictionary>(JSC::ExecState&, JSC::JSValue);
179
180 template<> TestObj::ChildDictionary convertDictionary<TestObj::ChildDictionary>(JSC::ExecState&, JSC::JSValue);
181
182 #if ENABLE(Condition1)
183
184 template<> TestObj::ConditionalDictionaryA convertDictionary<TestObj::ConditionalDictionaryA>(JSC::ExecState&, JSC::JSValue);
185
186 #endif
187
188 #if ENABLE(Condition1) && ENABLE(Condition2)
189
190 template<> TestObj::ConditionalDictionaryB convertDictionary<TestObj::ConditionalDictionaryB>(JSC::ExecState&, JSC::JSValue);
191
192 #endif
193
194 #if ENABLE(Condition1) || ENABLE(Condition2)
195
196 template<> TestObj::ConditionalDictionaryC convertDictionary<TestObj::ConditionalDictionaryC>(JSC::ExecState&, JSC::JSValue);
197
198 #endif
199
200
201 } // namespace WebCore