Line data Source code
1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/jsipc/JavaScriptTypes.h"
8 :
9 :
10 : //-----------------------------------------------------------------------------
11 : // Method definitions for the IPDL type |struct JSIID|
12 : //
13 : namespace mozilla {
14 : namespace jsipc {
15 0 : MOZ_IMPLICIT JSIID::JSIID() :
16 : m0_(),
17 : m1_(),
18 : m2_(),
19 : m3_0_(),
20 : m3_1_(),
21 : m3_2_(),
22 : m3_3_(),
23 : m3_4_(),
24 : m3_5_(),
25 : m3_6_(),
26 0 : m3_7_()
27 : {
28 0 : Init();
29 0 : }
30 :
31 0 : JSIID::~JSIID()
32 : {
33 0 : }
34 :
35 0 : auto JSIID::operator==(const JSIID& _o) const -> bool
36 : {
37 0 : if ((!((m0()) == ((_o).m0())))) {
38 0 : return false;
39 : }
40 0 : if ((!((m1()) == ((_o).m1())))) {
41 0 : return false;
42 : }
43 0 : if ((!((m2()) == ((_o).m2())))) {
44 0 : return false;
45 : }
46 0 : if ((!((m3_0()) == ((_o).m3_0())))) {
47 0 : return false;
48 : }
49 0 : if ((!((m3_1()) == ((_o).m3_1())))) {
50 0 : return false;
51 : }
52 0 : if ((!((m3_2()) == ((_o).m3_2())))) {
53 0 : return false;
54 : }
55 0 : if ((!((m3_3()) == ((_o).m3_3())))) {
56 0 : return false;
57 : }
58 0 : if ((!((m3_4()) == ((_o).m3_4())))) {
59 0 : return false;
60 : }
61 0 : if ((!((m3_5()) == ((_o).m3_5())))) {
62 0 : return false;
63 : }
64 0 : if ((!((m3_6()) == ((_o).m3_6())))) {
65 0 : return false;
66 : }
67 0 : if ((!((m3_7()) == ((_o).m3_7())))) {
68 0 : return false;
69 : }
70 0 : return true;
71 : }
72 :
73 0 : auto JSIID::operator!=(const JSIID& _o) const -> bool
74 : {
75 0 : return (!(operator==(_o)));
76 : }
77 :
78 0 : auto JSIID::Init() -> void
79 : {
80 0 : }
81 :
82 0 : auto JSIID::Assign(
83 : const uint32_t& _m0,
84 : const uint16_t& _m1,
85 : const uint16_t& _m2,
86 : const uint8_t& _m3_0,
87 : const uint8_t& _m3_1,
88 : const uint8_t& _m3_2,
89 : const uint8_t& _m3_3,
90 : const uint8_t& _m3_4,
91 : const uint8_t& _m3_5,
92 : const uint8_t& _m3_6,
93 : const uint8_t& _m3_7) -> void
94 : {
95 0 : m0_ = _m0;
96 0 : m1_ = _m1;
97 0 : m2_ = _m2;
98 0 : m3_0_ = _m3_0;
99 0 : m3_1_ = _m3_1;
100 0 : m3_2_ = _m3_2;
101 0 : m3_3_ = _m3_3;
102 0 : m3_4_ = _m3_4;
103 0 : m3_5_ = _m3_5;
104 0 : m3_6_ = _m3_6;
105 0 : m3_7_ = _m3_7;
106 0 : }
107 :
108 : } // namespace jsipc
109 : } // namespace mozilla
110 :
111 : //-----------------------------------------------------------------------------
112 : // Method definitions for the IPDL type |struct LocalObject|
113 : //
114 : namespace mozilla {
115 : namespace jsipc {
116 0 : MOZ_IMPLICIT LocalObject::LocalObject() :
117 0 : serializedId_()
118 : {
119 0 : Init();
120 0 : }
121 :
122 0 : LocalObject::~LocalObject()
123 : {
124 0 : }
125 :
126 0 : auto LocalObject::operator==(const LocalObject& _o) const -> bool
127 : {
128 0 : if ((!((serializedId()) == ((_o).serializedId())))) {
129 0 : return false;
130 : }
131 0 : return true;
132 : }
133 :
134 0 : auto LocalObject::operator!=(const LocalObject& _o) const -> bool
135 : {
136 0 : return (!(operator==(_o)));
137 : }
138 :
139 0 : auto LocalObject::Init() -> void
140 : {
141 0 : }
142 :
143 0 : auto LocalObject::Assign(const uint64_t& _serializedId) -> void
144 : {
145 0 : serializedId_ = _serializedId;
146 0 : }
147 :
148 : } // namespace jsipc
149 : } // namespace mozilla
150 :
151 : //-----------------------------------------------------------------------------
152 : // Method definitions for the IPDL type |struct RemoteObject|
153 : //
154 : namespace mozilla {
155 : namespace jsipc {
156 174 : MOZ_IMPLICIT RemoteObject::RemoteObject() :
157 : serializedId_(),
158 : isCallable_(),
159 : isConstructor_(),
160 : isDOMObject_(),
161 174 : objectTag_()
162 : {
163 174 : Init();
164 174 : }
165 :
166 203 : RemoteObject::~RemoteObject()
167 : {
168 203 : }
169 :
170 0 : auto RemoteObject::operator==(const RemoteObject& _o) const -> bool
171 : {
172 0 : if ((!((serializedId()) == ((_o).serializedId())))) {
173 0 : return false;
174 : }
175 0 : if ((!((isCallable()) == ((_o).isCallable())))) {
176 0 : return false;
177 : }
178 0 : if ((!((isConstructor()) == ((_o).isConstructor())))) {
179 0 : return false;
180 : }
181 0 : if ((!((isDOMObject()) == ((_o).isDOMObject())))) {
182 0 : return false;
183 : }
184 0 : if ((!((objectTag()) == ((_o).objectTag())))) {
185 0 : return false;
186 : }
187 0 : return true;
188 : }
189 :
190 0 : auto RemoteObject::operator!=(const RemoteObject& _o) const -> bool
191 : {
192 0 : return (!(operator==(_o)));
193 : }
194 :
195 203 : auto RemoteObject::Init() -> void
196 : {
197 203 : }
198 :
199 174 : auto RemoteObject::Assign(
200 : const uint64_t& _serializedId,
201 : const bool& _isCallable,
202 : const bool& _isConstructor,
203 : const bool& _isDOMObject,
204 : const nsCString& _objectTag) -> void
205 : {
206 174 : serializedId_ = _serializedId;
207 174 : isCallable_ = _isCallable;
208 174 : isConstructor_ = _isConstructor;
209 174 : isDOMObject_ = _isDOMObject;
210 174 : objectTag_ = _objectTag;
211 174 : }
212 :
213 : } // namespace jsipc
214 : } // namespace mozilla
215 :
216 : //-----------------------------------------------------------------------------
217 : // Method definitions for the IPDL type |union ObjectVariant|
218 : //
219 : namespace mozilla {
220 : namespace jsipc {
221 348 : auto ObjectVariant::MaybeDestroy(Type aNewType) -> bool
222 : {
223 348 : if ((mType) == (T__None)) {
224 203 : return true;
225 : }
226 145 : if ((mType) == (aNewType)) {
227 0 : return false;
228 : }
229 145 : switch (mType) {
230 : case TLocalObject:
231 : {
232 0 : (ptr_LocalObject())->~LocalObject__tdef();
233 0 : break;
234 : }
235 : case TRemoteObject:
236 : {
237 145 : (ptr_RemoteObject())->~RemoteObject__tdef();
238 145 : break;
239 : }
240 : default:
241 : {
242 0 : mozilla::ipc::LogicError("not reached");
243 0 : break;
244 : }
245 : }
246 145 : return true;
247 : }
248 :
249 0 : MOZ_IMPLICIT ObjectVariant::ObjectVariant(const LocalObject& aOther)
250 : {
251 0 : new (mozilla::KnownNotNull, ptr_LocalObject()) LocalObject(aOther);
252 0 : mType = TLocalObject;
253 0 : }
254 :
255 0 : MOZ_IMPLICIT ObjectVariant::ObjectVariant(const RemoteObject& aOther)
256 : {
257 0 : new (mozilla::KnownNotNull, ptr_RemoteObject()) RemoteObject(aOther);
258 0 : mType = TRemoteObject;
259 0 : }
260 :
261 0 : MOZ_IMPLICIT ObjectVariant::ObjectVariant(const ObjectVariant& aOther)
262 : {
263 0 : (aOther).AssertSanity();
264 0 : switch ((aOther).type()) {
265 : case TLocalObject:
266 : {
267 0 : new (mozilla::KnownNotNull, ptr_LocalObject()) LocalObject((aOther).get_LocalObject());
268 0 : break;
269 : }
270 : case TRemoteObject:
271 : {
272 0 : new (mozilla::KnownNotNull, ptr_RemoteObject()) RemoteObject((aOther).get_RemoteObject());
273 0 : break;
274 : }
275 : case T__None:
276 : {
277 0 : break;
278 : }
279 : default:
280 : {
281 0 : mozilla::ipc::LogicError("unreached");
282 0 : return;
283 : }
284 : }
285 0 : mType = (aOther).type();
286 : }
287 :
288 348 : ObjectVariant::~ObjectVariant()
289 : {
290 174 : static_cast<void>(MaybeDestroy(T__None));
291 174 : }
292 :
293 0 : auto ObjectVariant::operator=(const LocalObject& aRhs) -> ObjectVariant&
294 : {
295 0 : if (MaybeDestroy(TLocalObject)) {
296 0 : new (mozilla::KnownNotNull, ptr_LocalObject()) LocalObject;
297 : }
298 0 : (*(ptr_LocalObject())) = aRhs;
299 0 : mType = TLocalObject;
300 0 : return (*(this));
301 : }
302 :
303 58 : auto ObjectVariant::operator=(const RemoteObject& aRhs) -> ObjectVariant&
304 : {
305 58 : if (MaybeDestroy(TRemoteObject)) {
306 58 : new (mozilla::KnownNotNull, ptr_RemoteObject()) RemoteObject;
307 : }
308 58 : (*(ptr_RemoteObject())) = aRhs;
309 58 : mType = TRemoteObject;
310 58 : return (*(this));
311 : }
312 :
313 116 : auto ObjectVariant::operator=(const ObjectVariant& aRhs) -> ObjectVariant&
314 : {
315 116 : (aRhs).AssertSanity();
316 116 : Type t = (aRhs).type();
317 116 : switch (t) {
318 : case TLocalObject:
319 : {
320 0 : if (MaybeDestroy(t)) {
321 0 : new (mozilla::KnownNotNull, ptr_LocalObject()) LocalObject;
322 : }
323 0 : (*(ptr_LocalObject())) = (aRhs).get_LocalObject();
324 0 : break;
325 : }
326 : case TRemoteObject:
327 : {
328 87 : if (MaybeDestroy(t)) {
329 87 : new (mozilla::KnownNotNull, ptr_RemoteObject()) RemoteObject;
330 : }
331 87 : (*(ptr_RemoteObject())) = (aRhs).get_RemoteObject();
332 87 : break;
333 : }
334 : case T__None:
335 : {
336 29 : static_cast<void>(MaybeDestroy(t));
337 29 : break;
338 : }
339 : default:
340 : {
341 0 : mozilla::ipc::LogicError("unreached");
342 0 : break;
343 : }
344 : }
345 116 : mType = t;
346 116 : return (*(this));
347 : }
348 :
349 0 : auto ObjectVariant::operator==(const LocalObject& aRhs) const -> bool
350 : {
351 0 : return (get_LocalObject()) == (aRhs);
352 : }
353 :
354 0 : auto ObjectVariant::operator==(const RemoteObject& aRhs) const -> bool
355 : {
356 0 : return (get_RemoteObject()) == (aRhs);
357 : }
358 :
359 0 : auto ObjectVariant::operator==(const ObjectVariant& aRhs) const -> bool
360 : {
361 0 : if ((type()) != ((aRhs).type())) {
362 0 : return false;
363 : }
364 :
365 0 : switch (type()) {
366 : case TLocalObject:
367 : {
368 0 : return (get_LocalObject()) == ((aRhs).get_LocalObject());
369 : }
370 : case TRemoteObject:
371 : {
372 0 : return (get_RemoteObject()) == ((aRhs).get_RemoteObject());
373 : }
374 : default:
375 : {
376 0 : mozilla::ipc::LogicError("unreached");
377 0 : return false;
378 : }
379 : }
380 : }
381 :
382 0 : auto ObjectVariant::get(LocalObject* aOutValue) const -> void
383 : {
384 0 : (*(aOutValue)) = get_LocalObject();
385 0 : }
386 :
387 0 : auto ObjectVariant::get(RemoteObject* aOutValue) const -> void
388 : {
389 0 : (*(aOutValue)) = get_RemoteObject();
390 0 : }
391 :
392 : } // namespace jsipc
393 : } // namespace mozilla
394 :
395 : //-----------------------------------------------------------------------------
396 : // Method definitions for the IPDL type |struct WellKnownSymbol|
397 : //
398 : namespace mozilla {
399 : namespace jsipc {
400 0 : MOZ_IMPLICIT WellKnownSymbol::WellKnownSymbol() :
401 0 : which_()
402 : {
403 0 : Init();
404 0 : }
405 :
406 0 : WellKnownSymbol::~WellKnownSymbol()
407 : {
408 0 : }
409 :
410 0 : auto WellKnownSymbol::operator==(const WellKnownSymbol& _o) const -> bool
411 : {
412 0 : if ((!((which()) == ((_o).which())))) {
413 0 : return false;
414 : }
415 0 : return true;
416 : }
417 :
418 0 : auto WellKnownSymbol::operator!=(const WellKnownSymbol& _o) const -> bool
419 : {
420 0 : return (!(operator==(_o)));
421 : }
422 :
423 0 : auto WellKnownSymbol::Init() -> void
424 : {
425 0 : }
426 :
427 0 : auto WellKnownSymbol::Assign(const uint32_t& _which) -> void
428 : {
429 0 : which_ = _which;
430 0 : }
431 :
432 : } // namespace jsipc
433 : } // namespace mozilla
434 :
435 : //-----------------------------------------------------------------------------
436 : // Method definitions for the IPDL type |struct RegisteredSymbol|
437 : //
438 : namespace mozilla {
439 : namespace jsipc {
440 0 : MOZ_IMPLICIT RegisteredSymbol::RegisteredSymbol() :
441 0 : key_()
442 : {
443 0 : Init();
444 0 : }
445 :
446 0 : RegisteredSymbol::~RegisteredSymbol()
447 : {
448 0 : }
449 :
450 0 : auto RegisteredSymbol::operator==(const RegisteredSymbol& _o) const -> bool
451 : {
452 0 : if ((!((key()) == ((_o).key())))) {
453 0 : return false;
454 : }
455 0 : return true;
456 : }
457 :
458 0 : auto RegisteredSymbol::operator!=(const RegisteredSymbol& _o) const -> bool
459 : {
460 0 : return (!(operator==(_o)));
461 : }
462 :
463 0 : auto RegisteredSymbol::Init() -> void
464 : {
465 0 : }
466 :
467 0 : auto RegisteredSymbol::Assign(const nsString& _key) -> void
468 : {
469 0 : key_ = _key;
470 0 : }
471 :
472 : } // namespace jsipc
473 : } // namespace mozilla
474 :
475 : //-----------------------------------------------------------------------------
476 : // Method definitions for the IPDL type |union SymbolVariant|
477 : //
478 : namespace mozilla {
479 : namespace jsipc {
480 0 : auto SymbolVariant::MaybeDestroy(Type aNewType) -> bool
481 : {
482 0 : if ((mType) == (T__None)) {
483 0 : return true;
484 : }
485 0 : if ((mType) == (aNewType)) {
486 0 : return false;
487 : }
488 0 : switch (mType) {
489 : case TWellKnownSymbol:
490 : {
491 0 : (ptr_WellKnownSymbol())->~WellKnownSymbol__tdef();
492 0 : break;
493 : }
494 : case TRegisteredSymbol:
495 : {
496 0 : (ptr_RegisteredSymbol())->~RegisteredSymbol__tdef();
497 0 : break;
498 : }
499 : default:
500 : {
501 0 : mozilla::ipc::LogicError("not reached");
502 0 : break;
503 : }
504 : }
505 0 : return true;
506 : }
507 :
508 0 : MOZ_IMPLICIT SymbolVariant::SymbolVariant(const WellKnownSymbol& aOther)
509 : {
510 0 : new (mozilla::KnownNotNull, ptr_WellKnownSymbol()) WellKnownSymbol(aOther);
511 0 : mType = TWellKnownSymbol;
512 0 : }
513 :
514 0 : MOZ_IMPLICIT SymbolVariant::SymbolVariant(const RegisteredSymbol& aOther)
515 : {
516 0 : new (mozilla::KnownNotNull, ptr_RegisteredSymbol()) RegisteredSymbol(aOther);
517 0 : mType = TRegisteredSymbol;
518 0 : }
519 :
520 0 : MOZ_IMPLICIT SymbolVariant::SymbolVariant(const SymbolVariant& aOther)
521 : {
522 0 : (aOther).AssertSanity();
523 0 : switch ((aOther).type()) {
524 : case TWellKnownSymbol:
525 : {
526 0 : new (mozilla::KnownNotNull, ptr_WellKnownSymbol()) WellKnownSymbol((aOther).get_WellKnownSymbol());
527 0 : break;
528 : }
529 : case TRegisteredSymbol:
530 : {
531 0 : new (mozilla::KnownNotNull, ptr_RegisteredSymbol()) RegisteredSymbol((aOther).get_RegisteredSymbol());
532 0 : break;
533 : }
534 : case T__None:
535 : {
536 0 : break;
537 : }
538 : default:
539 : {
540 0 : mozilla::ipc::LogicError("unreached");
541 0 : return;
542 : }
543 : }
544 0 : mType = (aOther).type();
545 : }
546 :
547 0 : SymbolVariant::~SymbolVariant()
548 : {
549 0 : static_cast<void>(MaybeDestroy(T__None));
550 0 : }
551 :
552 0 : auto SymbolVariant::operator=(const WellKnownSymbol& aRhs) -> SymbolVariant&
553 : {
554 0 : if (MaybeDestroy(TWellKnownSymbol)) {
555 0 : new (mozilla::KnownNotNull, ptr_WellKnownSymbol()) WellKnownSymbol;
556 : }
557 0 : (*(ptr_WellKnownSymbol())) = aRhs;
558 0 : mType = TWellKnownSymbol;
559 0 : return (*(this));
560 : }
561 :
562 0 : auto SymbolVariant::operator=(const RegisteredSymbol& aRhs) -> SymbolVariant&
563 : {
564 0 : if (MaybeDestroy(TRegisteredSymbol)) {
565 0 : new (mozilla::KnownNotNull, ptr_RegisteredSymbol()) RegisteredSymbol;
566 : }
567 0 : (*(ptr_RegisteredSymbol())) = aRhs;
568 0 : mType = TRegisteredSymbol;
569 0 : return (*(this));
570 : }
571 :
572 0 : auto SymbolVariant::operator=(const SymbolVariant& aRhs) -> SymbolVariant&
573 : {
574 0 : (aRhs).AssertSanity();
575 0 : Type t = (aRhs).type();
576 0 : switch (t) {
577 : case TWellKnownSymbol:
578 : {
579 0 : if (MaybeDestroy(t)) {
580 0 : new (mozilla::KnownNotNull, ptr_WellKnownSymbol()) WellKnownSymbol;
581 : }
582 0 : (*(ptr_WellKnownSymbol())) = (aRhs).get_WellKnownSymbol();
583 0 : break;
584 : }
585 : case TRegisteredSymbol:
586 : {
587 0 : if (MaybeDestroy(t)) {
588 0 : new (mozilla::KnownNotNull, ptr_RegisteredSymbol()) RegisteredSymbol;
589 : }
590 0 : (*(ptr_RegisteredSymbol())) = (aRhs).get_RegisteredSymbol();
591 0 : break;
592 : }
593 : case T__None:
594 : {
595 0 : static_cast<void>(MaybeDestroy(t));
596 0 : break;
597 : }
598 : default:
599 : {
600 0 : mozilla::ipc::LogicError("unreached");
601 0 : break;
602 : }
603 : }
604 0 : mType = t;
605 0 : return (*(this));
606 : }
607 :
608 0 : auto SymbolVariant::operator==(const WellKnownSymbol& aRhs) const -> bool
609 : {
610 0 : return (get_WellKnownSymbol()) == (aRhs);
611 : }
612 :
613 0 : auto SymbolVariant::operator==(const RegisteredSymbol& aRhs) const -> bool
614 : {
615 0 : return (get_RegisteredSymbol()) == (aRhs);
616 : }
617 :
618 0 : auto SymbolVariant::operator==(const SymbolVariant& aRhs) const -> bool
619 : {
620 0 : if ((type()) != ((aRhs).type())) {
621 0 : return false;
622 : }
623 :
624 0 : switch (type()) {
625 : case TWellKnownSymbol:
626 : {
627 0 : return (get_WellKnownSymbol()) == ((aRhs).get_WellKnownSymbol());
628 : }
629 : case TRegisteredSymbol:
630 : {
631 0 : return (get_RegisteredSymbol()) == ((aRhs).get_RegisteredSymbol());
632 : }
633 : default:
634 : {
635 0 : mozilla::ipc::LogicError("unreached");
636 0 : return false;
637 : }
638 : }
639 : }
640 :
641 0 : auto SymbolVariant::get(WellKnownSymbol* aOutValue) const -> void
642 : {
643 0 : (*(aOutValue)) = get_WellKnownSymbol();
644 0 : }
645 :
646 0 : auto SymbolVariant::get(RegisteredSymbol* aOutValue) const -> void
647 : {
648 0 : (*(aOutValue)) = get_RegisteredSymbol();
649 0 : }
650 :
651 : } // namespace jsipc
652 : } // namespace mozilla
653 :
654 : //-----------------------------------------------------------------------------
655 : // Method definitions for the IPDL type |struct UndefinedVariant|
656 : //
657 : namespace mozilla {
658 : namespace jsipc {
659 0 : UndefinedVariant::~UndefinedVariant()
660 : {
661 0 : }
662 :
663 0 : auto UndefinedVariant::operator==(const UndefinedVariant& _o) const -> bool
664 : {
665 0 : return true;
666 : }
667 :
668 0 : auto UndefinedVariant::operator!=(const UndefinedVariant& _o) const -> bool
669 : {
670 0 : return (!(operator==(_o)));
671 : }
672 :
673 0 : auto UndefinedVariant::Init() -> void
674 : {
675 0 : }
676 :
677 0 : auto UndefinedVariant::Assign() -> void
678 : {
679 0 : }
680 :
681 : } // namespace jsipc
682 : } // namespace mozilla
683 :
684 : //-----------------------------------------------------------------------------
685 : // Method definitions for the IPDL type |struct NullVariant|
686 : //
687 : namespace mozilla {
688 : namespace jsipc {
689 90 : NullVariant::~NullVariant()
690 : {
691 90 : }
692 :
693 0 : auto NullVariant::operator==(const NullVariant& _o) const -> bool
694 : {
695 0 : return true;
696 : }
697 :
698 0 : auto NullVariant::operator!=(const NullVariant& _o) const -> bool
699 : {
700 0 : return (!(operator==(_o)));
701 : }
702 :
703 90 : auto NullVariant::Init() -> void
704 : {
705 90 : }
706 :
707 150 : auto NullVariant::Assign() -> void
708 : {
709 150 : }
710 :
711 : } // namespace jsipc
712 : } // namespace mozilla
713 :
714 : //-----------------------------------------------------------------------------
715 : // Method definitions for the IPDL type |union ObjectOrNullVariant|
716 : //
717 : namespace mozilla {
718 : namespace jsipc {
719 0 : auto ObjectOrNullVariant::MaybeDestroy(Type aNewType) -> bool
720 : {
721 0 : if ((mType) == (T__None)) {
722 0 : return true;
723 : }
724 0 : if ((mType) == (aNewType)) {
725 0 : return false;
726 : }
727 0 : switch (mType) {
728 : case TObjectVariant:
729 : {
730 0 : (ptr_ObjectVariant())->~ObjectVariant__tdef();
731 0 : break;
732 : }
733 : case TNullVariant:
734 : {
735 0 : (ptr_NullVariant())->~NullVariant__tdef();
736 0 : break;
737 : }
738 : default:
739 : {
740 0 : mozilla::ipc::LogicError("not reached");
741 0 : break;
742 : }
743 : }
744 0 : return true;
745 : }
746 :
747 0 : MOZ_IMPLICIT ObjectOrNullVariant::ObjectOrNullVariant(const ObjectVariant& aOther)
748 : {
749 0 : new (mozilla::KnownNotNull, ptr_ObjectVariant()) ObjectVariant(aOther);
750 0 : mType = TObjectVariant;
751 0 : }
752 :
753 0 : MOZ_IMPLICIT ObjectOrNullVariant::ObjectOrNullVariant(const NullVariant& aOther)
754 : {
755 0 : new (mozilla::KnownNotNull, ptr_NullVariant()) NullVariant(aOther);
756 0 : mType = TNullVariant;
757 0 : }
758 :
759 0 : MOZ_IMPLICIT ObjectOrNullVariant::ObjectOrNullVariant(const ObjectOrNullVariant& aOther)
760 : {
761 0 : (aOther).AssertSanity();
762 0 : switch ((aOther).type()) {
763 : case TObjectVariant:
764 : {
765 0 : new (mozilla::KnownNotNull, ptr_ObjectVariant()) ObjectVariant((aOther).get_ObjectVariant());
766 0 : break;
767 : }
768 : case TNullVariant:
769 : {
770 0 : new (mozilla::KnownNotNull, ptr_NullVariant()) NullVariant((aOther).get_NullVariant());
771 0 : break;
772 : }
773 : case T__None:
774 : {
775 0 : break;
776 : }
777 : default:
778 : {
779 0 : mozilla::ipc::LogicError("unreached");
780 0 : return;
781 : }
782 : }
783 0 : mType = (aOther).type();
784 : }
785 :
786 0 : ObjectOrNullVariant::~ObjectOrNullVariant()
787 : {
788 0 : static_cast<void>(MaybeDestroy(T__None));
789 0 : }
790 :
791 0 : auto ObjectOrNullVariant::operator=(const ObjectVariant& aRhs) -> ObjectOrNullVariant&
792 : {
793 0 : if (MaybeDestroy(TObjectVariant)) {
794 0 : new (mozilla::KnownNotNull, ptr_ObjectVariant()) ObjectVariant;
795 : }
796 0 : (*(ptr_ObjectVariant())) = aRhs;
797 0 : mType = TObjectVariant;
798 0 : return (*(this));
799 : }
800 :
801 0 : auto ObjectOrNullVariant::operator=(const NullVariant& aRhs) -> ObjectOrNullVariant&
802 : {
803 0 : if (MaybeDestroy(TNullVariant)) {
804 0 : new (mozilla::KnownNotNull, ptr_NullVariant()) NullVariant;
805 : }
806 0 : (*(ptr_NullVariant())) = aRhs;
807 0 : mType = TNullVariant;
808 0 : return (*(this));
809 : }
810 :
811 0 : auto ObjectOrNullVariant::operator=(const ObjectOrNullVariant& aRhs) -> ObjectOrNullVariant&
812 : {
813 0 : (aRhs).AssertSanity();
814 0 : Type t = (aRhs).type();
815 0 : switch (t) {
816 : case TObjectVariant:
817 : {
818 0 : if (MaybeDestroy(t)) {
819 0 : new (mozilla::KnownNotNull, ptr_ObjectVariant()) ObjectVariant;
820 : }
821 0 : (*(ptr_ObjectVariant())) = (aRhs).get_ObjectVariant();
822 0 : break;
823 : }
824 : case TNullVariant:
825 : {
826 0 : if (MaybeDestroy(t)) {
827 0 : new (mozilla::KnownNotNull, ptr_NullVariant()) NullVariant;
828 : }
829 0 : (*(ptr_NullVariant())) = (aRhs).get_NullVariant();
830 0 : break;
831 : }
832 : case T__None:
833 : {
834 0 : static_cast<void>(MaybeDestroy(t));
835 0 : break;
836 : }
837 : default:
838 : {
839 0 : mozilla::ipc::LogicError("unreached");
840 0 : break;
841 : }
842 : }
843 0 : mType = t;
844 0 : return (*(this));
845 : }
846 :
847 0 : auto ObjectOrNullVariant::operator==(const ObjectVariant& aRhs) const -> bool
848 : {
849 0 : return (get_ObjectVariant()) == (aRhs);
850 : }
851 :
852 0 : auto ObjectOrNullVariant::operator==(const NullVariant& aRhs) const -> bool
853 : {
854 0 : return (get_NullVariant()) == (aRhs);
855 : }
856 :
857 0 : auto ObjectOrNullVariant::operator==(const ObjectOrNullVariant& aRhs) const -> bool
858 : {
859 0 : if ((type()) != ((aRhs).type())) {
860 0 : return false;
861 : }
862 :
863 0 : switch (type()) {
864 : case TObjectVariant:
865 : {
866 0 : return (get_ObjectVariant()) == ((aRhs).get_ObjectVariant());
867 : }
868 : case TNullVariant:
869 : {
870 0 : return (get_NullVariant()) == ((aRhs).get_NullVariant());
871 : }
872 : default:
873 : {
874 0 : mozilla::ipc::LogicError("unreached");
875 0 : return false;
876 : }
877 : }
878 : }
879 :
880 0 : auto ObjectOrNullVariant::get(ObjectVariant* aOutValue) const -> void
881 : {
882 0 : (*(aOutValue)) = get_ObjectVariant();
883 0 : }
884 :
885 0 : auto ObjectOrNullVariant::get(NullVariant* aOutValue) const -> void
886 : {
887 0 : (*(aOutValue)) = get_NullVariant();
888 0 : }
889 :
890 : } // namespace jsipc
891 : } // namespace mozilla
892 :
893 : //-----------------------------------------------------------------------------
894 : // Method definitions for the IPDL type |union JSVariant|
895 : //
896 : namespace mozilla {
897 : namespace jsipc {
898 352 : auto JSVariant::MaybeDestroy(Type aNewType) -> bool
899 : {
900 352 : if ((mType) == (T__None)) {
901 176 : return true;
902 : }
903 176 : if ((mType) == (aNewType)) {
904 0 : return false;
905 : }
906 176 : switch (mType) {
907 : case TUndefinedVariant:
908 : {
909 0 : (ptr_UndefinedVariant())->~UndefinedVariant__tdef();
910 0 : break;
911 : }
912 : case TNullVariant:
913 : {
914 60 : (ptr_NullVariant())->~NullVariant__tdef();
915 60 : break;
916 : }
917 : case TObjectVariant:
918 : {
919 116 : (ptr_ObjectVariant())->~ObjectVariant__tdef();
920 116 : break;
921 : }
922 : case TSymbolVariant:
923 : {
924 0 : (ptr_SymbolVariant())->~SymbolVariant__tdef();
925 0 : break;
926 : }
927 : case TnsString:
928 : {
929 0 : (ptr_nsString())->~nsString__tdef();
930 0 : break;
931 : }
932 : case Tdouble:
933 : {
934 0 : (ptr_double())->~double__tdef();
935 0 : break;
936 : }
937 : case Tbool:
938 : {
939 0 : (ptr_bool())->~bool__tdef();
940 0 : break;
941 : }
942 : case TJSIID:
943 : {
944 0 : (ptr_JSIID())->~JSIID__tdef();
945 0 : break;
946 : }
947 : default:
948 : {
949 0 : mozilla::ipc::LogicError("not reached");
950 0 : break;
951 : }
952 : }
953 176 : return true;
954 : }
955 :
956 0 : MOZ_IMPLICIT JSVariant::JSVariant(const UndefinedVariant& aOther)
957 : {
958 0 : new (mozilla::KnownNotNull, ptr_UndefinedVariant()) UndefinedVariant(aOther);
959 0 : mType = TUndefinedVariant;
960 0 : }
961 :
962 0 : MOZ_IMPLICIT JSVariant::JSVariant(const NullVariant& aOther)
963 : {
964 0 : new (mozilla::KnownNotNull, ptr_NullVariant()) NullVariant(aOther);
965 0 : mType = TNullVariant;
966 0 : }
967 :
968 0 : MOZ_IMPLICIT JSVariant::JSVariant(const ObjectVariant& aOther)
969 : {
970 0 : new (mozilla::KnownNotNull, ptr_ObjectVariant()) ObjectVariant(aOther);
971 0 : mType = TObjectVariant;
972 0 : }
973 :
974 0 : MOZ_IMPLICIT JSVariant::JSVariant(const SymbolVariant& aOther)
975 : {
976 0 : new (mozilla::KnownNotNull, ptr_SymbolVariant()) SymbolVariant(aOther);
977 0 : mType = TSymbolVariant;
978 0 : }
979 :
980 0 : MOZ_IMPLICIT JSVariant::JSVariant(const nsString& aOther)
981 : {
982 0 : new (mozilla::KnownNotNull, ptr_nsString()) nsString(aOther);
983 0 : mType = TnsString;
984 0 : }
985 :
986 0 : MOZ_IMPLICIT JSVariant::JSVariant(const double& aOther)
987 : {
988 0 : new (mozilla::KnownNotNull, ptr_double()) double(aOther);
989 0 : mType = Tdouble;
990 0 : }
991 :
992 0 : MOZ_IMPLICIT JSVariant::JSVariant(const bool& aOther)
993 : {
994 0 : new (mozilla::KnownNotNull, ptr_bool()) bool(aOther);
995 0 : mType = Tbool;
996 0 : }
997 :
998 0 : MOZ_IMPLICIT JSVariant::JSVariant(const JSIID& aOther)
999 : {
1000 0 : new (mozilla::KnownNotNull, ptr_JSIID()) JSIID(aOther);
1001 0 : mType = TJSIID;
1002 0 : }
1003 :
1004 0 : MOZ_IMPLICIT JSVariant::JSVariant(const JSVariant& aOther)
1005 : {
1006 0 : (aOther).AssertSanity();
1007 0 : switch ((aOther).type()) {
1008 : case TUndefinedVariant:
1009 : {
1010 0 : new (mozilla::KnownNotNull, ptr_UndefinedVariant()) UndefinedVariant((aOther).get_UndefinedVariant());
1011 0 : break;
1012 : }
1013 : case TNullVariant:
1014 : {
1015 0 : new (mozilla::KnownNotNull, ptr_NullVariant()) NullVariant((aOther).get_NullVariant());
1016 0 : break;
1017 : }
1018 : case TObjectVariant:
1019 : {
1020 0 : new (mozilla::KnownNotNull, ptr_ObjectVariant()) ObjectVariant((aOther).get_ObjectVariant());
1021 0 : break;
1022 : }
1023 : case TSymbolVariant:
1024 : {
1025 0 : new (mozilla::KnownNotNull, ptr_SymbolVariant()) SymbolVariant((aOther).get_SymbolVariant());
1026 0 : break;
1027 : }
1028 : case TnsString:
1029 : {
1030 0 : new (mozilla::KnownNotNull, ptr_nsString()) nsString((aOther).get_nsString());
1031 0 : break;
1032 : }
1033 : case Tdouble:
1034 : {
1035 0 : new (mozilla::KnownNotNull, ptr_double()) double((aOther).get_double());
1036 0 : break;
1037 : }
1038 : case Tbool:
1039 : {
1040 0 : new (mozilla::KnownNotNull, ptr_bool()) bool((aOther).get_bool());
1041 0 : break;
1042 : }
1043 : case TJSIID:
1044 : {
1045 0 : new (mozilla::KnownNotNull, ptr_JSIID()) JSIID((aOther).get_JSIID());
1046 0 : break;
1047 : }
1048 : case T__None:
1049 : {
1050 0 : break;
1051 : }
1052 : default:
1053 : {
1054 0 : mozilla::ipc::LogicError("unreached");
1055 0 : return;
1056 : }
1057 : }
1058 0 : mType = (aOther).type();
1059 : }
1060 :
1061 352 : JSVariant::~JSVariant()
1062 : {
1063 176 : static_cast<void>(MaybeDestroy(T__None));
1064 176 : }
1065 :
1066 0 : auto JSVariant::operator=(const UndefinedVariant& aRhs) -> JSVariant&
1067 : {
1068 0 : if (MaybeDestroy(TUndefinedVariant)) {
1069 0 : new (mozilla::KnownNotNull, ptr_UndefinedVariant()) UndefinedVariant;
1070 : }
1071 0 : (*(ptr_UndefinedVariant())) = aRhs;
1072 0 : mType = TUndefinedVariant;
1073 0 : return (*(this));
1074 : }
1075 :
1076 30 : auto JSVariant::operator=(const NullVariant& aRhs) -> JSVariant&
1077 : {
1078 30 : if (MaybeDestroy(TNullVariant)) {
1079 30 : new (mozilla::KnownNotNull, ptr_NullVariant()) NullVariant;
1080 : }
1081 30 : (*(ptr_NullVariant())) = aRhs;
1082 30 : mType = TNullVariant;
1083 30 : return (*(this));
1084 : }
1085 :
1086 58 : auto JSVariant::operator=(const ObjectVariant& aRhs) -> JSVariant&
1087 : {
1088 58 : if (MaybeDestroy(TObjectVariant)) {
1089 58 : new (mozilla::KnownNotNull, ptr_ObjectVariant()) ObjectVariant;
1090 : }
1091 58 : (*(ptr_ObjectVariant())) = aRhs;
1092 58 : mType = TObjectVariant;
1093 58 : return (*(this));
1094 : }
1095 :
1096 0 : auto JSVariant::operator=(const SymbolVariant& aRhs) -> JSVariant&
1097 : {
1098 0 : if (MaybeDestroy(TSymbolVariant)) {
1099 0 : new (mozilla::KnownNotNull, ptr_SymbolVariant()) SymbolVariant;
1100 : }
1101 0 : (*(ptr_SymbolVariant())) = aRhs;
1102 0 : mType = TSymbolVariant;
1103 0 : return (*(this));
1104 : }
1105 :
1106 0 : auto JSVariant::operator=(const nsString& aRhs) -> JSVariant&
1107 : {
1108 0 : if (MaybeDestroy(TnsString)) {
1109 0 : new (mozilla::KnownNotNull, ptr_nsString()) nsString;
1110 : }
1111 0 : (*(ptr_nsString())) = aRhs;
1112 0 : mType = TnsString;
1113 0 : return (*(this));
1114 : }
1115 :
1116 0 : auto JSVariant::operator=(const double& aRhs) -> JSVariant&
1117 : {
1118 0 : if (MaybeDestroy(Tdouble)) {
1119 0 : new (mozilla::KnownNotNull, ptr_double()) double;
1120 : }
1121 0 : (*(ptr_double())) = aRhs;
1122 0 : mType = Tdouble;
1123 0 : return (*(this));
1124 : }
1125 :
1126 0 : auto JSVariant::operator=(const bool& aRhs) -> JSVariant&
1127 : {
1128 0 : if (MaybeDestroy(Tbool)) {
1129 0 : new (mozilla::KnownNotNull, ptr_bool()) bool;
1130 : }
1131 0 : (*(ptr_bool())) = aRhs;
1132 0 : mType = Tbool;
1133 0 : return (*(this));
1134 : }
1135 :
1136 0 : auto JSVariant::operator=(const JSIID& aRhs) -> JSVariant&
1137 : {
1138 0 : if (MaybeDestroy(TJSIID)) {
1139 0 : new (mozilla::KnownNotNull, ptr_JSIID()) JSIID;
1140 : }
1141 0 : (*(ptr_JSIID())) = aRhs;
1142 0 : mType = TJSIID;
1143 0 : return (*(this));
1144 : }
1145 :
1146 88 : auto JSVariant::operator=(const JSVariant& aRhs) -> JSVariant&
1147 : {
1148 88 : (aRhs).AssertSanity();
1149 88 : Type t = (aRhs).type();
1150 88 : switch (t) {
1151 : case TUndefinedVariant:
1152 : {
1153 0 : if (MaybeDestroy(t)) {
1154 0 : new (mozilla::KnownNotNull, ptr_UndefinedVariant()) UndefinedVariant;
1155 : }
1156 0 : (*(ptr_UndefinedVariant())) = (aRhs).get_UndefinedVariant();
1157 0 : break;
1158 : }
1159 : case TNullVariant:
1160 : {
1161 30 : if (MaybeDestroy(t)) {
1162 30 : new (mozilla::KnownNotNull, ptr_NullVariant()) NullVariant;
1163 : }
1164 30 : (*(ptr_NullVariant())) = (aRhs).get_NullVariant();
1165 30 : break;
1166 : }
1167 : case TObjectVariant:
1168 : {
1169 58 : if (MaybeDestroy(t)) {
1170 58 : new (mozilla::KnownNotNull, ptr_ObjectVariant()) ObjectVariant;
1171 : }
1172 58 : (*(ptr_ObjectVariant())) = (aRhs).get_ObjectVariant();
1173 58 : break;
1174 : }
1175 : case TSymbolVariant:
1176 : {
1177 0 : if (MaybeDestroy(t)) {
1178 0 : new (mozilla::KnownNotNull, ptr_SymbolVariant()) SymbolVariant;
1179 : }
1180 0 : (*(ptr_SymbolVariant())) = (aRhs).get_SymbolVariant();
1181 0 : break;
1182 : }
1183 : case TnsString:
1184 : {
1185 0 : if (MaybeDestroy(t)) {
1186 0 : new (mozilla::KnownNotNull, ptr_nsString()) nsString;
1187 : }
1188 0 : (*(ptr_nsString())) = (aRhs).get_nsString();
1189 0 : break;
1190 : }
1191 : case Tdouble:
1192 : {
1193 0 : if (MaybeDestroy(t)) {
1194 0 : new (mozilla::KnownNotNull, ptr_double()) double;
1195 : }
1196 0 : (*(ptr_double())) = (aRhs).get_double();
1197 0 : break;
1198 : }
1199 : case Tbool:
1200 : {
1201 0 : if (MaybeDestroy(t)) {
1202 0 : new (mozilla::KnownNotNull, ptr_bool()) bool;
1203 : }
1204 0 : (*(ptr_bool())) = (aRhs).get_bool();
1205 0 : break;
1206 : }
1207 : case TJSIID:
1208 : {
1209 0 : if (MaybeDestroy(t)) {
1210 0 : new (mozilla::KnownNotNull, ptr_JSIID()) JSIID;
1211 : }
1212 0 : (*(ptr_JSIID())) = (aRhs).get_JSIID();
1213 0 : break;
1214 : }
1215 : case T__None:
1216 : {
1217 0 : static_cast<void>(MaybeDestroy(t));
1218 0 : break;
1219 : }
1220 : default:
1221 : {
1222 0 : mozilla::ipc::LogicError("unreached");
1223 0 : break;
1224 : }
1225 : }
1226 88 : mType = t;
1227 88 : return (*(this));
1228 : }
1229 :
1230 0 : auto JSVariant::operator==(const UndefinedVariant& aRhs) const -> bool
1231 : {
1232 0 : return (get_UndefinedVariant()) == (aRhs);
1233 : }
1234 :
1235 0 : auto JSVariant::operator==(const NullVariant& aRhs) const -> bool
1236 : {
1237 0 : return (get_NullVariant()) == (aRhs);
1238 : }
1239 :
1240 0 : auto JSVariant::operator==(const ObjectVariant& aRhs) const -> bool
1241 : {
1242 0 : return (get_ObjectVariant()) == (aRhs);
1243 : }
1244 :
1245 0 : auto JSVariant::operator==(const SymbolVariant& aRhs) const -> bool
1246 : {
1247 0 : return (get_SymbolVariant()) == (aRhs);
1248 : }
1249 :
1250 0 : auto JSVariant::operator==(const nsString& aRhs) const -> bool
1251 : {
1252 0 : return (get_nsString()) == (aRhs);
1253 : }
1254 :
1255 0 : auto JSVariant::operator==(const double& aRhs) const -> bool
1256 : {
1257 0 : return (get_double()) == (aRhs);
1258 : }
1259 :
1260 0 : auto JSVariant::operator==(const bool& aRhs) const -> bool
1261 : {
1262 0 : return (get_bool()) == (aRhs);
1263 : }
1264 :
1265 0 : auto JSVariant::operator==(const JSIID& aRhs) const -> bool
1266 : {
1267 0 : return (get_JSIID()) == (aRhs);
1268 : }
1269 :
1270 0 : auto JSVariant::operator==(const JSVariant& aRhs) const -> bool
1271 : {
1272 0 : if ((type()) != ((aRhs).type())) {
1273 0 : return false;
1274 : }
1275 :
1276 0 : switch (type()) {
1277 : case TUndefinedVariant:
1278 : {
1279 0 : return (get_UndefinedVariant()) == ((aRhs).get_UndefinedVariant());
1280 : }
1281 : case TNullVariant:
1282 : {
1283 0 : return (get_NullVariant()) == ((aRhs).get_NullVariant());
1284 : }
1285 : case TObjectVariant:
1286 : {
1287 0 : return (get_ObjectVariant()) == ((aRhs).get_ObjectVariant());
1288 : }
1289 : case TSymbolVariant:
1290 : {
1291 0 : return (get_SymbolVariant()) == ((aRhs).get_SymbolVariant());
1292 : }
1293 : case TnsString:
1294 : {
1295 0 : return (get_nsString()) == ((aRhs).get_nsString());
1296 : }
1297 : case Tdouble:
1298 : {
1299 0 : return (get_double()) == ((aRhs).get_double());
1300 : }
1301 : case Tbool:
1302 : {
1303 0 : return (get_bool()) == ((aRhs).get_bool());
1304 : }
1305 : case TJSIID:
1306 : {
1307 0 : return (get_JSIID()) == ((aRhs).get_JSIID());
1308 : }
1309 : default:
1310 : {
1311 0 : mozilla::ipc::LogicError("unreached");
1312 0 : return false;
1313 : }
1314 : }
1315 : }
1316 :
1317 0 : auto JSVariant::get(UndefinedVariant* aOutValue) const -> void
1318 : {
1319 0 : (*(aOutValue)) = get_UndefinedVariant();
1320 0 : }
1321 :
1322 0 : auto JSVariant::get(NullVariant* aOutValue) const -> void
1323 : {
1324 0 : (*(aOutValue)) = get_NullVariant();
1325 0 : }
1326 :
1327 0 : auto JSVariant::get(ObjectVariant* aOutValue) const -> void
1328 : {
1329 0 : (*(aOutValue)) = get_ObjectVariant();
1330 0 : }
1331 :
1332 0 : auto JSVariant::get(SymbolVariant* aOutValue) const -> void
1333 : {
1334 0 : (*(aOutValue)) = get_SymbolVariant();
1335 0 : }
1336 :
1337 0 : auto JSVariant::get(nsString* aOutValue) const -> void
1338 : {
1339 0 : (*(aOutValue)) = get_nsString();
1340 0 : }
1341 :
1342 0 : auto JSVariant::get(double* aOutValue) const -> void
1343 : {
1344 0 : (*(aOutValue)) = get_double();
1345 0 : }
1346 :
1347 0 : auto JSVariant::get(bool* aOutValue) const -> void
1348 : {
1349 0 : (*(aOutValue)) = get_bool();
1350 0 : }
1351 :
1352 0 : auto JSVariant::get(JSIID* aOutValue) const -> void
1353 : {
1354 0 : (*(aOutValue)) = get_JSIID();
1355 0 : }
1356 :
1357 : } // namespace jsipc
1358 : } // namespace mozilla
1359 :
1360 : //-----------------------------------------------------------------------------
1361 : // Method definitions for the IPDL type |union JSIDVariant|
1362 : //
1363 : namespace mozilla {
1364 : namespace jsipc {
1365 0 : auto JSIDVariant::MaybeDestroy(Type aNewType) -> bool
1366 : {
1367 0 : if ((mType) == (T__None)) {
1368 0 : return true;
1369 : }
1370 0 : if ((mType) == (aNewType)) {
1371 0 : return false;
1372 : }
1373 0 : switch (mType) {
1374 : case TSymbolVariant:
1375 : {
1376 0 : (ptr_SymbolVariant())->~SymbolVariant__tdef();
1377 0 : break;
1378 : }
1379 : case TnsString:
1380 : {
1381 0 : (ptr_nsString())->~nsString__tdef();
1382 0 : break;
1383 : }
1384 : case Tint32_t:
1385 : {
1386 0 : (ptr_int32_t())->~int32_t__tdef();
1387 0 : break;
1388 : }
1389 : default:
1390 : {
1391 0 : mozilla::ipc::LogicError("not reached");
1392 0 : break;
1393 : }
1394 : }
1395 0 : return true;
1396 : }
1397 :
1398 0 : MOZ_IMPLICIT JSIDVariant::JSIDVariant(const SymbolVariant& aOther)
1399 : {
1400 0 : new (mozilla::KnownNotNull, ptr_SymbolVariant()) SymbolVariant(aOther);
1401 0 : mType = TSymbolVariant;
1402 0 : }
1403 :
1404 0 : MOZ_IMPLICIT JSIDVariant::JSIDVariant(const nsString& aOther)
1405 : {
1406 0 : new (mozilla::KnownNotNull, ptr_nsString()) nsString(aOther);
1407 0 : mType = TnsString;
1408 0 : }
1409 :
1410 0 : MOZ_IMPLICIT JSIDVariant::JSIDVariant(const int32_t& aOther)
1411 : {
1412 0 : new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(aOther);
1413 0 : mType = Tint32_t;
1414 0 : }
1415 :
1416 0 : MOZ_IMPLICIT JSIDVariant::JSIDVariant(const JSIDVariant& aOther)
1417 : {
1418 0 : (aOther).AssertSanity();
1419 0 : switch ((aOther).type()) {
1420 : case TSymbolVariant:
1421 : {
1422 0 : new (mozilla::KnownNotNull, ptr_SymbolVariant()) SymbolVariant((aOther).get_SymbolVariant());
1423 0 : break;
1424 : }
1425 : case TnsString:
1426 : {
1427 0 : new (mozilla::KnownNotNull, ptr_nsString()) nsString((aOther).get_nsString());
1428 0 : break;
1429 : }
1430 : case Tint32_t:
1431 : {
1432 0 : new (mozilla::KnownNotNull, ptr_int32_t()) int32_t((aOther).get_int32_t());
1433 0 : break;
1434 : }
1435 : case T__None:
1436 : {
1437 0 : break;
1438 : }
1439 : default:
1440 : {
1441 0 : mozilla::ipc::LogicError("unreached");
1442 0 : return;
1443 : }
1444 : }
1445 0 : mType = (aOther).type();
1446 : }
1447 :
1448 0 : JSIDVariant::~JSIDVariant()
1449 : {
1450 0 : static_cast<void>(MaybeDestroy(T__None));
1451 0 : }
1452 :
1453 0 : auto JSIDVariant::operator=(const SymbolVariant& aRhs) -> JSIDVariant&
1454 : {
1455 0 : if (MaybeDestroy(TSymbolVariant)) {
1456 0 : new (mozilla::KnownNotNull, ptr_SymbolVariant()) SymbolVariant;
1457 : }
1458 0 : (*(ptr_SymbolVariant())) = aRhs;
1459 0 : mType = TSymbolVariant;
1460 0 : return (*(this));
1461 : }
1462 :
1463 0 : auto JSIDVariant::operator=(const nsString& aRhs) -> JSIDVariant&
1464 : {
1465 0 : if (MaybeDestroy(TnsString)) {
1466 0 : new (mozilla::KnownNotNull, ptr_nsString()) nsString;
1467 : }
1468 0 : (*(ptr_nsString())) = aRhs;
1469 0 : mType = TnsString;
1470 0 : return (*(this));
1471 : }
1472 :
1473 0 : auto JSIDVariant::operator=(const int32_t& aRhs) -> JSIDVariant&
1474 : {
1475 0 : if (MaybeDestroy(Tint32_t)) {
1476 0 : new (mozilla::KnownNotNull, ptr_int32_t()) int32_t;
1477 : }
1478 0 : (*(ptr_int32_t())) = aRhs;
1479 0 : mType = Tint32_t;
1480 0 : return (*(this));
1481 : }
1482 :
1483 0 : auto JSIDVariant::operator=(const JSIDVariant& aRhs) -> JSIDVariant&
1484 : {
1485 0 : (aRhs).AssertSanity();
1486 0 : Type t = (aRhs).type();
1487 0 : switch (t) {
1488 : case TSymbolVariant:
1489 : {
1490 0 : if (MaybeDestroy(t)) {
1491 0 : new (mozilla::KnownNotNull, ptr_SymbolVariant()) SymbolVariant;
1492 : }
1493 0 : (*(ptr_SymbolVariant())) = (aRhs).get_SymbolVariant();
1494 0 : break;
1495 : }
1496 : case TnsString:
1497 : {
1498 0 : if (MaybeDestroy(t)) {
1499 0 : new (mozilla::KnownNotNull, ptr_nsString()) nsString;
1500 : }
1501 0 : (*(ptr_nsString())) = (aRhs).get_nsString();
1502 0 : break;
1503 : }
1504 : case Tint32_t:
1505 : {
1506 0 : if (MaybeDestroy(t)) {
1507 0 : new (mozilla::KnownNotNull, ptr_int32_t()) int32_t;
1508 : }
1509 0 : (*(ptr_int32_t())) = (aRhs).get_int32_t();
1510 0 : break;
1511 : }
1512 : case T__None:
1513 : {
1514 0 : static_cast<void>(MaybeDestroy(t));
1515 0 : break;
1516 : }
1517 : default:
1518 : {
1519 0 : mozilla::ipc::LogicError("unreached");
1520 0 : break;
1521 : }
1522 : }
1523 0 : mType = t;
1524 0 : return (*(this));
1525 : }
1526 :
1527 0 : auto JSIDVariant::operator==(const SymbolVariant& aRhs) const -> bool
1528 : {
1529 0 : return (get_SymbolVariant()) == (aRhs);
1530 : }
1531 :
1532 0 : auto JSIDVariant::operator==(const nsString& aRhs) const -> bool
1533 : {
1534 0 : return (get_nsString()) == (aRhs);
1535 : }
1536 :
1537 0 : auto JSIDVariant::operator==(const int32_t& aRhs) const -> bool
1538 : {
1539 0 : return (get_int32_t()) == (aRhs);
1540 : }
1541 :
1542 0 : auto JSIDVariant::operator==(const JSIDVariant& aRhs) const -> bool
1543 : {
1544 0 : if ((type()) != ((aRhs).type())) {
1545 0 : return false;
1546 : }
1547 :
1548 0 : switch (type()) {
1549 : case TSymbolVariant:
1550 : {
1551 0 : return (get_SymbolVariant()) == ((aRhs).get_SymbolVariant());
1552 : }
1553 : case TnsString:
1554 : {
1555 0 : return (get_nsString()) == ((aRhs).get_nsString());
1556 : }
1557 : case Tint32_t:
1558 : {
1559 0 : return (get_int32_t()) == ((aRhs).get_int32_t());
1560 : }
1561 : default:
1562 : {
1563 0 : mozilla::ipc::LogicError("unreached");
1564 0 : return false;
1565 : }
1566 : }
1567 : }
1568 :
1569 0 : auto JSIDVariant::get(SymbolVariant* aOutValue) const -> void
1570 : {
1571 0 : (*(aOutValue)) = get_SymbolVariant();
1572 0 : }
1573 :
1574 0 : auto JSIDVariant::get(nsString* aOutValue) const -> void
1575 : {
1576 0 : (*(aOutValue)) = get_nsString();
1577 0 : }
1578 :
1579 0 : auto JSIDVariant::get(int32_t* aOutValue) const -> void
1580 : {
1581 0 : (*(aOutValue)) = get_int32_t();
1582 0 : }
1583 :
1584 : } // namespace jsipc
1585 : } // namespace mozilla
1586 :
1587 : //-----------------------------------------------------------------------------
1588 : // Method definitions for the IPDL type |struct ReturnSuccess|
1589 : //
1590 : namespace mozilla {
1591 : namespace jsipc {
1592 0 : ReturnSuccess::~ReturnSuccess()
1593 : {
1594 0 : }
1595 :
1596 0 : auto ReturnSuccess::operator==(const ReturnSuccess& _o) const -> bool
1597 : {
1598 0 : return true;
1599 : }
1600 :
1601 0 : auto ReturnSuccess::operator!=(const ReturnSuccess& _o) const -> bool
1602 : {
1603 0 : return (!(operator==(_o)));
1604 : }
1605 :
1606 0 : auto ReturnSuccess::Init() -> void
1607 : {
1608 0 : }
1609 :
1610 0 : auto ReturnSuccess::Assign() -> void
1611 : {
1612 0 : }
1613 :
1614 : } // namespace jsipc
1615 : } // namespace mozilla
1616 :
1617 : //-----------------------------------------------------------------------------
1618 : // Method definitions for the IPDL type |struct ReturnStopIteration|
1619 : //
1620 : namespace mozilla {
1621 : namespace jsipc {
1622 0 : ReturnStopIteration::~ReturnStopIteration()
1623 : {
1624 0 : }
1625 :
1626 0 : auto ReturnStopIteration::operator==(const ReturnStopIteration& _o) const -> bool
1627 : {
1628 0 : return true;
1629 : }
1630 :
1631 0 : auto ReturnStopIteration::operator!=(const ReturnStopIteration& _o) const -> bool
1632 : {
1633 0 : return (!(operator==(_o)));
1634 : }
1635 :
1636 0 : auto ReturnStopIteration::Init() -> void
1637 : {
1638 0 : }
1639 :
1640 0 : auto ReturnStopIteration::Assign() -> void
1641 : {
1642 0 : }
1643 :
1644 : } // namespace jsipc
1645 : } // namespace mozilla
1646 :
1647 : //-----------------------------------------------------------------------------
1648 : // Method definitions for the IPDL type |struct ReturnDeadCPOW|
1649 : //
1650 : namespace mozilla {
1651 : namespace jsipc {
1652 0 : ReturnDeadCPOW::~ReturnDeadCPOW()
1653 : {
1654 0 : }
1655 :
1656 0 : auto ReturnDeadCPOW::operator==(const ReturnDeadCPOW& _o) const -> bool
1657 : {
1658 0 : return true;
1659 : }
1660 :
1661 0 : auto ReturnDeadCPOW::operator!=(const ReturnDeadCPOW& _o) const -> bool
1662 : {
1663 0 : return (!(operator==(_o)));
1664 : }
1665 :
1666 0 : auto ReturnDeadCPOW::Init() -> void
1667 : {
1668 0 : }
1669 :
1670 0 : auto ReturnDeadCPOW::Assign() -> void
1671 : {
1672 0 : }
1673 :
1674 : } // namespace jsipc
1675 : } // namespace mozilla
1676 :
1677 : //-----------------------------------------------------------------------------
1678 : // Method definitions for the IPDL type |struct ReturnException|
1679 : //
1680 : namespace mozilla {
1681 : namespace jsipc {
1682 0 : MOZ_IMPLICIT ReturnException::ReturnException()
1683 : {
1684 0 : Init();
1685 0 : }
1686 :
1687 0 : ReturnException::~ReturnException()
1688 : {
1689 0 : }
1690 :
1691 0 : auto ReturnException::operator==(const ReturnException& _o) const -> bool
1692 : {
1693 0 : if ((!((exn()) == ((_o).exn())))) {
1694 0 : return false;
1695 : }
1696 0 : return true;
1697 : }
1698 :
1699 0 : auto ReturnException::operator!=(const ReturnException& _o) const -> bool
1700 : {
1701 0 : return (!(operator==(_o)));
1702 : }
1703 :
1704 0 : auto ReturnException::Init() -> void
1705 : {
1706 0 : }
1707 :
1708 0 : auto ReturnException::Assign(const JSVariant& _exn) -> void
1709 : {
1710 0 : exn_ = _exn;
1711 0 : }
1712 :
1713 : } // namespace jsipc
1714 : } // namespace mozilla
1715 :
1716 : //-----------------------------------------------------------------------------
1717 : // Method definitions for the IPDL type |struct ReturnObjectOpResult|
1718 : //
1719 : namespace mozilla {
1720 : namespace jsipc {
1721 0 : MOZ_IMPLICIT ReturnObjectOpResult::ReturnObjectOpResult() :
1722 0 : code_()
1723 : {
1724 0 : Init();
1725 0 : }
1726 :
1727 0 : ReturnObjectOpResult::~ReturnObjectOpResult()
1728 : {
1729 0 : }
1730 :
1731 0 : auto ReturnObjectOpResult::operator==(const ReturnObjectOpResult& _o) const -> bool
1732 : {
1733 0 : if ((!((code()) == ((_o).code())))) {
1734 0 : return false;
1735 : }
1736 0 : return true;
1737 : }
1738 :
1739 0 : auto ReturnObjectOpResult::operator!=(const ReturnObjectOpResult& _o) const -> bool
1740 : {
1741 0 : return (!(operator==(_o)));
1742 : }
1743 :
1744 0 : auto ReturnObjectOpResult::Init() -> void
1745 : {
1746 0 : }
1747 :
1748 0 : auto ReturnObjectOpResult::Assign(const uint32_t& _code) -> void
1749 : {
1750 0 : code_ = _code;
1751 0 : }
1752 :
1753 : } // namespace jsipc
1754 : } // namespace mozilla
1755 :
1756 : //-----------------------------------------------------------------------------
1757 : // Method definitions for the IPDL type |union ReturnStatus|
1758 : //
1759 : namespace mozilla {
1760 : namespace jsipc {
1761 0 : auto ReturnStatus::MaybeDestroy(Type aNewType) -> bool
1762 : {
1763 0 : if ((mType) == (T__None)) {
1764 0 : return true;
1765 : }
1766 0 : if ((mType) == (aNewType)) {
1767 0 : return false;
1768 : }
1769 0 : switch (mType) {
1770 : case TReturnSuccess:
1771 : {
1772 0 : (ptr_ReturnSuccess())->~ReturnSuccess__tdef();
1773 0 : break;
1774 : }
1775 : case TReturnStopIteration:
1776 : {
1777 0 : (ptr_ReturnStopIteration())->~ReturnStopIteration__tdef();
1778 0 : break;
1779 : }
1780 : case TReturnDeadCPOW:
1781 : {
1782 0 : (ptr_ReturnDeadCPOW())->~ReturnDeadCPOW__tdef();
1783 0 : break;
1784 : }
1785 : case TReturnException:
1786 : {
1787 0 : (ptr_ReturnException())->~ReturnException__tdef();
1788 0 : break;
1789 : }
1790 : case TReturnObjectOpResult:
1791 : {
1792 0 : (ptr_ReturnObjectOpResult())->~ReturnObjectOpResult__tdef();
1793 0 : break;
1794 : }
1795 : default:
1796 : {
1797 0 : mozilla::ipc::LogicError("not reached");
1798 0 : break;
1799 : }
1800 : }
1801 0 : return true;
1802 : }
1803 :
1804 0 : MOZ_IMPLICIT ReturnStatus::ReturnStatus(const ReturnSuccess& aOther)
1805 : {
1806 0 : new (mozilla::KnownNotNull, ptr_ReturnSuccess()) ReturnSuccess(aOther);
1807 0 : mType = TReturnSuccess;
1808 0 : }
1809 :
1810 0 : MOZ_IMPLICIT ReturnStatus::ReturnStatus(const ReturnStopIteration& aOther)
1811 : {
1812 0 : new (mozilla::KnownNotNull, ptr_ReturnStopIteration()) ReturnStopIteration(aOther);
1813 0 : mType = TReturnStopIteration;
1814 0 : }
1815 :
1816 0 : MOZ_IMPLICIT ReturnStatus::ReturnStatus(const ReturnDeadCPOW& aOther)
1817 : {
1818 0 : new (mozilla::KnownNotNull, ptr_ReturnDeadCPOW()) ReturnDeadCPOW(aOther);
1819 0 : mType = TReturnDeadCPOW;
1820 0 : }
1821 :
1822 0 : MOZ_IMPLICIT ReturnStatus::ReturnStatus(const ReturnException& aOther)
1823 : {
1824 0 : new (mozilla::KnownNotNull, ptr_ReturnException()) ReturnException(aOther);
1825 0 : mType = TReturnException;
1826 0 : }
1827 :
1828 0 : MOZ_IMPLICIT ReturnStatus::ReturnStatus(const ReturnObjectOpResult& aOther)
1829 : {
1830 0 : new (mozilla::KnownNotNull, ptr_ReturnObjectOpResult()) ReturnObjectOpResult(aOther);
1831 0 : mType = TReturnObjectOpResult;
1832 0 : }
1833 :
1834 0 : MOZ_IMPLICIT ReturnStatus::ReturnStatus(const ReturnStatus& aOther)
1835 : {
1836 0 : (aOther).AssertSanity();
1837 0 : switch ((aOther).type()) {
1838 : case TReturnSuccess:
1839 : {
1840 0 : new (mozilla::KnownNotNull, ptr_ReturnSuccess()) ReturnSuccess((aOther).get_ReturnSuccess());
1841 0 : break;
1842 : }
1843 : case TReturnStopIteration:
1844 : {
1845 0 : new (mozilla::KnownNotNull, ptr_ReturnStopIteration()) ReturnStopIteration((aOther).get_ReturnStopIteration());
1846 0 : break;
1847 : }
1848 : case TReturnDeadCPOW:
1849 : {
1850 0 : new (mozilla::KnownNotNull, ptr_ReturnDeadCPOW()) ReturnDeadCPOW((aOther).get_ReturnDeadCPOW());
1851 0 : break;
1852 : }
1853 : case TReturnException:
1854 : {
1855 0 : new (mozilla::KnownNotNull, ptr_ReturnException()) ReturnException((aOther).get_ReturnException());
1856 0 : break;
1857 : }
1858 : case TReturnObjectOpResult:
1859 : {
1860 0 : new (mozilla::KnownNotNull, ptr_ReturnObjectOpResult()) ReturnObjectOpResult((aOther).get_ReturnObjectOpResult());
1861 0 : break;
1862 : }
1863 : case T__None:
1864 : {
1865 0 : break;
1866 : }
1867 : default:
1868 : {
1869 0 : mozilla::ipc::LogicError("unreached");
1870 0 : return;
1871 : }
1872 : }
1873 0 : mType = (aOther).type();
1874 : }
1875 :
1876 0 : ReturnStatus::~ReturnStatus()
1877 : {
1878 0 : static_cast<void>(MaybeDestroy(T__None));
1879 0 : }
1880 :
1881 0 : auto ReturnStatus::operator=(const ReturnSuccess& aRhs) -> ReturnStatus&
1882 : {
1883 0 : if (MaybeDestroy(TReturnSuccess)) {
1884 0 : new (mozilla::KnownNotNull, ptr_ReturnSuccess()) ReturnSuccess;
1885 : }
1886 0 : (*(ptr_ReturnSuccess())) = aRhs;
1887 0 : mType = TReturnSuccess;
1888 0 : return (*(this));
1889 : }
1890 :
1891 0 : auto ReturnStatus::operator=(const ReturnStopIteration& aRhs) -> ReturnStatus&
1892 : {
1893 0 : if (MaybeDestroy(TReturnStopIteration)) {
1894 0 : new (mozilla::KnownNotNull, ptr_ReturnStopIteration()) ReturnStopIteration;
1895 : }
1896 0 : (*(ptr_ReturnStopIteration())) = aRhs;
1897 0 : mType = TReturnStopIteration;
1898 0 : return (*(this));
1899 : }
1900 :
1901 0 : auto ReturnStatus::operator=(const ReturnDeadCPOW& aRhs) -> ReturnStatus&
1902 : {
1903 0 : if (MaybeDestroy(TReturnDeadCPOW)) {
1904 0 : new (mozilla::KnownNotNull, ptr_ReturnDeadCPOW()) ReturnDeadCPOW;
1905 : }
1906 0 : (*(ptr_ReturnDeadCPOW())) = aRhs;
1907 0 : mType = TReturnDeadCPOW;
1908 0 : return (*(this));
1909 : }
1910 :
1911 0 : auto ReturnStatus::operator=(const ReturnException& aRhs) -> ReturnStatus&
1912 : {
1913 0 : if (MaybeDestroy(TReturnException)) {
1914 0 : new (mozilla::KnownNotNull, ptr_ReturnException()) ReturnException;
1915 : }
1916 0 : (*(ptr_ReturnException())) = aRhs;
1917 0 : mType = TReturnException;
1918 0 : return (*(this));
1919 : }
1920 :
1921 0 : auto ReturnStatus::operator=(const ReturnObjectOpResult& aRhs) -> ReturnStatus&
1922 : {
1923 0 : if (MaybeDestroy(TReturnObjectOpResult)) {
1924 0 : new (mozilla::KnownNotNull, ptr_ReturnObjectOpResult()) ReturnObjectOpResult;
1925 : }
1926 0 : (*(ptr_ReturnObjectOpResult())) = aRhs;
1927 0 : mType = TReturnObjectOpResult;
1928 0 : return (*(this));
1929 : }
1930 :
1931 0 : auto ReturnStatus::operator=(const ReturnStatus& aRhs) -> ReturnStatus&
1932 : {
1933 0 : (aRhs).AssertSanity();
1934 0 : Type t = (aRhs).type();
1935 0 : switch (t) {
1936 : case TReturnSuccess:
1937 : {
1938 0 : if (MaybeDestroy(t)) {
1939 0 : new (mozilla::KnownNotNull, ptr_ReturnSuccess()) ReturnSuccess;
1940 : }
1941 0 : (*(ptr_ReturnSuccess())) = (aRhs).get_ReturnSuccess();
1942 0 : break;
1943 : }
1944 : case TReturnStopIteration:
1945 : {
1946 0 : if (MaybeDestroy(t)) {
1947 0 : new (mozilla::KnownNotNull, ptr_ReturnStopIteration()) ReturnStopIteration;
1948 : }
1949 0 : (*(ptr_ReturnStopIteration())) = (aRhs).get_ReturnStopIteration();
1950 0 : break;
1951 : }
1952 : case TReturnDeadCPOW:
1953 : {
1954 0 : if (MaybeDestroy(t)) {
1955 0 : new (mozilla::KnownNotNull, ptr_ReturnDeadCPOW()) ReturnDeadCPOW;
1956 : }
1957 0 : (*(ptr_ReturnDeadCPOW())) = (aRhs).get_ReturnDeadCPOW();
1958 0 : break;
1959 : }
1960 : case TReturnException:
1961 : {
1962 0 : if (MaybeDestroy(t)) {
1963 0 : new (mozilla::KnownNotNull, ptr_ReturnException()) ReturnException;
1964 : }
1965 0 : (*(ptr_ReturnException())) = (aRhs).get_ReturnException();
1966 0 : break;
1967 : }
1968 : case TReturnObjectOpResult:
1969 : {
1970 0 : if (MaybeDestroy(t)) {
1971 0 : new (mozilla::KnownNotNull, ptr_ReturnObjectOpResult()) ReturnObjectOpResult;
1972 : }
1973 0 : (*(ptr_ReturnObjectOpResult())) = (aRhs).get_ReturnObjectOpResult();
1974 0 : break;
1975 : }
1976 : case T__None:
1977 : {
1978 0 : static_cast<void>(MaybeDestroy(t));
1979 0 : break;
1980 : }
1981 : default:
1982 : {
1983 0 : mozilla::ipc::LogicError("unreached");
1984 0 : break;
1985 : }
1986 : }
1987 0 : mType = t;
1988 0 : return (*(this));
1989 : }
1990 :
1991 0 : auto ReturnStatus::operator==(const ReturnSuccess& aRhs) const -> bool
1992 : {
1993 0 : return (get_ReturnSuccess()) == (aRhs);
1994 : }
1995 :
1996 0 : auto ReturnStatus::operator==(const ReturnStopIteration& aRhs) const -> bool
1997 : {
1998 0 : return (get_ReturnStopIteration()) == (aRhs);
1999 : }
2000 :
2001 0 : auto ReturnStatus::operator==(const ReturnDeadCPOW& aRhs) const -> bool
2002 : {
2003 0 : return (get_ReturnDeadCPOW()) == (aRhs);
2004 : }
2005 :
2006 0 : auto ReturnStatus::operator==(const ReturnException& aRhs) const -> bool
2007 : {
2008 0 : return (get_ReturnException()) == (aRhs);
2009 : }
2010 :
2011 0 : auto ReturnStatus::operator==(const ReturnObjectOpResult& aRhs) const -> bool
2012 : {
2013 0 : return (get_ReturnObjectOpResult()) == (aRhs);
2014 : }
2015 :
2016 0 : auto ReturnStatus::operator==(const ReturnStatus& aRhs) const -> bool
2017 : {
2018 0 : if ((type()) != ((aRhs).type())) {
2019 0 : return false;
2020 : }
2021 :
2022 0 : switch (type()) {
2023 : case TReturnSuccess:
2024 : {
2025 0 : return (get_ReturnSuccess()) == ((aRhs).get_ReturnSuccess());
2026 : }
2027 : case TReturnStopIteration:
2028 : {
2029 0 : return (get_ReturnStopIteration()) == ((aRhs).get_ReturnStopIteration());
2030 : }
2031 : case TReturnDeadCPOW:
2032 : {
2033 0 : return (get_ReturnDeadCPOW()) == ((aRhs).get_ReturnDeadCPOW());
2034 : }
2035 : case TReturnException:
2036 : {
2037 0 : return (get_ReturnException()) == ((aRhs).get_ReturnException());
2038 : }
2039 : case TReturnObjectOpResult:
2040 : {
2041 0 : return (get_ReturnObjectOpResult()) == ((aRhs).get_ReturnObjectOpResult());
2042 : }
2043 : default:
2044 : {
2045 0 : mozilla::ipc::LogicError("unreached");
2046 0 : return false;
2047 : }
2048 : }
2049 : }
2050 :
2051 0 : auto ReturnStatus::get(ReturnSuccess* aOutValue) const -> void
2052 : {
2053 0 : (*(aOutValue)) = get_ReturnSuccess();
2054 0 : }
2055 :
2056 0 : auto ReturnStatus::get(ReturnStopIteration* aOutValue) const -> void
2057 : {
2058 0 : (*(aOutValue)) = get_ReturnStopIteration();
2059 0 : }
2060 :
2061 0 : auto ReturnStatus::get(ReturnDeadCPOW* aOutValue) const -> void
2062 : {
2063 0 : (*(aOutValue)) = get_ReturnDeadCPOW();
2064 0 : }
2065 :
2066 0 : auto ReturnStatus::get(ReturnException* aOutValue) const -> void
2067 : {
2068 0 : (*(aOutValue)) = get_ReturnException();
2069 0 : }
2070 :
2071 0 : auto ReturnStatus::get(ReturnObjectOpResult* aOutValue) const -> void
2072 : {
2073 0 : (*(aOutValue)) = get_ReturnObjectOpResult();
2074 0 : }
2075 :
2076 : } // namespace jsipc
2077 : } // namespace mozilla
2078 :
2079 : //-----------------------------------------------------------------------------
2080 : // Method definitions for the IPDL type |union JSParam|
2081 : //
2082 : namespace mozilla {
2083 : namespace jsipc {
2084 0 : auto JSParam::MaybeDestroy(Type aNewType) -> bool
2085 : {
2086 0 : if ((mType) == (T__None)) {
2087 0 : return true;
2088 : }
2089 0 : if ((mType) == (aNewType)) {
2090 0 : return false;
2091 : }
2092 0 : switch (mType) {
2093 : case Tvoid_t:
2094 : {
2095 0 : (ptr_void_t())->~void_t__tdef();
2096 0 : break;
2097 : }
2098 : case TJSVariant:
2099 : {
2100 0 : (ptr_JSVariant())->~JSVariant__tdef();
2101 0 : break;
2102 : }
2103 : default:
2104 : {
2105 0 : mozilla::ipc::LogicError("not reached");
2106 0 : break;
2107 : }
2108 : }
2109 0 : return true;
2110 : }
2111 :
2112 0 : MOZ_IMPLICIT JSParam::JSParam(const void_t& aOther)
2113 : {
2114 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
2115 0 : mType = Tvoid_t;
2116 0 : }
2117 :
2118 0 : MOZ_IMPLICIT JSParam::JSParam(const JSVariant& aOther)
2119 : {
2120 0 : new (mozilla::KnownNotNull, ptr_JSVariant()) JSVariant(aOther);
2121 0 : mType = TJSVariant;
2122 0 : }
2123 :
2124 0 : MOZ_IMPLICIT JSParam::JSParam(const JSParam& aOther)
2125 : {
2126 0 : (aOther).AssertSanity();
2127 0 : switch ((aOther).type()) {
2128 : case Tvoid_t:
2129 : {
2130 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
2131 0 : break;
2132 : }
2133 : case TJSVariant:
2134 : {
2135 0 : new (mozilla::KnownNotNull, ptr_JSVariant()) JSVariant((aOther).get_JSVariant());
2136 0 : break;
2137 : }
2138 : case T__None:
2139 : {
2140 0 : break;
2141 : }
2142 : default:
2143 : {
2144 0 : mozilla::ipc::LogicError("unreached");
2145 0 : return;
2146 : }
2147 : }
2148 0 : mType = (aOther).type();
2149 : }
2150 :
2151 0 : JSParam::~JSParam()
2152 : {
2153 0 : static_cast<void>(MaybeDestroy(T__None));
2154 0 : }
2155 :
2156 0 : auto JSParam::operator=(const void_t& aRhs) -> JSParam&
2157 : {
2158 0 : if (MaybeDestroy(Tvoid_t)) {
2159 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
2160 : }
2161 0 : (*(ptr_void_t())) = aRhs;
2162 0 : mType = Tvoid_t;
2163 0 : return (*(this));
2164 : }
2165 :
2166 0 : auto JSParam::operator=(const JSVariant& aRhs) -> JSParam&
2167 : {
2168 0 : if (MaybeDestroy(TJSVariant)) {
2169 0 : new (mozilla::KnownNotNull, ptr_JSVariant()) JSVariant;
2170 : }
2171 0 : (*(ptr_JSVariant())) = aRhs;
2172 0 : mType = TJSVariant;
2173 0 : return (*(this));
2174 : }
2175 :
2176 0 : auto JSParam::operator=(const JSParam& aRhs) -> JSParam&
2177 : {
2178 0 : (aRhs).AssertSanity();
2179 0 : Type t = (aRhs).type();
2180 0 : switch (t) {
2181 : case Tvoid_t:
2182 : {
2183 0 : if (MaybeDestroy(t)) {
2184 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
2185 : }
2186 0 : (*(ptr_void_t())) = (aRhs).get_void_t();
2187 0 : break;
2188 : }
2189 : case TJSVariant:
2190 : {
2191 0 : if (MaybeDestroy(t)) {
2192 0 : new (mozilla::KnownNotNull, ptr_JSVariant()) JSVariant;
2193 : }
2194 0 : (*(ptr_JSVariant())) = (aRhs).get_JSVariant();
2195 0 : break;
2196 : }
2197 : case T__None:
2198 : {
2199 0 : static_cast<void>(MaybeDestroy(t));
2200 0 : break;
2201 : }
2202 : default:
2203 : {
2204 0 : mozilla::ipc::LogicError("unreached");
2205 0 : break;
2206 : }
2207 : }
2208 0 : mType = t;
2209 0 : return (*(this));
2210 : }
2211 :
2212 0 : auto JSParam::operator==(const void_t& aRhs) const -> bool
2213 : {
2214 0 : return (get_void_t()) == (aRhs);
2215 : }
2216 :
2217 0 : auto JSParam::operator==(const JSVariant& aRhs) const -> bool
2218 : {
2219 0 : return (get_JSVariant()) == (aRhs);
2220 : }
2221 :
2222 0 : auto JSParam::operator==(const JSParam& aRhs) const -> bool
2223 : {
2224 0 : if ((type()) != ((aRhs).type())) {
2225 0 : return false;
2226 : }
2227 :
2228 0 : switch (type()) {
2229 : case Tvoid_t:
2230 : {
2231 0 : return (get_void_t()) == ((aRhs).get_void_t());
2232 : }
2233 : case TJSVariant:
2234 : {
2235 0 : return (get_JSVariant()) == ((aRhs).get_JSVariant());
2236 : }
2237 : default:
2238 : {
2239 0 : mozilla::ipc::LogicError("unreached");
2240 0 : return false;
2241 : }
2242 : }
2243 : }
2244 :
2245 0 : auto JSParam::get(void_t* aOutValue) const -> void
2246 : {
2247 0 : (*(aOutValue)) = get_void_t();
2248 0 : }
2249 :
2250 0 : auto JSParam::get(JSVariant* aOutValue) const -> void
2251 : {
2252 0 : (*(aOutValue)) = get_JSVariant();
2253 0 : }
2254 :
2255 : } // namespace jsipc
2256 : } // namespace mozilla
2257 :
2258 : //-----------------------------------------------------------------------------
2259 : // Method definitions for the IPDL type |union GetterSetter|
2260 : //
2261 : namespace mozilla {
2262 : namespace jsipc {
2263 0 : auto GetterSetter::MaybeDestroy(Type aNewType) -> bool
2264 : {
2265 0 : if ((mType) == (T__None)) {
2266 0 : return true;
2267 : }
2268 0 : if ((mType) == (aNewType)) {
2269 0 : return false;
2270 : }
2271 0 : switch (mType) {
2272 : case Tuint64_t:
2273 : {
2274 0 : (ptr_uint64_t())->~uint64_t__tdef();
2275 0 : break;
2276 : }
2277 : case TObjectVariant:
2278 : {
2279 0 : (ptr_ObjectVariant())->~ObjectVariant__tdef();
2280 0 : break;
2281 : }
2282 : default:
2283 : {
2284 0 : mozilla::ipc::LogicError("not reached");
2285 0 : break;
2286 : }
2287 : }
2288 0 : return true;
2289 : }
2290 :
2291 0 : MOZ_IMPLICIT GetterSetter::GetterSetter(const uint64_t& aOther)
2292 : {
2293 0 : new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(aOther);
2294 0 : mType = Tuint64_t;
2295 0 : }
2296 :
2297 0 : MOZ_IMPLICIT GetterSetter::GetterSetter(const ObjectVariant& aOther)
2298 : {
2299 0 : new (mozilla::KnownNotNull, ptr_ObjectVariant()) ObjectVariant(aOther);
2300 0 : mType = TObjectVariant;
2301 0 : }
2302 :
2303 0 : MOZ_IMPLICIT GetterSetter::GetterSetter(const GetterSetter& aOther)
2304 : {
2305 0 : (aOther).AssertSanity();
2306 0 : switch ((aOther).type()) {
2307 : case Tuint64_t:
2308 : {
2309 0 : new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t((aOther).get_uint64_t());
2310 0 : break;
2311 : }
2312 : case TObjectVariant:
2313 : {
2314 0 : new (mozilla::KnownNotNull, ptr_ObjectVariant()) ObjectVariant((aOther).get_ObjectVariant());
2315 0 : break;
2316 : }
2317 : case T__None:
2318 : {
2319 0 : break;
2320 : }
2321 : default:
2322 : {
2323 0 : mozilla::ipc::LogicError("unreached");
2324 0 : return;
2325 : }
2326 : }
2327 0 : mType = (aOther).type();
2328 : }
2329 :
2330 0 : GetterSetter::~GetterSetter()
2331 : {
2332 0 : static_cast<void>(MaybeDestroy(T__None));
2333 0 : }
2334 :
2335 0 : auto GetterSetter::operator=(const uint64_t& aRhs) -> GetterSetter&
2336 : {
2337 0 : if (MaybeDestroy(Tuint64_t)) {
2338 0 : new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t;
2339 : }
2340 0 : (*(ptr_uint64_t())) = aRhs;
2341 0 : mType = Tuint64_t;
2342 0 : return (*(this));
2343 : }
2344 :
2345 0 : auto GetterSetter::operator=(const ObjectVariant& aRhs) -> GetterSetter&
2346 : {
2347 0 : if (MaybeDestroy(TObjectVariant)) {
2348 0 : new (mozilla::KnownNotNull, ptr_ObjectVariant()) ObjectVariant;
2349 : }
2350 0 : (*(ptr_ObjectVariant())) = aRhs;
2351 0 : mType = TObjectVariant;
2352 0 : return (*(this));
2353 : }
2354 :
2355 0 : auto GetterSetter::operator=(const GetterSetter& aRhs) -> GetterSetter&
2356 : {
2357 0 : (aRhs).AssertSanity();
2358 0 : Type t = (aRhs).type();
2359 0 : switch (t) {
2360 : case Tuint64_t:
2361 : {
2362 0 : if (MaybeDestroy(t)) {
2363 0 : new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t;
2364 : }
2365 0 : (*(ptr_uint64_t())) = (aRhs).get_uint64_t();
2366 0 : break;
2367 : }
2368 : case TObjectVariant:
2369 : {
2370 0 : if (MaybeDestroy(t)) {
2371 0 : new (mozilla::KnownNotNull, ptr_ObjectVariant()) ObjectVariant;
2372 : }
2373 0 : (*(ptr_ObjectVariant())) = (aRhs).get_ObjectVariant();
2374 0 : break;
2375 : }
2376 : case T__None:
2377 : {
2378 0 : static_cast<void>(MaybeDestroy(t));
2379 0 : break;
2380 : }
2381 : default:
2382 : {
2383 0 : mozilla::ipc::LogicError("unreached");
2384 0 : break;
2385 : }
2386 : }
2387 0 : mType = t;
2388 0 : return (*(this));
2389 : }
2390 :
2391 0 : auto GetterSetter::operator==(const uint64_t& aRhs) const -> bool
2392 : {
2393 0 : return (get_uint64_t()) == (aRhs);
2394 : }
2395 :
2396 0 : auto GetterSetter::operator==(const ObjectVariant& aRhs) const -> bool
2397 : {
2398 0 : return (get_ObjectVariant()) == (aRhs);
2399 : }
2400 :
2401 0 : auto GetterSetter::operator==(const GetterSetter& aRhs) const -> bool
2402 : {
2403 0 : if ((type()) != ((aRhs).type())) {
2404 0 : return false;
2405 : }
2406 :
2407 0 : switch (type()) {
2408 : case Tuint64_t:
2409 : {
2410 0 : return (get_uint64_t()) == ((aRhs).get_uint64_t());
2411 : }
2412 : case TObjectVariant:
2413 : {
2414 0 : return (get_ObjectVariant()) == ((aRhs).get_ObjectVariant());
2415 : }
2416 : default:
2417 : {
2418 0 : mozilla::ipc::LogicError("unreached");
2419 0 : return false;
2420 : }
2421 : }
2422 : }
2423 :
2424 0 : auto GetterSetter::get(uint64_t* aOutValue) const -> void
2425 : {
2426 0 : (*(aOutValue)) = get_uint64_t();
2427 0 : }
2428 :
2429 0 : auto GetterSetter::get(ObjectVariant* aOutValue) const -> void
2430 : {
2431 0 : (*(aOutValue)) = get_ObjectVariant();
2432 0 : }
2433 :
2434 : } // namespace jsipc
2435 : } // namespace mozilla
2436 :
2437 : //-----------------------------------------------------------------------------
2438 : // Method definitions for the IPDL type |struct PPropertyDescriptor|
2439 : //
2440 : namespace mozilla {
2441 : namespace jsipc {
2442 0 : MOZ_IMPLICIT PPropertyDescriptor::PPropertyDescriptor() :
2443 0 : attrs_()
2444 : {
2445 0 : Init();
2446 0 : }
2447 :
2448 0 : PPropertyDescriptor::~PPropertyDescriptor()
2449 : {
2450 0 : }
2451 :
2452 0 : auto PPropertyDescriptor::operator==(const PPropertyDescriptor& _o) const -> bool
2453 : {
2454 0 : if ((!((obj()) == ((_o).obj())))) {
2455 0 : return false;
2456 : }
2457 0 : if ((!((attrs()) == ((_o).attrs())))) {
2458 0 : return false;
2459 : }
2460 0 : if ((!((value()) == ((_o).value())))) {
2461 0 : return false;
2462 : }
2463 0 : if ((!((getter()) == ((_o).getter())))) {
2464 0 : return false;
2465 : }
2466 0 : if ((!((setter()) == ((_o).setter())))) {
2467 0 : return false;
2468 : }
2469 0 : return true;
2470 : }
2471 :
2472 0 : auto PPropertyDescriptor::operator!=(const PPropertyDescriptor& _o) const -> bool
2473 : {
2474 0 : return (!(operator==(_o)));
2475 : }
2476 :
2477 0 : auto PPropertyDescriptor::Init() -> void
2478 : {
2479 0 : }
2480 :
2481 0 : auto PPropertyDescriptor::Assign(
2482 : const ObjectOrNullVariant& _obj,
2483 : const uint32_t& _attrs,
2484 : const JSVariant& _value,
2485 : const GetterSetter& _getter,
2486 : const GetterSetter& _setter) -> void
2487 : {
2488 0 : obj_ = _obj;
2489 0 : attrs_ = _attrs;
2490 0 : value_ = _value;
2491 0 : getter_ = _getter;
2492 0 : setter_ = _setter;
2493 0 : }
2494 :
2495 : } // namespace jsipc
2496 : } // namespace mozilla
2497 :
2498 : //-----------------------------------------------------------------------------
2499 : // Method definitions for the IPDL type |struct CpowEntry|
2500 : //
2501 : namespace mozilla {
2502 : namespace jsipc {
2503 44 : MOZ_IMPLICIT CpowEntry::CpowEntry() :
2504 44 : name_()
2505 : {
2506 44 : Init();
2507 44 : }
2508 :
2509 132 : CpowEntry::~CpowEntry()
2510 : {
2511 132 : }
2512 :
2513 0 : auto CpowEntry::operator==(const CpowEntry& _o) const -> bool
2514 : {
2515 0 : if ((!((name()) == ((_o).name())))) {
2516 0 : return false;
2517 : }
2518 0 : if ((!((value()) == ((_o).value())))) {
2519 0 : return false;
2520 : }
2521 0 : return true;
2522 : }
2523 :
2524 0 : auto CpowEntry::operator!=(const CpowEntry& _o) const -> bool
2525 : {
2526 0 : return (!(operator==(_o)));
2527 : }
2528 :
2529 132 : auto CpowEntry::Init() -> void
2530 : {
2531 132 : }
2532 :
2533 88 : auto CpowEntry::Assign(
2534 : const nsString& _name,
2535 : const JSVariant& _value) -> void
2536 : {
2537 88 : name_ = _name;
2538 88 : value_ = _value;
2539 88 : }
2540 :
2541 : } // namespace jsipc
2542 : } // namespace mozilla
|
