Line data Source code
1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/dom/cache/CacheTypes.h"
8 :
9 :
10 : //-----------------------------------------------------------------------------
11 : // Method definitions for the IPDL type |struct CacheQueryParams|
12 : //
13 : namespace mozilla {
14 : namespace dom {
15 : namespace cache {
16 0 : MOZ_IMPLICIT CacheQueryParams::CacheQueryParams() :
17 : ignoreSearch_(),
18 : ignoreMethod_(),
19 : ignoreVary_(),
20 : cacheNameSet_(),
21 0 : cacheName_()
22 : {
23 0 : Init();
24 0 : }
25 :
26 0 : CacheQueryParams::~CacheQueryParams()
27 : {
28 0 : }
29 :
30 0 : auto CacheQueryParams::operator==(const CacheQueryParams& _o) const -> bool
31 : {
32 0 : if ((!((ignoreSearch()) == ((_o).ignoreSearch())))) {
33 0 : return false;
34 : }
35 0 : if ((!((ignoreMethod()) == ((_o).ignoreMethod())))) {
36 0 : return false;
37 : }
38 0 : if ((!((ignoreVary()) == ((_o).ignoreVary())))) {
39 0 : return false;
40 : }
41 0 : if ((!((cacheNameSet()) == ((_o).cacheNameSet())))) {
42 0 : return false;
43 : }
44 0 : if ((!((cacheName()) == ((_o).cacheName())))) {
45 0 : return false;
46 : }
47 0 : return true;
48 : }
49 :
50 0 : auto CacheQueryParams::operator!=(const CacheQueryParams& _o) const -> bool
51 : {
52 0 : return (!(operator==(_o)));
53 : }
54 :
55 0 : auto CacheQueryParams::Init() -> void
56 : {
57 0 : }
58 :
59 0 : auto CacheQueryParams::Assign(
60 : const bool& _ignoreSearch,
61 : const bool& _ignoreMethod,
62 : const bool& _ignoreVary,
63 : const bool& _cacheNameSet,
64 : const nsString& _cacheName) -> void
65 : {
66 0 : ignoreSearch_ = _ignoreSearch;
67 0 : ignoreMethod_ = _ignoreMethod;
68 0 : ignoreVary_ = _ignoreVary;
69 0 : cacheNameSet_ = _cacheNameSet;
70 0 : cacheName_ = _cacheName;
71 0 : }
72 :
73 : } // namespace cache
74 : } // namespace dom
75 : } // namespace mozilla
76 :
77 : //-----------------------------------------------------------------------------
78 : // Method definitions for the IPDL type |struct CacheReadStream|
79 : //
80 : namespace mozilla {
81 : namespace dom {
82 : namespace cache {
83 0 : MOZ_IMPLICIT CacheReadStream::CacheReadStream() :
84 0 : id_()
85 : {
86 0 : Init();
87 0 : }
88 :
89 0 : CacheReadStream::~CacheReadStream()
90 : {
91 0 : }
92 :
93 0 : auto CacheReadStream::operator==(const CacheReadStream& _o) const -> bool
94 : {
95 0 : if ((!((id()) == ((_o).id())))) {
96 0 : return false;
97 : }
98 0 : if ((!((controlParent()) == ((_o).controlParent())))) {
99 0 : return false;
100 : }
101 0 : if ((!((controlChild()) == ((_o).controlChild())))) {
102 0 : return false;
103 : }
104 0 : if ((!((stream()) == ((_o).stream())))) {
105 0 : return false;
106 : }
107 0 : return true;
108 : }
109 :
110 0 : auto CacheReadStream::operator!=(const CacheReadStream& _o) const -> bool
111 : {
112 0 : return (!(operator==(_o)));
113 : }
114 :
115 0 : auto CacheReadStream::Init() -> void
116 : {
117 0 : controlParent_ = nullptr;
118 0 : controlChild_ = nullptr;
119 0 : }
120 :
121 0 : auto CacheReadStream::Assign(
122 : const nsID& _id,
123 : PCacheStreamControlParent* _controlParent,
124 : PCacheStreamControlChild* _controlChild,
125 : const IPCStream& _stream) -> void
126 : {
127 0 : id_ = _id;
128 0 : controlParent_ = _controlParent;
129 0 : controlChild_ = _controlChild;
130 0 : stream_ = _stream;
131 0 : }
132 :
133 : } // namespace cache
134 : } // namespace dom
135 : } // namespace mozilla
136 :
137 : //-----------------------------------------------------------------------------
138 : // Method definitions for the IPDL type |union CacheReadStreamOrVoid|
139 : //
140 : namespace mozilla {
141 : namespace dom {
142 : namespace cache {
143 0 : auto CacheReadStreamOrVoid::MaybeDestroy(Type aNewType) -> bool
144 : {
145 0 : if ((mType) == (T__None)) {
146 0 : return true;
147 : }
148 0 : if ((mType) == (aNewType)) {
149 0 : return false;
150 : }
151 0 : switch (mType) {
152 : case Tvoid_t:
153 : {
154 0 : (ptr_void_t())->~void_t__tdef();
155 0 : break;
156 : }
157 : case TCacheReadStream:
158 : {
159 0 : (ptr_CacheReadStream())->~CacheReadStream__tdef();
160 0 : break;
161 : }
162 : default:
163 : {
164 0 : mozilla::ipc::LogicError("not reached");
165 0 : break;
166 : }
167 : }
168 0 : return true;
169 : }
170 :
171 0 : MOZ_IMPLICIT CacheReadStreamOrVoid::CacheReadStreamOrVoid(const void_t& aOther)
172 : {
173 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
174 0 : mType = Tvoid_t;
175 0 : }
176 :
177 0 : MOZ_IMPLICIT CacheReadStreamOrVoid::CacheReadStreamOrVoid(const CacheReadStream& aOther)
178 : {
179 0 : new (mozilla::KnownNotNull, ptr_CacheReadStream()) CacheReadStream(aOther);
180 0 : mType = TCacheReadStream;
181 0 : }
182 :
183 0 : MOZ_IMPLICIT CacheReadStreamOrVoid::CacheReadStreamOrVoid(const CacheReadStreamOrVoid& aOther)
184 : {
185 0 : (aOther).AssertSanity();
186 0 : switch ((aOther).type()) {
187 : case Tvoid_t:
188 : {
189 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
190 0 : break;
191 : }
192 : case TCacheReadStream:
193 : {
194 0 : new (mozilla::KnownNotNull, ptr_CacheReadStream()) CacheReadStream((aOther).get_CacheReadStream());
195 0 : break;
196 : }
197 : case T__None:
198 : {
199 0 : break;
200 : }
201 : default:
202 : {
203 0 : mozilla::ipc::LogicError("unreached");
204 0 : return;
205 : }
206 : }
207 0 : mType = (aOther).type();
208 : }
209 :
210 0 : CacheReadStreamOrVoid::~CacheReadStreamOrVoid()
211 : {
212 0 : static_cast<void>(MaybeDestroy(T__None));
213 0 : }
214 :
215 0 : auto CacheReadStreamOrVoid::operator=(const void_t& aRhs) -> CacheReadStreamOrVoid&
216 : {
217 0 : if (MaybeDestroy(Tvoid_t)) {
218 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
219 : }
220 0 : (*(ptr_void_t())) = aRhs;
221 0 : mType = Tvoid_t;
222 0 : return (*(this));
223 : }
224 :
225 0 : auto CacheReadStreamOrVoid::operator=(const CacheReadStream& aRhs) -> CacheReadStreamOrVoid&
226 : {
227 0 : if (MaybeDestroy(TCacheReadStream)) {
228 0 : new (mozilla::KnownNotNull, ptr_CacheReadStream()) CacheReadStream;
229 : }
230 0 : (*(ptr_CacheReadStream())) = aRhs;
231 0 : mType = TCacheReadStream;
232 0 : return (*(this));
233 : }
234 :
235 0 : auto CacheReadStreamOrVoid::operator=(const CacheReadStreamOrVoid& aRhs) -> CacheReadStreamOrVoid&
236 : {
237 0 : (aRhs).AssertSanity();
238 0 : Type t = (aRhs).type();
239 0 : switch (t) {
240 : case Tvoid_t:
241 : {
242 0 : if (MaybeDestroy(t)) {
243 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
244 : }
245 0 : (*(ptr_void_t())) = (aRhs).get_void_t();
246 0 : break;
247 : }
248 : case TCacheReadStream:
249 : {
250 0 : if (MaybeDestroy(t)) {
251 0 : new (mozilla::KnownNotNull, ptr_CacheReadStream()) CacheReadStream;
252 : }
253 0 : (*(ptr_CacheReadStream())) = (aRhs).get_CacheReadStream();
254 0 : break;
255 : }
256 : case T__None:
257 : {
258 0 : static_cast<void>(MaybeDestroy(t));
259 0 : break;
260 : }
261 : default:
262 : {
263 0 : mozilla::ipc::LogicError("unreached");
264 0 : break;
265 : }
266 : }
267 0 : mType = t;
268 0 : return (*(this));
269 : }
270 :
271 0 : auto CacheReadStreamOrVoid::operator==(const void_t& aRhs) const -> bool
272 : {
273 0 : return (get_void_t()) == (aRhs);
274 : }
275 :
276 0 : auto CacheReadStreamOrVoid::operator==(const CacheReadStream& aRhs) const -> bool
277 : {
278 0 : return (get_CacheReadStream()) == (aRhs);
279 : }
280 :
281 0 : auto CacheReadStreamOrVoid::operator==(const CacheReadStreamOrVoid& aRhs) const -> bool
282 : {
283 0 : if ((type()) != ((aRhs).type())) {
284 0 : return false;
285 : }
286 :
287 0 : switch (type()) {
288 : case Tvoid_t:
289 : {
290 0 : return (get_void_t()) == ((aRhs).get_void_t());
291 : }
292 : case TCacheReadStream:
293 : {
294 0 : return (get_CacheReadStream()) == ((aRhs).get_CacheReadStream());
295 : }
296 : default:
297 : {
298 0 : mozilla::ipc::LogicError("unreached");
299 0 : return false;
300 : }
301 : }
302 : }
303 :
304 0 : auto CacheReadStreamOrVoid::get(void_t* aOutValue) const -> void
305 : {
306 0 : (*(aOutValue)) = get_void_t();
307 0 : }
308 :
309 0 : auto CacheReadStreamOrVoid::get(CacheReadStream* aOutValue) const -> void
310 : {
311 0 : (*(aOutValue)) = get_CacheReadStream();
312 0 : }
313 :
314 : } // namespace cache
315 : } // namespace dom
316 : } // namespace mozilla
317 :
318 : //-----------------------------------------------------------------------------
319 : // Method definitions for the IPDL type |struct HeadersEntry|
320 : //
321 : namespace mozilla {
322 : namespace dom {
323 : namespace cache {
324 0 : MOZ_IMPLICIT HeadersEntry::HeadersEntry() :
325 : name_(),
326 0 : value_()
327 : {
328 0 : Init();
329 0 : }
330 :
331 0 : HeadersEntry::~HeadersEntry()
332 : {
333 0 : }
334 :
335 0 : auto HeadersEntry::operator==(const HeadersEntry& _o) const -> bool
336 : {
337 0 : if ((!((name()) == ((_o).name())))) {
338 0 : return false;
339 : }
340 0 : if ((!((value()) == ((_o).value())))) {
341 0 : return false;
342 : }
343 0 : return true;
344 : }
345 :
346 0 : auto HeadersEntry::operator!=(const HeadersEntry& _o) const -> bool
347 : {
348 0 : return (!(operator==(_o)));
349 : }
350 :
351 0 : auto HeadersEntry::Init() -> void
352 : {
353 0 : }
354 :
355 0 : auto HeadersEntry::Assign(
356 : const nsCString& _name,
357 : const nsCString& _value) -> void
358 : {
359 0 : name_ = _name;
360 0 : value_ = _value;
361 0 : }
362 :
363 : } // namespace cache
364 : } // namespace dom
365 : } // namespace mozilla
366 :
367 : //-----------------------------------------------------------------------------
368 : // Method definitions for the IPDL type |struct CacheRequest|
369 : //
370 : namespace mozilla {
371 : namespace dom {
372 : namespace cache {
373 0 : MOZ_IMPLICIT CacheRequest::CacheRequest() :
374 : method_(),
375 : urlWithoutQuery_(),
376 : urlQuery_(),
377 : urlFragment_(),
378 : headersGuard_(),
379 : referrer_(),
380 : referrerPolicy_(),
381 : mode_(),
382 : credentials_(),
383 : contentPolicyType_(),
384 : requestCache_(),
385 : requestRedirect_(),
386 0 : integrity_()
387 : {
388 0 : Init();
389 0 : }
390 :
391 0 : CacheRequest::~CacheRequest()
392 : {
393 0 : }
394 :
395 0 : auto CacheRequest::operator==(const CacheRequest& _o) const -> bool
396 : {
397 0 : if ((!((method()) == ((_o).method())))) {
398 0 : return false;
399 : }
400 0 : if ((!((urlWithoutQuery()) == ((_o).urlWithoutQuery())))) {
401 0 : return false;
402 : }
403 0 : if ((!((urlQuery()) == ((_o).urlQuery())))) {
404 0 : return false;
405 : }
406 0 : if ((!((urlFragment()) == ((_o).urlFragment())))) {
407 0 : return false;
408 : }
409 0 : if ((!((headers()) == ((_o).headers())))) {
410 0 : return false;
411 : }
412 0 : if ((!((headersGuard()) == ((_o).headersGuard())))) {
413 0 : return false;
414 : }
415 0 : if ((!((referrer()) == ((_o).referrer())))) {
416 0 : return false;
417 : }
418 0 : if ((!((referrerPolicy()) == ((_o).referrerPolicy())))) {
419 0 : return false;
420 : }
421 0 : if ((!((mode()) == ((_o).mode())))) {
422 0 : return false;
423 : }
424 0 : if ((!((credentials()) == ((_o).credentials())))) {
425 0 : return false;
426 : }
427 0 : if ((!((body()) == ((_o).body())))) {
428 0 : return false;
429 : }
430 0 : if ((!((contentPolicyType()) == ((_o).contentPolicyType())))) {
431 0 : return false;
432 : }
433 0 : if ((!((requestCache()) == ((_o).requestCache())))) {
434 0 : return false;
435 : }
436 0 : if ((!((requestRedirect()) == ((_o).requestRedirect())))) {
437 0 : return false;
438 : }
439 0 : if ((!((integrity()) == ((_o).integrity())))) {
440 0 : return false;
441 : }
442 0 : return true;
443 : }
444 :
445 0 : auto CacheRequest::operator!=(const CacheRequest& _o) const -> bool
446 : {
447 0 : return (!(operator==(_o)));
448 : }
449 :
450 0 : auto CacheRequest::Init() -> void
451 : {
452 0 : }
453 :
454 0 : auto CacheRequest::Assign(
455 : const nsCString& _method,
456 : const nsCString& _urlWithoutQuery,
457 : const nsCString& _urlQuery,
458 : const nsCString& _urlFragment,
459 : const nsTArray<HeadersEntry>& _headers,
460 : const HeadersGuardEnum& _headersGuard,
461 : const nsString& _referrer,
462 : const ReferrerPolicy& _referrerPolicy,
463 : const RequestMode& _mode,
464 : const RequestCredentials& _credentials,
465 : const CacheReadStreamOrVoid& _body,
466 : const uint32_t& _contentPolicyType,
467 : const RequestCache& _requestCache,
468 : const RequestRedirect& _requestRedirect,
469 : const nsString& _integrity) -> void
470 : {
471 0 : method_ = _method;
472 0 : urlWithoutQuery_ = _urlWithoutQuery;
473 0 : urlQuery_ = _urlQuery;
474 0 : urlFragment_ = _urlFragment;
475 0 : headers_ = _headers;
476 0 : headersGuard_ = _headersGuard;
477 0 : referrer_ = _referrer;
478 0 : referrerPolicy_ = _referrerPolicy;
479 0 : mode_ = _mode;
480 0 : credentials_ = _credentials;
481 0 : body_ = _body;
482 0 : contentPolicyType_ = _contentPolicyType;
483 0 : requestCache_ = _requestCache;
484 0 : requestRedirect_ = _requestRedirect;
485 0 : integrity_ = _integrity;
486 0 : }
487 :
488 : } // namespace cache
489 : } // namespace dom
490 : } // namespace mozilla
491 :
492 : //-----------------------------------------------------------------------------
493 : // Method definitions for the IPDL type |union CacheRequestOrVoid|
494 : //
495 : namespace mozilla {
496 : namespace dom {
497 : namespace cache {
498 0 : auto CacheRequestOrVoid::MaybeDestroy(Type aNewType) -> bool
499 : {
500 0 : if ((mType) == (T__None)) {
501 0 : return true;
502 : }
503 0 : if ((mType) == (aNewType)) {
504 0 : return false;
505 : }
506 0 : switch (mType) {
507 : case Tvoid_t:
508 : {
509 0 : (ptr_void_t())->~void_t__tdef();
510 0 : break;
511 : }
512 : case TCacheRequest:
513 : {
514 0 : (ptr_CacheRequest())->~CacheRequest__tdef();
515 0 : break;
516 : }
517 : default:
518 : {
519 0 : mozilla::ipc::LogicError("not reached");
520 0 : break;
521 : }
522 : }
523 0 : return true;
524 : }
525 :
526 0 : MOZ_IMPLICIT CacheRequestOrVoid::CacheRequestOrVoid(const void_t& aOther)
527 : {
528 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
529 0 : mType = Tvoid_t;
530 0 : }
531 :
532 0 : MOZ_IMPLICIT CacheRequestOrVoid::CacheRequestOrVoid(const CacheRequest& aOther)
533 : {
534 0 : new (mozilla::KnownNotNull, ptr_CacheRequest()) CacheRequest(aOther);
535 0 : mType = TCacheRequest;
536 0 : }
537 :
538 0 : MOZ_IMPLICIT CacheRequestOrVoid::CacheRequestOrVoid(const CacheRequestOrVoid& aOther)
539 : {
540 0 : (aOther).AssertSanity();
541 0 : switch ((aOther).type()) {
542 : case Tvoid_t:
543 : {
544 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
545 0 : break;
546 : }
547 : case TCacheRequest:
548 : {
549 0 : new (mozilla::KnownNotNull, ptr_CacheRequest()) CacheRequest((aOther).get_CacheRequest());
550 0 : break;
551 : }
552 : case T__None:
553 : {
554 0 : break;
555 : }
556 : default:
557 : {
558 0 : mozilla::ipc::LogicError("unreached");
559 0 : return;
560 : }
561 : }
562 0 : mType = (aOther).type();
563 : }
564 :
565 0 : CacheRequestOrVoid::~CacheRequestOrVoid()
566 : {
567 0 : static_cast<void>(MaybeDestroy(T__None));
568 0 : }
569 :
570 0 : auto CacheRequestOrVoid::operator=(const void_t& aRhs) -> CacheRequestOrVoid&
571 : {
572 0 : if (MaybeDestroy(Tvoid_t)) {
573 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
574 : }
575 0 : (*(ptr_void_t())) = aRhs;
576 0 : mType = Tvoid_t;
577 0 : return (*(this));
578 : }
579 :
580 0 : auto CacheRequestOrVoid::operator=(const CacheRequest& aRhs) -> CacheRequestOrVoid&
581 : {
582 0 : if (MaybeDestroy(TCacheRequest)) {
583 0 : new (mozilla::KnownNotNull, ptr_CacheRequest()) CacheRequest;
584 : }
585 0 : (*(ptr_CacheRequest())) = aRhs;
586 0 : mType = TCacheRequest;
587 0 : return (*(this));
588 : }
589 :
590 0 : auto CacheRequestOrVoid::operator=(const CacheRequestOrVoid& aRhs) -> CacheRequestOrVoid&
591 : {
592 0 : (aRhs).AssertSanity();
593 0 : Type t = (aRhs).type();
594 0 : switch (t) {
595 : case Tvoid_t:
596 : {
597 0 : if (MaybeDestroy(t)) {
598 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
599 : }
600 0 : (*(ptr_void_t())) = (aRhs).get_void_t();
601 0 : break;
602 : }
603 : case TCacheRequest:
604 : {
605 0 : if (MaybeDestroy(t)) {
606 0 : new (mozilla::KnownNotNull, ptr_CacheRequest()) CacheRequest;
607 : }
608 0 : (*(ptr_CacheRequest())) = (aRhs).get_CacheRequest();
609 0 : break;
610 : }
611 : case T__None:
612 : {
613 0 : static_cast<void>(MaybeDestroy(t));
614 0 : break;
615 : }
616 : default:
617 : {
618 0 : mozilla::ipc::LogicError("unreached");
619 0 : break;
620 : }
621 : }
622 0 : mType = t;
623 0 : return (*(this));
624 : }
625 :
626 0 : auto CacheRequestOrVoid::operator==(const void_t& aRhs) const -> bool
627 : {
628 0 : return (get_void_t()) == (aRhs);
629 : }
630 :
631 0 : auto CacheRequestOrVoid::operator==(const CacheRequest& aRhs) const -> bool
632 : {
633 0 : return (get_CacheRequest()) == (aRhs);
634 : }
635 :
636 0 : auto CacheRequestOrVoid::operator==(const CacheRequestOrVoid& aRhs) const -> bool
637 : {
638 0 : if ((type()) != ((aRhs).type())) {
639 0 : return false;
640 : }
641 :
642 0 : switch (type()) {
643 : case Tvoid_t:
644 : {
645 0 : return (get_void_t()) == ((aRhs).get_void_t());
646 : }
647 : case TCacheRequest:
648 : {
649 0 : return (get_CacheRequest()) == ((aRhs).get_CacheRequest());
650 : }
651 : default:
652 : {
653 0 : mozilla::ipc::LogicError("unreached");
654 0 : return false;
655 : }
656 : }
657 : }
658 :
659 0 : auto CacheRequestOrVoid::get(void_t* aOutValue) const -> void
660 : {
661 0 : (*(aOutValue)) = get_void_t();
662 0 : }
663 :
664 0 : auto CacheRequestOrVoid::get(CacheRequest* aOutValue) const -> void
665 : {
666 0 : (*(aOutValue)) = get_CacheRequest();
667 0 : }
668 :
669 : } // namespace cache
670 : } // namespace dom
671 : } // namespace mozilla
672 :
673 : //-----------------------------------------------------------------------------
674 : // Method definitions for the IPDL type |struct CacheResponse|
675 : //
676 : namespace mozilla {
677 : namespace dom {
678 : namespace cache {
679 0 : MOZ_IMPLICIT CacheResponse::CacheResponse() :
680 : type_(),
681 : status_(),
682 : statusText_(),
683 0 : headersGuard_()
684 : {
685 0 : Init();
686 0 : }
687 :
688 0 : CacheResponse::~CacheResponse()
689 : {
690 0 : }
691 :
692 0 : auto CacheResponse::operator==(const CacheResponse& _o) const -> bool
693 : {
694 0 : if ((!((type()) == ((_o).type())))) {
695 0 : return false;
696 : }
697 0 : if ((!((urlList()) == ((_o).urlList())))) {
698 0 : return false;
699 : }
700 0 : if ((!((status()) == ((_o).status())))) {
701 0 : return false;
702 : }
703 0 : if ((!((statusText()) == ((_o).statusText())))) {
704 0 : return false;
705 : }
706 0 : if ((!((headers()) == ((_o).headers())))) {
707 0 : return false;
708 : }
709 0 : if ((!((headersGuard()) == ((_o).headersGuard())))) {
710 0 : return false;
711 : }
712 0 : if ((!((body()) == ((_o).body())))) {
713 0 : return false;
714 : }
715 0 : if ((!((channelInfo()) == ((_o).channelInfo())))) {
716 0 : return false;
717 : }
718 0 : if ((!((principalInfo()) == ((_o).principalInfo())))) {
719 0 : return false;
720 : }
721 0 : return true;
722 : }
723 :
724 0 : auto CacheResponse::operator!=(const CacheResponse& _o) const -> bool
725 : {
726 0 : return (!(operator==(_o)));
727 : }
728 :
729 0 : auto CacheResponse::Init() -> void
730 : {
731 0 : }
732 :
733 0 : auto CacheResponse::Assign(
734 : const ResponseType& _type,
735 : const nsTArray<nsCString>& _urlList,
736 : const uint32_t& _status,
737 : const nsCString& _statusText,
738 : const nsTArray<HeadersEntry>& _headers,
739 : const HeadersGuardEnum& _headersGuard,
740 : const CacheReadStreamOrVoid& _body,
741 : const IPCChannelInfo& _channelInfo,
742 : const OptionalPrincipalInfo& _principalInfo) -> void
743 : {
744 0 : type_ = _type;
745 0 : urlList_ = _urlList;
746 0 : status_ = _status;
747 0 : statusText_ = _statusText;
748 0 : headers_ = _headers;
749 0 : headersGuard_ = _headersGuard;
750 0 : body_ = _body;
751 0 : channelInfo_ = _channelInfo;
752 0 : principalInfo_ = _principalInfo;
753 0 : }
754 :
755 : } // namespace cache
756 : } // namespace dom
757 : } // namespace mozilla
758 :
759 : //-----------------------------------------------------------------------------
760 : // Method definitions for the IPDL type |union CacheResponseOrVoid|
761 : //
762 : namespace mozilla {
763 : namespace dom {
764 : namespace cache {
765 0 : auto CacheResponseOrVoid::MaybeDestroy(Type aNewType) -> bool
766 : {
767 0 : if ((mType) == (T__None)) {
768 0 : return true;
769 : }
770 0 : if ((mType) == (aNewType)) {
771 0 : return false;
772 : }
773 0 : switch (mType) {
774 : case Tvoid_t:
775 : {
776 0 : (ptr_void_t())->~void_t__tdef();
777 0 : break;
778 : }
779 : case TCacheResponse:
780 : {
781 0 : (ptr_CacheResponse())->~CacheResponse__tdef();
782 0 : break;
783 : }
784 : default:
785 : {
786 0 : mozilla::ipc::LogicError("not reached");
787 0 : break;
788 : }
789 : }
790 0 : return true;
791 : }
792 :
793 0 : MOZ_IMPLICIT CacheResponseOrVoid::CacheResponseOrVoid(const void_t& aOther)
794 : {
795 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
796 0 : mType = Tvoid_t;
797 0 : }
798 :
799 0 : MOZ_IMPLICIT CacheResponseOrVoid::CacheResponseOrVoid(const CacheResponse& aOther)
800 : {
801 0 : new (mozilla::KnownNotNull, ptr_CacheResponse()) CacheResponse(aOther);
802 0 : mType = TCacheResponse;
803 0 : }
804 :
805 0 : MOZ_IMPLICIT CacheResponseOrVoid::CacheResponseOrVoid(const CacheResponseOrVoid& aOther)
806 : {
807 0 : (aOther).AssertSanity();
808 0 : switch ((aOther).type()) {
809 : case Tvoid_t:
810 : {
811 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
812 0 : break;
813 : }
814 : case TCacheResponse:
815 : {
816 0 : new (mozilla::KnownNotNull, ptr_CacheResponse()) CacheResponse((aOther).get_CacheResponse());
817 0 : break;
818 : }
819 : case T__None:
820 : {
821 0 : break;
822 : }
823 : default:
824 : {
825 0 : mozilla::ipc::LogicError("unreached");
826 0 : return;
827 : }
828 : }
829 0 : mType = (aOther).type();
830 : }
831 :
832 0 : CacheResponseOrVoid::~CacheResponseOrVoid()
833 : {
834 0 : static_cast<void>(MaybeDestroy(T__None));
835 0 : }
836 :
837 0 : auto CacheResponseOrVoid::operator=(const void_t& aRhs) -> CacheResponseOrVoid&
838 : {
839 0 : if (MaybeDestroy(Tvoid_t)) {
840 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
841 : }
842 0 : (*(ptr_void_t())) = aRhs;
843 0 : mType = Tvoid_t;
844 0 : return (*(this));
845 : }
846 :
847 0 : auto CacheResponseOrVoid::operator=(const CacheResponse& aRhs) -> CacheResponseOrVoid&
848 : {
849 0 : if (MaybeDestroy(TCacheResponse)) {
850 0 : new (mozilla::KnownNotNull, ptr_CacheResponse()) CacheResponse;
851 : }
852 0 : (*(ptr_CacheResponse())) = aRhs;
853 0 : mType = TCacheResponse;
854 0 : return (*(this));
855 : }
856 :
857 0 : auto CacheResponseOrVoid::operator=(const CacheResponseOrVoid& aRhs) -> CacheResponseOrVoid&
858 : {
859 0 : (aRhs).AssertSanity();
860 0 : Type t = (aRhs).type();
861 0 : switch (t) {
862 : case Tvoid_t:
863 : {
864 0 : if (MaybeDestroy(t)) {
865 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
866 : }
867 0 : (*(ptr_void_t())) = (aRhs).get_void_t();
868 0 : break;
869 : }
870 : case TCacheResponse:
871 : {
872 0 : if (MaybeDestroy(t)) {
873 0 : new (mozilla::KnownNotNull, ptr_CacheResponse()) CacheResponse;
874 : }
875 0 : (*(ptr_CacheResponse())) = (aRhs).get_CacheResponse();
876 0 : break;
877 : }
878 : case T__None:
879 : {
880 0 : static_cast<void>(MaybeDestroy(t));
881 0 : break;
882 : }
883 : default:
884 : {
885 0 : mozilla::ipc::LogicError("unreached");
886 0 : break;
887 : }
888 : }
889 0 : mType = t;
890 0 : return (*(this));
891 : }
892 :
893 0 : auto CacheResponseOrVoid::operator==(const void_t& aRhs) const -> bool
894 : {
895 0 : return (get_void_t()) == (aRhs);
896 : }
897 :
898 0 : auto CacheResponseOrVoid::operator==(const CacheResponse& aRhs) const -> bool
899 : {
900 0 : return (get_CacheResponse()) == (aRhs);
901 : }
902 :
903 0 : auto CacheResponseOrVoid::operator==(const CacheResponseOrVoid& aRhs) const -> bool
904 : {
905 0 : if ((type()) != ((aRhs).type())) {
906 0 : return false;
907 : }
908 :
909 0 : switch (type()) {
910 : case Tvoid_t:
911 : {
912 0 : return (get_void_t()) == ((aRhs).get_void_t());
913 : }
914 : case TCacheResponse:
915 : {
916 0 : return (get_CacheResponse()) == ((aRhs).get_CacheResponse());
917 : }
918 : default:
919 : {
920 0 : mozilla::ipc::LogicError("unreached");
921 0 : return false;
922 : }
923 : }
924 : }
925 :
926 0 : auto CacheResponseOrVoid::get(void_t* aOutValue) const -> void
927 : {
928 0 : (*(aOutValue)) = get_void_t();
929 0 : }
930 :
931 0 : auto CacheResponseOrVoid::get(CacheResponse* aOutValue) const -> void
932 : {
933 0 : (*(aOutValue)) = get_CacheResponse();
934 0 : }
935 :
936 : } // namespace cache
937 : } // namespace dom
938 : } // namespace mozilla
939 :
940 : //-----------------------------------------------------------------------------
941 : // Method definitions for the IPDL type |struct CacheRequestResponse|
942 : //
943 : namespace mozilla {
944 : namespace dom {
945 : namespace cache {
946 0 : MOZ_IMPLICIT CacheRequestResponse::CacheRequestResponse()
947 : {
948 0 : Init();
949 0 : }
950 :
951 0 : CacheRequestResponse::~CacheRequestResponse()
952 : {
953 0 : }
954 :
955 0 : auto CacheRequestResponse::operator==(const CacheRequestResponse& _o) const -> bool
956 : {
957 0 : if ((!((request()) == ((_o).request())))) {
958 0 : return false;
959 : }
960 0 : if ((!((response()) == ((_o).response())))) {
961 0 : return false;
962 : }
963 0 : return true;
964 : }
965 :
966 0 : auto CacheRequestResponse::operator!=(const CacheRequestResponse& _o) const -> bool
967 : {
968 0 : return (!(operator==(_o)));
969 : }
970 :
971 0 : auto CacheRequestResponse::Init() -> void
972 : {
973 0 : }
974 :
975 0 : auto CacheRequestResponse::Assign(
976 : const CacheRequest& _request,
977 : const CacheResponse& _response) -> void
978 : {
979 0 : request_ = _request;
980 0 : response_ = _response;
981 0 : }
982 :
983 : } // namespace cache
984 : } // namespace dom
985 : } // namespace mozilla
986 :
987 : //-----------------------------------------------------------------------------
988 : // Method definitions for the IPDL type |struct CacheMatchArgs|
989 : //
990 : namespace mozilla {
991 : namespace dom {
992 : namespace cache {
993 0 : MOZ_IMPLICIT CacheMatchArgs::CacheMatchArgs()
994 : {
995 0 : Init();
996 0 : }
997 :
998 0 : CacheMatchArgs::~CacheMatchArgs()
999 : {
1000 0 : }
1001 :
1002 0 : auto CacheMatchArgs::operator==(const CacheMatchArgs& _o) const -> bool
1003 : {
1004 0 : if ((!((request()) == ((_o).request())))) {
1005 0 : return false;
1006 : }
1007 0 : if ((!((params()) == ((_o).params())))) {
1008 0 : return false;
1009 : }
1010 0 : return true;
1011 : }
1012 :
1013 0 : auto CacheMatchArgs::operator!=(const CacheMatchArgs& _o) const -> bool
1014 : {
1015 0 : return (!(operator==(_o)));
1016 : }
1017 :
1018 0 : auto CacheMatchArgs::Init() -> void
1019 : {
1020 0 : }
1021 :
1022 0 : auto CacheMatchArgs::Assign(
1023 : const CacheRequest& _request,
1024 : const CacheQueryParams& _params) -> void
1025 : {
1026 0 : request_ = _request;
1027 0 : params_ = _params;
1028 0 : }
1029 :
1030 : } // namespace cache
1031 : } // namespace dom
1032 : } // namespace mozilla
1033 :
1034 : //-----------------------------------------------------------------------------
1035 : // Method definitions for the IPDL type |struct CacheMatchAllArgs|
1036 : //
1037 : namespace mozilla {
1038 : namespace dom {
1039 : namespace cache {
1040 0 : MOZ_IMPLICIT CacheMatchAllArgs::CacheMatchAllArgs()
1041 : {
1042 0 : Init();
1043 0 : }
1044 :
1045 0 : CacheMatchAllArgs::~CacheMatchAllArgs()
1046 : {
1047 0 : }
1048 :
1049 0 : auto CacheMatchAllArgs::operator==(const CacheMatchAllArgs& _o) const -> bool
1050 : {
1051 0 : if ((!((requestOrVoid()) == ((_o).requestOrVoid())))) {
1052 0 : return false;
1053 : }
1054 0 : if ((!((params()) == ((_o).params())))) {
1055 0 : return false;
1056 : }
1057 0 : return true;
1058 : }
1059 :
1060 0 : auto CacheMatchAllArgs::operator!=(const CacheMatchAllArgs& _o) const -> bool
1061 : {
1062 0 : return (!(operator==(_o)));
1063 : }
1064 :
1065 0 : auto CacheMatchAllArgs::Init() -> void
1066 : {
1067 0 : }
1068 :
1069 0 : auto CacheMatchAllArgs::Assign(
1070 : const CacheRequestOrVoid& _requestOrVoid,
1071 : const CacheQueryParams& _params) -> void
1072 : {
1073 0 : requestOrVoid_ = _requestOrVoid;
1074 0 : params_ = _params;
1075 0 : }
1076 :
1077 : } // namespace cache
1078 : } // namespace dom
1079 : } // namespace mozilla
1080 :
1081 : //-----------------------------------------------------------------------------
1082 : // Method definitions for the IPDL type |struct CachePutAllArgs|
1083 : //
1084 : namespace mozilla {
1085 : namespace dom {
1086 : namespace cache {
1087 0 : MOZ_IMPLICIT CachePutAllArgs::CachePutAllArgs()
1088 : {
1089 0 : Init();
1090 0 : }
1091 :
1092 0 : CachePutAllArgs::~CachePutAllArgs()
1093 : {
1094 0 : }
1095 :
1096 0 : auto CachePutAllArgs::operator==(const CachePutAllArgs& _o) const -> bool
1097 : {
1098 0 : if ((!((requestResponseList()) == ((_o).requestResponseList())))) {
1099 0 : return false;
1100 : }
1101 0 : return true;
1102 : }
1103 :
1104 0 : auto CachePutAllArgs::operator!=(const CachePutAllArgs& _o) const -> bool
1105 : {
1106 0 : return (!(operator==(_o)));
1107 : }
1108 :
1109 0 : auto CachePutAllArgs::Init() -> void
1110 : {
1111 0 : }
1112 :
1113 0 : auto CachePutAllArgs::Assign(const nsTArray<CacheRequestResponse>& _requestResponseList) -> void
1114 : {
1115 0 : requestResponseList_ = _requestResponseList;
1116 0 : }
1117 :
1118 : } // namespace cache
1119 : } // namespace dom
1120 : } // namespace mozilla
1121 :
1122 : //-----------------------------------------------------------------------------
1123 : // Method definitions for the IPDL type |struct CacheDeleteArgs|
1124 : //
1125 : namespace mozilla {
1126 : namespace dom {
1127 : namespace cache {
1128 0 : MOZ_IMPLICIT CacheDeleteArgs::CacheDeleteArgs()
1129 : {
1130 0 : Init();
1131 0 : }
1132 :
1133 0 : CacheDeleteArgs::~CacheDeleteArgs()
1134 : {
1135 0 : }
1136 :
1137 0 : auto CacheDeleteArgs::operator==(const CacheDeleteArgs& _o) const -> bool
1138 : {
1139 0 : if ((!((request()) == ((_o).request())))) {
1140 0 : return false;
1141 : }
1142 0 : if ((!((params()) == ((_o).params())))) {
1143 0 : return false;
1144 : }
1145 0 : return true;
1146 : }
1147 :
1148 0 : auto CacheDeleteArgs::operator!=(const CacheDeleteArgs& _o) const -> bool
1149 : {
1150 0 : return (!(operator==(_o)));
1151 : }
1152 :
1153 0 : auto CacheDeleteArgs::Init() -> void
1154 : {
1155 0 : }
1156 :
1157 0 : auto CacheDeleteArgs::Assign(
1158 : const CacheRequest& _request,
1159 : const CacheQueryParams& _params) -> void
1160 : {
1161 0 : request_ = _request;
1162 0 : params_ = _params;
1163 0 : }
1164 :
1165 : } // namespace cache
1166 : } // namespace dom
1167 : } // namespace mozilla
1168 :
1169 : //-----------------------------------------------------------------------------
1170 : // Method definitions for the IPDL type |struct CacheKeysArgs|
1171 : //
1172 : namespace mozilla {
1173 : namespace dom {
1174 : namespace cache {
1175 0 : MOZ_IMPLICIT CacheKeysArgs::CacheKeysArgs()
1176 : {
1177 0 : Init();
1178 0 : }
1179 :
1180 0 : CacheKeysArgs::~CacheKeysArgs()
1181 : {
1182 0 : }
1183 :
1184 0 : auto CacheKeysArgs::operator==(const CacheKeysArgs& _o) const -> bool
1185 : {
1186 0 : if ((!((requestOrVoid()) == ((_o).requestOrVoid())))) {
1187 0 : return false;
1188 : }
1189 0 : if ((!((params()) == ((_o).params())))) {
1190 0 : return false;
1191 : }
1192 0 : return true;
1193 : }
1194 :
1195 0 : auto CacheKeysArgs::operator!=(const CacheKeysArgs& _o) const -> bool
1196 : {
1197 0 : return (!(operator==(_o)));
1198 : }
1199 :
1200 0 : auto CacheKeysArgs::Init() -> void
1201 : {
1202 0 : }
1203 :
1204 0 : auto CacheKeysArgs::Assign(
1205 : const CacheRequestOrVoid& _requestOrVoid,
1206 : const CacheQueryParams& _params) -> void
1207 : {
1208 0 : requestOrVoid_ = _requestOrVoid;
1209 0 : params_ = _params;
1210 0 : }
1211 :
1212 : } // namespace cache
1213 : } // namespace dom
1214 : } // namespace mozilla
1215 :
1216 : //-----------------------------------------------------------------------------
1217 : // Method definitions for the IPDL type |struct StorageMatchArgs|
1218 : //
1219 : namespace mozilla {
1220 : namespace dom {
1221 : namespace cache {
1222 0 : MOZ_IMPLICIT StorageMatchArgs::StorageMatchArgs()
1223 : {
1224 0 : Init();
1225 0 : }
1226 :
1227 0 : StorageMatchArgs::~StorageMatchArgs()
1228 : {
1229 0 : }
1230 :
1231 0 : auto StorageMatchArgs::operator==(const StorageMatchArgs& _o) const -> bool
1232 : {
1233 0 : if ((!((request()) == ((_o).request())))) {
1234 0 : return false;
1235 : }
1236 0 : if ((!((params()) == ((_o).params())))) {
1237 0 : return false;
1238 : }
1239 0 : return true;
1240 : }
1241 :
1242 0 : auto StorageMatchArgs::operator!=(const StorageMatchArgs& _o) const -> bool
1243 : {
1244 0 : return (!(operator==(_o)));
1245 : }
1246 :
1247 0 : auto StorageMatchArgs::Init() -> void
1248 : {
1249 0 : }
1250 :
1251 0 : auto StorageMatchArgs::Assign(
1252 : const CacheRequest& _request,
1253 : const CacheQueryParams& _params) -> void
1254 : {
1255 0 : request_ = _request;
1256 0 : params_ = _params;
1257 0 : }
1258 :
1259 : } // namespace cache
1260 : } // namespace dom
1261 : } // namespace mozilla
1262 :
1263 : //-----------------------------------------------------------------------------
1264 : // Method definitions for the IPDL type |struct StorageHasArgs|
1265 : //
1266 : namespace mozilla {
1267 : namespace dom {
1268 : namespace cache {
1269 0 : MOZ_IMPLICIT StorageHasArgs::StorageHasArgs() :
1270 0 : key_()
1271 : {
1272 0 : Init();
1273 0 : }
1274 :
1275 0 : StorageHasArgs::~StorageHasArgs()
1276 : {
1277 0 : }
1278 :
1279 0 : auto StorageHasArgs::operator==(const StorageHasArgs& _o) const -> bool
1280 : {
1281 0 : if ((!((key()) == ((_o).key())))) {
1282 0 : return false;
1283 : }
1284 0 : return true;
1285 : }
1286 :
1287 0 : auto StorageHasArgs::operator!=(const StorageHasArgs& _o) const -> bool
1288 : {
1289 0 : return (!(operator==(_o)));
1290 : }
1291 :
1292 0 : auto StorageHasArgs::Init() -> void
1293 : {
1294 0 : }
1295 :
1296 0 : auto StorageHasArgs::Assign(const nsString& _key) -> void
1297 : {
1298 0 : key_ = _key;
1299 0 : }
1300 :
1301 : } // namespace cache
1302 : } // namespace dom
1303 : } // namespace mozilla
1304 :
1305 : //-----------------------------------------------------------------------------
1306 : // Method definitions for the IPDL type |struct StorageOpenArgs|
1307 : //
1308 : namespace mozilla {
1309 : namespace dom {
1310 : namespace cache {
1311 0 : MOZ_IMPLICIT StorageOpenArgs::StorageOpenArgs() :
1312 0 : key_()
1313 : {
1314 0 : Init();
1315 0 : }
1316 :
1317 0 : StorageOpenArgs::~StorageOpenArgs()
1318 : {
1319 0 : }
1320 :
1321 0 : auto StorageOpenArgs::operator==(const StorageOpenArgs& _o) const -> bool
1322 : {
1323 0 : if ((!((key()) == ((_o).key())))) {
1324 0 : return false;
1325 : }
1326 0 : return true;
1327 : }
1328 :
1329 0 : auto StorageOpenArgs::operator!=(const StorageOpenArgs& _o) const -> bool
1330 : {
1331 0 : return (!(operator==(_o)));
1332 : }
1333 :
1334 0 : auto StorageOpenArgs::Init() -> void
1335 : {
1336 0 : }
1337 :
1338 0 : auto StorageOpenArgs::Assign(const nsString& _key) -> void
1339 : {
1340 0 : key_ = _key;
1341 0 : }
1342 :
1343 : } // namespace cache
1344 : } // namespace dom
1345 : } // namespace mozilla
1346 :
1347 : //-----------------------------------------------------------------------------
1348 : // Method definitions for the IPDL type |struct StorageDeleteArgs|
1349 : //
1350 : namespace mozilla {
1351 : namespace dom {
1352 : namespace cache {
1353 0 : MOZ_IMPLICIT StorageDeleteArgs::StorageDeleteArgs() :
1354 0 : key_()
1355 : {
1356 0 : Init();
1357 0 : }
1358 :
1359 0 : StorageDeleteArgs::~StorageDeleteArgs()
1360 : {
1361 0 : }
1362 :
1363 0 : auto StorageDeleteArgs::operator==(const StorageDeleteArgs& _o) const -> bool
1364 : {
1365 0 : if ((!((key()) == ((_o).key())))) {
1366 0 : return false;
1367 : }
1368 0 : return true;
1369 : }
1370 :
1371 0 : auto StorageDeleteArgs::operator!=(const StorageDeleteArgs& _o) const -> bool
1372 : {
1373 0 : return (!(operator==(_o)));
1374 : }
1375 :
1376 0 : auto StorageDeleteArgs::Init() -> void
1377 : {
1378 0 : }
1379 :
1380 0 : auto StorageDeleteArgs::Assign(const nsString& _key) -> void
1381 : {
1382 0 : key_ = _key;
1383 0 : }
1384 :
1385 : } // namespace cache
1386 : } // namespace dom
1387 : } // namespace mozilla
1388 :
1389 : //-----------------------------------------------------------------------------
1390 : // Method definitions for the IPDL type |struct StorageKeysArgs|
1391 : //
1392 : namespace mozilla {
1393 : namespace dom {
1394 : namespace cache {
1395 0 : StorageKeysArgs::~StorageKeysArgs()
1396 : {
1397 0 : }
1398 :
1399 0 : auto StorageKeysArgs::operator==(const StorageKeysArgs& _o) const -> bool
1400 : {
1401 0 : return true;
1402 : }
1403 :
1404 0 : auto StorageKeysArgs::operator!=(const StorageKeysArgs& _o) const -> bool
1405 : {
1406 0 : return (!(operator==(_o)));
1407 : }
1408 :
1409 0 : auto StorageKeysArgs::Init() -> void
1410 : {
1411 0 : }
1412 :
1413 0 : auto StorageKeysArgs::Assign() -> void
1414 : {
1415 0 : }
1416 :
1417 : } // namespace cache
1418 : } // namespace dom
1419 : } // namespace mozilla
1420 :
1421 : //-----------------------------------------------------------------------------
1422 : // Method definitions for the IPDL type |union CacheOpArgs|
1423 : //
1424 : namespace mozilla {
1425 : namespace dom {
1426 : namespace cache {
1427 0 : auto CacheOpArgs::MaybeDestroy(Type aNewType) -> bool
1428 : {
1429 0 : if ((mType) == (T__None)) {
1430 0 : return true;
1431 : }
1432 0 : if ((mType) == (aNewType)) {
1433 0 : return false;
1434 : }
1435 0 : switch (mType) {
1436 : case TCacheMatchArgs:
1437 : {
1438 0 : (ptr_CacheMatchArgs())->~CacheMatchArgs__tdef();
1439 0 : break;
1440 : }
1441 : case TCacheMatchAllArgs:
1442 : {
1443 0 : (ptr_CacheMatchAllArgs())->~CacheMatchAllArgs__tdef();
1444 0 : break;
1445 : }
1446 : case TCachePutAllArgs:
1447 : {
1448 0 : (ptr_CachePutAllArgs())->~CachePutAllArgs__tdef();
1449 0 : break;
1450 : }
1451 : case TCacheDeleteArgs:
1452 : {
1453 0 : (ptr_CacheDeleteArgs())->~CacheDeleteArgs__tdef();
1454 0 : break;
1455 : }
1456 : case TCacheKeysArgs:
1457 : {
1458 0 : (ptr_CacheKeysArgs())->~CacheKeysArgs__tdef();
1459 0 : break;
1460 : }
1461 : case TStorageMatchArgs:
1462 : {
1463 0 : (ptr_StorageMatchArgs())->~StorageMatchArgs__tdef();
1464 0 : break;
1465 : }
1466 : case TStorageHasArgs:
1467 : {
1468 0 : (ptr_StorageHasArgs())->~StorageHasArgs__tdef();
1469 0 : break;
1470 : }
1471 : case TStorageOpenArgs:
1472 : {
1473 0 : (ptr_StorageOpenArgs())->~StorageOpenArgs__tdef();
1474 0 : break;
1475 : }
1476 : case TStorageDeleteArgs:
1477 : {
1478 0 : (ptr_StorageDeleteArgs())->~StorageDeleteArgs__tdef();
1479 0 : break;
1480 : }
1481 : case TStorageKeysArgs:
1482 : {
1483 0 : (ptr_StorageKeysArgs())->~StorageKeysArgs__tdef();
1484 0 : break;
1485 : }
1486 : default:
1487 : {
1488 0 : mozilla::ipc::LogicError("not reached");
1489 0 : break;
1490 : }
1491 : }
1492 0 : return true;
1493 : }
1494 :
1495 0 : MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheMatchArgs& aOther)
1496 : {
1497 0 : new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(aOther);
1498 0 : mType = TCacheMatchArgs;
1499 0 : }
1500 :
1501 0 : MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheMatchAllArgs& aOther)
1502 : {
1503 0 : new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(aOther);
1504 0 : mType = TCacheMatchAllArgs;
1505 0 : }
1506 :
1507 0 : MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CachePutAllArgs& aOther)
1508 : {
1509 0 : new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(aOther);
1510 0 : mType = TCachePutAllArgs;
1511 0 : }
1512 :
1513 0 : MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheDeleteArgs& aOther)
1514 : {
1515 0 : new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(aOther);
1516 0 : mType = TCacheDeleteArgs;
1517 0 : }
1518 :
1519 0 : MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheKeysArgs& aOther)
1520 : {
1521 0 : new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(aOther);
1522 0 : mType = TCacheKeysArgs;
1523 0 : }
1524 :
1525 0 : MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageMatchArgs& aOther)
1526 : {
1527 0 : new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(aOther);
1528 0 : mType = TStorageMatchArgs;
1529 0 : }
1530 :
1531 0 : MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageHasArgs& aOther)
1532 : {
1533 0 : new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(aOther);
1534 0 : mType = TStorageHasArgs;
1535 0 : }
1536 :
1537 0 : MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageOpenArgs& aOther)
1538 : {
1539 0 : new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(aOther);
1540 0 : mType = TStorageOpenArgs;
1541 0 : }
1542 :
1543 0 : MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageDeleteArgs& aOther)
1544 : {
1545 0 : new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(aOther);
1546 0 : mType = TStorageDeleteArgs;
1547 0 : }
1548 :
1549 0 : MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageKeysArgs& aOther)
1550 : {
1551 0 : new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(aOther);
1552 0 : mType = TStorageKeysArgs;
1553 0 : }
1554 :
1555 0 : MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheOpArgs& aOther)
1556 : {
1557 0 : (aOther).AssertSanity();
1558 0 : switch ((aOther).type()) {
1559 : case TCacheMatchArgs:
1560 : {
1561 0 : new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs((aOther).get_CacheMatchArgs());
1562 0 : break;
1563 : }
1564 : case TCacheMatchAllArgs:
1565 : {
1566 0 : new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs((aOther).get_CacheMatchAllArgs());
1567 0 : break;
1568 : }
1569 : case TCachePutAllArgs:
1570 : {
1571 0 : new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs((aOther).get_CachePutAllArgs());
1572 0 : break;
1573 : }
1574 : case TCacheDeleteArgs:
1575 : {
1576 0 : new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs((aOther).get_CacheDeleteArgs());
1577 0 : break;
1578 : }
1579 : case TCacheKeysArgs:
1580 : {
1581 0 : new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs((aOther).get_CacheKeysArgs());
1582 0 : break;
1583 : }
1584 : case TStorageMatchArgs:
1585 : {
1586 0 : new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs((aOther).get_StorageMatchArgs());
1587 0 : break;
1588 : }
1589 : case TStorageHasArgs:
1590 : {
1591 0 : new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs((aOther).get_StorageHasArgs());
1592 0 : break;
1593 : }
1594 : case TStorageOpenArgs:
1595 : {
1596 0 : new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs((aOther).get_StorageOpenArgs());
1597 0 : break;
1598 : }
1599 : case TStorageDeleteArgs:
1600 : {
1601 0 : new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs((aOther).get_StorageDeleteArgs());
1602 0 : break;
1603 : }
1604 : case TStorageKeysArgs:
1605 : {
1606 0 : new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs((aOther).get_StorageKeysArgs());
1607 0 : break;
1608 : }
1609 : case T__None:
1610 : {
1611 0 : break;
1612 : }
1613 : default:
1614 : {
1615 0 : mozilla::ipc::LogicError("unreached");
1616 0 : return;
1617 : }
1618 : }
1619 0 : mType = (aOther).type();
1620 : }
1621 :
1622 0 : CacheOpArgs::~CacheOpArgs()
1623 : {
1624 0 : static_cast<void>(MaybeDestroy(T__None));
1625 0 : }
1626 :
1627 0 : auto CacheOpArgs::operator=(const CacheMatchArgs& aRhs) -> CacheOpArgs&
1628 : {
1629 0 : if (MaybeDestroy(TCacheMatchArgs)) {
1630 0 : new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs;
1631 : }
1632 0 : (*(ptr_CacheMatchArgs())) = aRhs;
1633 0 : mType = TCacheMatchArgs;
1634 0 : return (*(this));
1635 : }
1636 :
1637 0 : auto CacheOpArgs::operator=(const CacheMatchAllArgs& aRhs) -> CacheOpArgs&
1638 : {
1639 0 : if (MaybeDestroy(TCacheMatchAllArgs)) {
1640 0 : new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs;
1641 : }
1642 0 : (*(ptr_CacheMatchAllArgs())) = aRhs;
1643 0 : mType = TCacheMatchAllArgs;
1644 0 : return (*(this));
1645 : }
1646 :
1647 0 : auto CacheOpArgs::operator=(const CachePutAllArgs& aRhs) -> CacheOpArgs&
1648 : {
1649 0 : if (MaybeDestroy(TCachePutAllArgs)) {
1650 0 : new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs;
1651 : }
1652 0 : (*(ptr_CachePutAllArgs())) = aRhs;
1653 0 : mType = TCachePutAllArgs;
1654 0 : return (*(this));
1655 : }
1656 :
1657 0 : auto CacheOpArgs::operator=(const CacheDeleteArgs& aRhs) -> CacheOpArgs&
1658 : {
1659 0 : if (MaybeDestroy(TCacheDeleteArgs)) {
1660 0 : new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs;
1661 : }
1662 0 : (*(ptr_CacheDeleteArgs())) = aRhs;
1663 0 : mType = TCacheDeleteArgs;
1664 0 : return (*(this));
1665 : }
1666 :
1667 0 : auto CacheOpArgs::operator=(const CacheKeysArgs& aRhs) -> CacheOpArgs&
1668 : {
1669 0 : if (MaybeDestroy(TCacheKeysArgs)) {
1670 0 : new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs;
1671 : }
1672 0 : (*(ptr_CacheKeysArgs())) = aRhs;
1673 0 : mType = TCacheKeysArgs;
1674 0 : return (*(this));
1675 : }
1676 :
1677 0 : auto CacheOpArgs::operator=(const StorageMatchArgs& aRhs) -> CacheOpArgs&
1678 : {
1679 0 : if (MaybeDestroy(TStorageMatchArgs)) {
1680 0 : new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs;
1681 : }
1682 0 : (*(ptr_StorageMatchArgs())) = aRhs;
1683 0 : mType = TStorageMatchArgs;
1684 0 : return (*(this));
1685 : }
1686 :
1687 0 : auto CacheOpArgs::operator=(const StorageHasArgs& aRhs) -> CacheOpArgs&
1688 : {
1689 0 : if (MaybeDestroy(TStorageHasArgs)) {
1690 0 : new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs;
1691 : }
1692 0 : (*(ptr_StorageHasArgs())) = aRhs;
1693 0 : mType = TStorageHasArgs;
1694 0 : return (*(this));
1695 : }
1696 :
1697 0 : auto CacheOpArgs::operator=(const StorageOpenArgs& aRhs) -> CacheOpArgs&
1698 : {
1699 0 : if (MaybeDestroy(TStorageOpenArgs)) {
1700 0 : new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs;
1701 : }
1702 0 : (*(ptr_StorageOpenArgs())) = aRhs;
1703 0 : mType = TStorageOpenArgs;
1704 0 : return (*(this));
1705 : }
1706 :
1707 0 : auto CacheOpArgs::operator=(const StorageDeleteArgs& aRhs) -> CacheOpArgs&
1708 : {
1709 0 : if (MaybeDestroy(TStorageDeleteArgs)) {
1710 0 : new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs;
1711 : }
1712 0 : (*(ptr_StorageDeleteArgs())) = aRhs;
1713 0 : mType = TStorageDeleteArgs;
1714 0 : return (*(this));
1715 : }
1716 :
1717 0 : auto CacheOpArgs::operator=(const StorageKeysArgs& aRhs) -> CacheOpArgs&
1718 : {
1719 0 : if (MaybeDestroy(TStorageKeysArgs)) {
1720 0 : new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs;
1721 : }
1722 0 : (*(ptr_StorageKeysArgs())) = aRhs;
1723 0 : mType = TStorageKeysArgs;
1724 0 : return (*(this));
1725 : }
1726 :
1727 0 : auto CacheOpArgs::operator=(const CacheOpArgs& aRhs) -> CacheOpArgs&
1728 : {
1729 0 : (aRhs).AssertSanity();
1730 0 : Type t = (aRhs).type();
1731 0 : switch (t) {
1732 : case TCacheMatchArgs:
1733 : {
1734 0 : if (MaybeDestroy(t)) {
1735 0 : new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs;
1736 : }
1737 0 : (*(ptr_CacheMatchArgs())) = (aRhs).get_CacheMatchArgs();
1738 0 : break;
1739 : }
1740 : case TCacheMatchAllArgs:
1741 : {
1742 0 : if (MaybeDestroy(t)) {
1743 0 : new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs;
1744 : }
1745 0 : (*(ptr_CacheMatchAllArgs())) = (aRhs).get_CacheMatchAllArgs();
1746 0 : break;
1747 : }
1748 : case TCachePutAllArgs:
1749 : {
1750 0 : if (MaybeDestroy(t)) {
1751 0 : new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs;
1752 : }
1753 0 : (*(ptr_CachePutAllArgs())) = (aRhs).get_CachePutAllArgs();
1754 0 : break;
1755 : }
1756 : case TCacheDeleteArgs:
1757 : {
1758 0 : if (MaybeDestroy(t)) {
1759 0 : new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs;
1760 : }
1761 0 : (*(ptr_CacheDeleteArgs())) = (aRhs).get_CacheDeleteArgs();
1762 0 : break;
1763 : }
1764 : case TCacheKeysArgs:
1765 : {
1766 0 : if (MaybeDestroy(t)) {
1767 0 : new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs;
1768 : }
1769 0 : (*(ptr_CacheKeysArgs())) = (aRhs).get_CacheKeysArgs();
1770 0 : break;
1771 : }
1772 : case TStorageMatchArgs:
1773 : {
1774 0 : if (MaybeDestroy(t)) {
1775 0 : new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs;
1776 : }
1777 0 : (*(ptr_StorageMatchArgs())) = (aRhs).get_StorageMatchArgs();
1778 0 : break;
1779 : }
1780 : case TStorageHasArgs:
1781 : {
1782 0 : if (MaybeDestroy(t)) {
1783 0 : new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs;
1784 : }
1785 0 : (*(ptr_StorageHasArgs())) = (aRhs).get_StorageHasArgs();
1786 0 : break;
1787 : }
1788 : case TStorageOpenArgs:
1789 : {
1790 0 : if (MaybeDestroy(t)) {
1791 0 : new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs;
1792 : }
1793 0 : (*(ptr_StorageOpenArgs())) = (aRhs).get_StorageOpenArgs();
1794 0 : break;
1795 : }
1796 : case TStorageDeleteArgs:
1797 : {
1798 0 : if (MaybeDestroy(t)) {
1799 0 : new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs;
1800 : }
1801 0 : (*(ptr_StorageDeleteArgs())) = (aRhs).get_StorageDeleteArgs();
1802 0 : break;
1803 : }
1804 : case TStorageKeysArgs:
1805 : {
1806 0 : if (MaybeDestroy(t)) {
1807 0 : new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs;
1808 : }
1809 0 : (*(ptr_StorageKeysArgs())) = (aRhs).get_StorageKeysArgs();
1810 0 : break;
1811 : }
1812 : case T__None:
1813 : {
1814 0 : static_cast<void>(MaybeDestroy(t));
1815 0 : break;
1816 : }
1817 : default:
1818 : {
1819 0 : mozilla::ipc::LogicError("unreached");
1820 0 : break;
1821 : }
1822 : }
1823 0 : mType = t;
1824 0 : return (*(this));
1825 : }
1826 :
1827 0 : auto CacheOpArgs::operator==(const CacheMatchArgs& aRhs) const -> bool
1828 : {
1829 0 : return (get_CacheMatchArgs()) == (aRhs);
1830 : }
1831 :
1832 0 : auto CacheOpArgs::operator==(const CacheMatchAllArgs& aRhs) const -> bool
1833 : {
1834 0 : return (get_CacheMatchAllArgs()) == (aRhs);
1835 : }
1836 :
1837 0 : auto CacheOpArgs::operator==(const CachePutAllArgs& aRhs) const -> bool
1838 : {
1839 0 : return (get_CachePutAllArgs()) == (aRhs);
1840 : }
1841 :
1842 0 : auto CacheOpArgs::operator==(const CacheDeleteArgs& aRhs) const -> bool
1843 : {
1844 0 : return (get_CacheDeleteArgs()) == (aRhs);
1845 : }
1846 :
1847 0 : auto CacheOpArgs::operator==(const CacheKeysArgs& aRhs) const -> bool
1848 : {
1849 0 : return (get_CacheKeysArgs()) == (aRhs);
1850 : }
1851 :
1852 0 : auto CacheOpArgs::operator==(const StorageMatchArgs& aRhs) const -> bool
1853 : {
1854 0 : return (get_StorageMatchArgs()) == (aRhs);
1855 : }
1856 :
1857 0 : auto CacheOpArgs::operator==(const StorageHasArgs& aRhs) const -> bool
1858 : {
1859 0 : return (get_StorageHasArgs()) == (aRhs);
1860 : }
1861 :
1862 0 : auto CacheOpArgs::operator==(const StorageOpenArgs& aRhs) const -> bool
1863 : {
1864 0 : return (get_StorageOpenArgs()) == (aRhs);
1865 : }
1866 :
1867 0 : auto CacheOpArgs::operator==(const StorageDeleteArgs& aRhs) const -> bool
1868 : {
1869 0 : return (get_StorageDeleteArgs()) == (aRhs);
1870 : }
1871 :
1872 0 : auto CacheOpArgs::operator==(const StorageKeysArgs& aRhs) const -> bool
1873 : {
1874 0 : return (get_StorageKeysArgs()) == (aRhs);
1875 : }
1876 :
1877 0 : auto CacheOpArgs::operator==(const CacheOpArgs& aRhs) const -> bool
1878 : {
1879 0 : if ((type()) != ((aRhs).type())) {
1880 0 : return false;
1881 : }
1882 :
1883 0 : switch (type()) {
1884 : case TCacheMatchArgs:
1885 : {
1886 0 : return (get_CacheMatchArgs()) == ((aRhs).get_CacheMatchArgs());
1887 : }
1888 : case TCacheMatchAllArgs:
1889 : {
1890 0 : return (get_CacheMatchAllArgs()) == ((aRhs).get_CacheMatchAllArgs());
1891 : }
1892 : case TCachePutAllArgs:
1893 : {
1894 0 : return (get_CachePutAllArgs()) == ((aRhs).get_CachePutAllArgs());
1895 : }
1896 : case TCacheDeleteArgs:
1897 : {
1898 0 : return (get_CacheDeleteArgs()) == ((aRhs).get_CacheDeleteArgs());
1899 : }
1900 : case TCacheKeysArgs:
1901 : {
1902 0 : return (get_CacheKeysArgs()) == ((aRhs).get_CacheKeysArgs());
1903 : }
1904 : case TStorageMatchArgs:
1905 : {
1906 0 : return (get_StorageMatchArgs()) == ((aRhs).get_StorageMatchArgs());
1907 : }
1908 : case TStorageHasArgs:
1909 : {
1910 0 : return (get_StorageHasArgs()) == ((aRhs).get_StorageHasArgs());
1911 : }
1912 : case TStorageOpenArgs:
1913 : {
1914 0 : return (get_StorageOpenArgs()) == ((aRhs).get_StorageOpenArgs());
1915 : }
1916 : case TStorageDeleteArgs:
1917 : {
1918 0 : return (get_StorageDeleteArgs()) == ((aRhs).get_StorageDeleteArgs());
1919 : }
1920 : case TStorageKeysArgs:
1921 : {
1922 0 : return (get_StorageKeysArgs()) == ((aRhs).get_StorageKeysArgs());
1923 : }
1924 : default:
1925 : {
1926 0 : mozilla::ipc::LogicError("unreached");
1927 0 : return false;
1928 : }
1929 : }
1930 : }
1931 :
1932 0 : auto CacheOpArgs::get(CacheMatchArgs* aOutValue) const -> void
1933 : {
1934 0 : (*(aOutValue)) = get_CacheMatchArgs();
1935 0 : }
1936 :
1937 0 : auto CacheOpArgs::get(CacheMatchAllArgs* aOutValue) const -> void
1938 : {
1939 0 : (*(aOutValue)) = get_CacheMatchAllArgs();
1940 0 : }
1941 :
1942 0 : auto CacheOpArgs::get(CachePutAllArgs* aOutValue) const -> void
1943 : {
1944 0 : (*(aOutValue)) = get_CachePutAllArgs();
1945 0 : }
1946 :
1947 0 : auto CacheOpArgs::get(CacheDeleteArgs* aOutValue) const -> void
1948 : {
1949 0 : (*(aOutValue)) = get_CacheDeleteArgs();
1950 0 : }
1951 :
1952 0 : auto CacheOpArgs::get(CacheKeysArgs* aOutValue) const -> void
1953 : {
1954 0 : (*(aOutValue)) = get_CacheKeysArgs();
1955 0 : }
1956 :
1957 0 : auto CacheOpArgs::get(StorageMatchArgs* aOutValue) const -> void
1958 : {
1959 0 : (*(aOutValue)) = get_StorageMatchArgs();
1960 0 : }
1961 :
1962 0 : auto CacheOpArgs::get(StorageHasArgs* aOutValue) const -> void
1963 : {
1964 0 : (*(aOutValue)) = get_StorageHasArgs();
1965 0 : }
1966 :
1967 0 : auto CacheOpArgs::get(StorageOpenArgs* aOutValue) const -> void
1968 : {
1969 0 : (*(aOutValue)) = get_StorageOpenArgs();
1970 0 : }
1971 :
1972 0 : auto CacheOpArgs::get(StorageDeleteArgs* aOutValue) const -> void
1973 : {
1974 0 : (*(aOutValue)) = get_StorageDeleteArgs();
1975 0 : }
1976 :
1977 0 : auto CacheOpArgs::get(StorageKeysArgs* aOutValue) const -> void
1978 : {
1979 0 : (*(aOutValue)) = get_StorageKeysArgs();
1980 0 : }
1981 :
1982 : } // namespace cache
1983 : } // namespace dom
1984 : } // namespace mozilla
1985 :
1986 : //-----------------------------------------------------------------------------
1987 : // Method definitions for the IPDL type |struct CacheMatchResult|
1988 : //
1989 : namespace mozilla {
1990 : namespace dom {
1991 : namespace cache {
1992 0 : MOZ_IMPLICIT CacheMatchResult::CacheMatchResult()
1993 : {
1994 0 : Init();
1995 0 : }
1996 :
1997 0 : CacheMatchResult::~CacheMatchResult()
1998 : {
1999 0 : }
2000 :
2001 0 : auto CacheMatchResult::operator==(const CacheMatchResult& _o) const -> bool
2002 : {
2003 0 : if ((!((responseOrVoid()) == ((_o).responseOrVoid())))) {
2004 0 : return false;
2005 : }
2006 0 : return true;
2007 : }
2008 :
2009 0 : auto CacheMatchResult::operator!=(const CacheMatchResult& _o) const -> bool
2010 : {
2011 0 : return (!(operator==(_o)));
2012 : }
2013 :
2014 0 : auto CacheMatchResult::Init() -> void
2015 : {
2016 0 : }
2017 :
2018 0 : auto CacheMatchResult::Assign(const CacheResponseOrVoid& _responseOrVoid) -> void
2019 : {
2020 0 : responseOrVoid_ = _responseOrVoid;
2021 0 : }
2022 :
2023 : } // namespace cache
2024 : } // namespace dom
2025 : } // namespace mozilla
2026 :
2027 : //-----------------------------------------------------------------------------
2028 : // Method definitions for the IPDL type |struct CacheMatchAllResult|
2029 : //
2030 : namespace mozilla {
2031 : namespace dom {
2032 : namespace cache {
2033 0 : MOZ_IMPLICIT CacheMatchAllResult::CacheMatchAllResult()
2034 : {
2035 0 : Init();
2036 0 : }
2037 :
2038 0 : CacheMatchAllResult::~CacheMatchAllResult()
2039 : {
2040 0 : }
2041 :
2042 0 : auto CacheMatchAllResult::operator==(const CacheMatchAllResult& _o) const -> bool
2043 : {
2044 0 : if ((!((responseList()) == ((_o).responseList())))) {
2045 0 : return false;
2046 : }
2047 0 : return true;
2048 : }
2049 :
2050 0 : auto CacheMatchAllResult::operator!=(const CacheMatchAllResult& _o) const -> bool
2051 : {
2052 0 : return (!(operator==(_o)));
2053 : }
2054 :
2055 0 : auto CacheMatchAllResult::Init() -> void
2056 : {
2057 0 : }
2058 :
2059 0 : auto CacheMatchAllResult::Assign(const nsTArray<CacheResponse>& _responseList) -> void
2060 : {
2061 0 : responseList_ = _responseList;
2062 0 : }
2063 :
2064 : } // namespace cache
2065 : } // namespace dom
2066 : } // namespace mozilla
2067 :
2068 : //-----------------------------------------------------------------------------
2069 : // Method definitions for the IPDL type |struct CachePutAllResult|
2070 : //
2071 : namespace mozilla {
2072 : namespace dom {
2073 : namespace cache {
2074 0 : CachePutAllResult::~CachePutAllResult()
2075 : {
2076 0 : }
2077 :
2078 0 : auto CachePutAllResult::operator==(const CachePutAllResult& _o) const -> bool
2079 : {
2080 0 : return true;
2081 : }
2082 :
2083 0 : auto CachePutAllResult::operator!=(const CachePutAllResult& _o) const -> bool
2084 : {
2085 0 : return (!(operator==(_o)));
2086 : }
2087 :
2088 0 : auto CachePutAllResult::Init() -> void
2089 : {
2090 0 : }
2091 :
2092 0 : auto CachePutAllResult::Assign() -> void
2093 : {
2094 0 : }
2095 :
2096 : } // namespace cache
2097 : } // namespace dom
2098 : } // namespace mozilla
2099 :
2100 : //-----------------------------------------------------------------------------
2101 : // Method definitions for the IPDL type |struct CacheDeleteResult|
2102 : //
2103 : namespace mozilla {
2104 : namespace dom {
2105 : namespace cache {
2106 0 : MOZ_IMPLICIT CacheDeleteResult::CacheDeleteResult() :
2107 0 : success_()
2108 : {
2109 0 : Init();
2110 0 : }
2111 :
2112 0 : CacheDeleteResult::~CacheDeleteResult()
2113 : {
2114 0 : }
2115 :
2116 0 : auto CacheDeleteResult::operator==(const CacheDeleteResult& _o) const -> bool
2117 : {
2118 0 : if ((!((success()) == ((_o).success())))) {
2119 0 : return false;
2120 : }
2121 0 : return true;
2122 : }
2123 :
2124 0 : auto CacheDeleteResult::operator!=(const CacheDeleteResult& _o) const -> bool
2125 : {
2126 0 : return (!(operator==(_o)));
2127 : }
2128 :
2129 0 : auto CacheDeleteResult::Init() -> void
2130 : {
2131 0 : }
2132 :
2133 0 : auto CacheDeleteResult::Assign(const bool& _success) -> void
2134 : {
2135 0 : success_ = _success;
2136 0 : }
2137 :
2138 : } // namespace cache
2139 : } // namespace dom
2140 : } // namespace mozilla
2141 :
2142 : //-----------------------------------------------------------------------------
2143 : // Method definitions for the IPDL type |struct CacheKeysResult|
2144 : //
2145 : namespace mozilla {
2146 : namespace dom {
2147 : namespace cache {
2148 0 : MOZ_IMPLICIT CacheKeysResult::CacheKeysResult()
2149 : {
2150 0 : Init();
2151 0 : }
2152 :
2153 0 : CacheKeysResult::~CacheKeysResult()
2154 : {
2155 0 : }
2156 :
2157 0 : auto CacheKeysResult::operator==(const CacheKeysResult& _o) const -> bool
2158 : {
2159 0 : if ((!((requestList()) == ((_o).requestList())))) {
2160 0 : return false;
2161 : }
2162 0 : return true;
2163 : }
2164 :
2165 0 : auto CacheKeysResult::operator!=(const CacheKeysResult& _o) const -> bool
2166 : {
2167 0 : return (!(operator==(_o)));
2168 : }
2169 :
2170 0 : auto CacheKeysResult::Init() -> void
2171 : {
2172 0 : }
2173 :
2174 0 : auto CacheKeysResult::Assign(const nsTArray<CacheRequest>& _requestList) -> void
2175 : {
2176 0 : requestList_ = _requestList;
2177 0 : }
2178 :
2179 : } // namespace cache
2180 : } // namespace dom
2181 : } // namespace mozilla
2182 :
2183 : //-----------------------------------------------------------------------------
2184 : // Method definitions for the IPDL type |struct StorageMatchResult|
2185 : //
2186 : namespace mozilla {
2187 : namespace dom {
2188 : namespace cache {
2189 0 : MOZ_IMPLICIT StorageMatchResult::StorageMatchResult()
2190 : {
2191 0 : Init();
2192 0 : }
2193 :
2194 0 : StorageMatchResult::~StorageMatchResult()
2195 : {
2196 0 : }
2197 :
2198 0 : auto StorageMatchResult::operator==(const StorageMatchResult& _o) const -> bool
2199 : {
2200 0 : if ((!((responseOrVoid()) == ((_o).responseOrVoid())))) {
2201 0 : return false;
2202 : }
2203 0 : return true;
2204 : }
2205 :
2206 0 : auto StorageMatchResult::operator!=(const StorageMatchResult& _o) const -> bool
2207 : {
2208 0 : return (!(operator==(_o)));
2209 : }
2210 :
2211 0 : auto StorageMatchResult::Init() -> void
2212 : {
2213 0 : }
2214 :
2215 0 : auto StorageMatchResult::Assign(const CacheResponseOrVoid& _responseOrVoid) -> void
2216 : {
2217 0 : responseOrVoid_ = _responseOrVoid;
2218 0 : }
2219 :
2220 : } // namespace cache
2221 : } // namespace dom
2222 : } // namespace mozilla
2223 :
2224 : //-----------------------------------------------------------------------------
2225 : // Method definitions for the IPDL type |struct StorageHasResult|
2226 : //
2227 : namespace mozilla {
2228 : namespace dom {
2229 : namespace cache {
2230 0 : MOZ_IMPLICIT StorageHasResult::StorageHasResult() :
2231 0 : success_()
2232 : {
2233 0 : Init();
2234 0 : }
2235 :
2236 0 : StorageHasResult::~StorageHasResult()
2237 : {
2238 0 : }
2239 :
2240 0 : auto StorageHasResult::operator==(const StorageHasResult& _o) const -> bool
2241 : {
2242 0 : if ((!((success()) == ((_o).success())))) {
2243 0 : return false;
2244 : }
2245 0 : return true;
2246 : }
2247 :
2248 0 : auto StorageHasResult::operator!=(const StorageHasResult& _o) const -> bool
2249 : {
2250 0 : return (!(operator==(_o)));
2251 : }
2252 :
2253 0 : auto StorageHasResult::Init() -> void
2254 : {
2255 0 : }
2256 :
2257 0 : auto StorageHasResult::Assign(const bool& _success) -> void
2258 : {
2259 0 : success_ = _success;
2260 0 : }
2261 :
2262 : } // namespace cache
2263 : } // namespace dom
2264 : } // namespace mozilla
2265 :
2266 : //-----------------------------------------------------------------------------
2267 : // Method definitions for the IPDL type |struct StorageOpenResult|
2268 : //
2269 : namespace mozilla {
2270 : namespace dom {
2271 : namespace cache {
2272 0 : MOZ_IMPLICIT StorageOpenResult::StorageOpenResult()
2273 : {
2274 0 : Init();
2275 0 : }
2276 :
2277 0 : StorageOpenResult::~StorageOpenResult()
2278 : {
2279 0 : }
2280 :
2281 0 : auto StorageOpenResult::operator==(const StorageOpenResult& _o) const -> bool
2282 : {
2283 0 : if ((!((actorParent()) == ((_o).actorParent())))) {
2284 0 : return false;
2285 : }
2286 0 : if ((!((actorChild()) == ((_o).actorChild())))) {
2287 0 : return false;
2288 : }
2289 0 : return true;
2290 : }
2291 :
2292 0 : auto StorageOpenResult::operator!=(const StorageOpenResult& _o) const -> bool
2293 : {
2294 0 : return (!(operator==(_o)));
2295 : }
2296 :
2297 0 : auto StorageOpenResult::Init() -> void
2298 : {
2299 0 : actorParent_ = nullptr;
2300 0 : actorChild_ = nullptr;
2301 0 : }
2302 :
2303 0 : auto StorageOpenResult::Assign(
2304 : PCacheParent* _actorParent,
2305 : PCacheChild* _actorChild) -> void
2306 : {
2307 0 : actorParent_ = _actorParent;
2308 0 : actorChild_ = _actorChild;
2309 0 : }
2310 :
2311 : } // namespace cache
2312 : } // namespace dom
2313 : } // namespace mozilla
2314 :
2315 : //-----------------------------------------------------------------------------
2316 : // Method definitions for the IPDL type |struct StorageDeleteResult|
2317 : //
2318 : namespace mozilla {
2319 : namespace dom {
2320 : namespace cache {
2321 0 : MOZ_IMPLICIT StorageDeleteResult::StorageDeleteResult() :
2322 0 : success_()
2323 : {
2324 0 : Init();
2325 0 : }
2326 :
2327 0 : StorageDeleteResult::~StorageDeleteResult()
2328 : {
2329 0 : }
2330 :
2331 0 : auto StorageDeleteResult::operator==(const StorageDeleteResult& _o) const -> bool
2332 : {
2333 0 : if ((!((success()) == ((_o).success())))) {
2334 0 : return false;
2335 : }
2336 0 : return true;
2337 : }
2338 :
2339 0 : auto StorageDeleteResult::operator!=(const StorageDeleteResult& _o) const -> bool
2340 : {
2341 0 : return (!(operator==(_o)));
2342 : }
2343 :
2344 0 : auto StorageDeleteResult::Init() -> void
2345 : {
2346 0 : }
2347 :
2348 0 : auto StorageDeleteResult::Assign(const bool& _success) -> void
2349 : {
2350 0 : success_ = _success;
2351 0 : }
2352 :
2353 : } // namespace cache
2354 : } // namespace dom
2355 : } // namespace mozilla
2356 :
2357 : //-----------------------------------------------------------------------------
2358 : // Method definitions for the IPDL type |struct StorageKeysResult|
2359 : //
2360 : namespace mozilla {
2361 : namespace dom {
2362 : namespace cache {
2363 0 : MOZ_IMPLICIT StorageKeysResult::StorageKeysResult()
2364 : {
2365 0 : Init();
2366 0 : }
2367 :
2368 0 : StorageKeysResult::~StorageKeysResult()
2369 : {
2370 0 : }
2371 :
2372 0 : auto StorageKeysResult::operator==(const StorageKeysResult& _o) const -> bool
2373 : {
2374 0 : if ((!((keyList()) == ((_o).keyList())))) {
2375 0 : return false;
2376 : }
2377 0 : return true;
2378 : }
2379 :
2380 0 : auto StorageKeysResult::operator!=(const StorageKeysResult& _o) const -> bool
2381 : {
2382 0 : return (!(operator==(_o)));
2383 : }
2384 :
2385 0 : auto StorageKeysResult::Init() -> void
2386 : {
2387 0 : }
2388 :
2389 0 : auto StorageKeysResult::Assign(const nsTArray<nsString>& _keyList) -> void
2390 : {
2391 0 : keyList_ = _keyList;
2392 0 : }
2393 :
2394 : } // namespace cache
2395 : } // namespace dom
2396 : } // namespace mozilla
2397 :
2398 : //-----------------------------------------------------------------------------
2399 : // Method definitions for the IPDL type |union CacheOpResult|
2400 : //
2401 : namespace mozilla {
2402 : namespace dom {
2403 : namespace cache {
2404 0 : auto CacheOpResult::MaybeDestroy(Type aNewType) -> bool
2405 : {
2406 0 : if ((mType) == (T__None)) {
2407 0 : return true;
2408 : }
2409 0 : if ((mType) == (aNewType)) {
2410 0 : return false;
2411 : }
2412 0 : switch (mType) {
2413 : case Tvoid_t:
2414 : {
2415 0 : (ptr_void_t())->~void_t__tdef();
2416 0 : break;
2417 : }
2418 : case TCacheMatchResult:
2419 : {
2420 0 : (ptr_CacheMatchResult())->~CacheMatchResult__tdef();
2421 0 : break;
2422 : }
2423 : case TCacheMatchAllResult:
2424 : {
2425 0 : (ptr_CacheMatchAllResult())->~CacheMatchAllResult__tdef();
2426 0 : break;
2427 : }
2428 : case TCachePutAllResult:
2429 : {
2430 0 : (ptr_CachePutAllResult())->~CachePutAllResult__tdef();
2431 0 : break;
2432 : }
2433 : case TCacheDeleteResult:
2434 : {
2435 0 : (ptr_CacheDeleteResult())->~CacheDeleteResult__tdef();
2436 0 : break;
2437 : }
2438 : case TCacheKeysResult:
2439 : {
2440 0 : (ptr_CacheKeysResult())->~CacheKeysResult__tdef();
2441 0 : break;
2442 : }
2443 : case TStorageMatchResult:
2444 : {
2445 0 : (ptr_StorageMatchResult())->~StorageMatchResult__tdef();
2446 0 : break;
2447 : }
2448 : case TStorageHasResult:
2449 : {
2450 0 : (ptr_StorageHasResult())->~StorageHasResult__tdef();
2451 0 : break;
2452 : }
2453 : case TStorageOpenResult:
2454 : {
2455 0 : (ptr_StorageOpenResult())->~StorageOpenResult__tdef();
2456 0 : break;
2457 : }
2458 : case TStorageDeleteResult:
2459 : {
2460 0 : (ptr_StorageDeleteResult())->~StorageDeleteResult__tdef();
2461 0 : break;
2462 : }
2463 : case TStorageKeysResult:
2464 : {
2465 0 : (ptr_StorageKeysResult())->~StorageKeysResult__tdef();
2466 0 : break;
2467 : }
2468 : default:
2469 : {
2470 0 : mozilla::ipc::LogicError("not reached");
2471 0 : break;
2472 : }
2473 : }
2474 0 : return true;
2475 : }
2476 :
2477 0 : MOZ_IMPLICIT CacheOpResult::CacheOpResult(const void_t& aOther)
2478 : {
2479 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
2480 0 : mType = Tvoid_t;
2481 0 : }
2482 :
2483 0 : MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheMatchResult& aOther)
2484 : {
2485 0 : new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(aOther);
2486 0 : mType = TCacheMatchResult;
2487 0 : }
2488 :
2489 0 : MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheMatchAllResult& aOther)
2490 : {
2491 0 : new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(aOther);
2492 0 : mType = TCacheMatchAllResult;
2493 0 : }
2494 :
2495 0 : MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CachePutAllResult& aOther)
2496 : {
2497 0 : new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(aOther);
2498 0 : mType = TCachePutAllResult;
2499 0 : }
2500 :
2501 0 : MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheDeleteResult& aOther)
2502 : {
2503 0 : new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(aOther);
2504 0 : mType = TCacheDeleteResult;
2505 0 : }
2506 :
2507 0 : MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheKeysResult& aOther)
2508 : {
2509 0 : new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(aOther);
2510 0 : mType = TCacheKeysResult;
2511 0 : }
2512 :
2513 0 : MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageMatchResult& aOther)
2514 : {
2515 0 : new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(aOther);
2516 0 : mType = TStorageMatchResult;
2517 0 : }
2518 :
2519 0 : MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageHasResult& aOther)
2520 : {
2521 0 : new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(aOther);
2522 0 : mType = TStorageHasResult;
2523 0 : }
2524 :
2525 0 : MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageOpenResult& aOther)
2526 : {
2527 0 : new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(aOther);
2528 0 : mType = TStorageOpenResult;
2529 0 : }
2530 :
2531 0 : MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageDeleteResult& aOther)
2532 : {
2533 0 : new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(aOther);
2534 0 : mType = TStorageDeleteResult;
2535 0 : }
2536 :
2537 0 : MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageKeysResult& aOther)
2538 : {
2539 0 : new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(aOther);
2540 0 : mType = TStorageKeysResult;
2541 0 : }
2542 :
2543 0 : MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheOpResult& aOther)
2544 : {
2545 0 : (aOther).AssertSanity();
2546 0 : switch ((aOther).type()) {
2547 : case Tvoid_t:
2548 : {
2549 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
2550 0 : break;
2551 : }
2552 : case TCacheMatchResult:
2553 : {
2554 0 : new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult((aOther).get_CacheMatchResult());
2555 0 : break;
2556 : }
2557 : case TCacheMatchAllResult:
2558 : {
2559 0 : new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult((aOther).get_CacheMatchAllResult());
2560 0 : break;
2561 : }
2562 : case TCachePutAllResult:
2563 : {
2564 0 : new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult((aOther).get_CachePutAllResult());
2565 0 : break;
2566 : }
2567 : case TCacheDeleteResult:
2568 : {
2569 0 : new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult((aOther).get_CacheDeleteResult());
2570 0 : break;
2571 : }
2572 : case TCacheKeysResult:
2573 : {
2574 0 : new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult((aOther).get_CacheKeysResult());
2575 0 : break;
2576 : }
2577 : case TStorageMatchResult:
2578 : {
2579 0 : new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult((aOther).get_StorageMatchResult());
2580 0 : break;
2581 : }
2582 : case TStorageHasResult:
2583 : {
2584 0 : new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult((aOther).get_StorageHasResult());
2585 0 : break;
2586 : }
2587 : case TStorageOpenResult:
2588 : {
2589 0 : new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult((aOther).get_StorageOpenResult());
2590 0 : break;
2591 : }
2592 : case TStorageDeleteResult:
2593 : {
2594 0 : new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult((aOther).get_StorageDeleteResult());
2595 0 : break;
2596 : }
2597 : case TStorageKeysResult:
2598 : {
2599 0 : new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult((aOther).get_StorageKeysResult());
2600 0 : break;
2601 : }
2602 : case T__None:
2603 : {
2604 0 : break;
2605 : }
2606 : default:
2607 : {
2608 0 : mozilla::ipc::LogicError("unreached");
2609 0 : return;
2610 : }
2611 : }
2612 0 : mType = (aOther).type();
2613 : }
2614 :
2615 0 : CacheOpResult::~CacheOpResult()
2616 : {
2617 0 : static_cast<void>(MaybeDestroy(T__None));
2618 0 : }
2619 :
2620 0 : auto CacheOpResult::operator=(const void_t& aRhs) -> CacheOpResult&
2621 : {
2622 0 : if (MaybeDestroy(Tvoid_t)) {
2623 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
2624 : }
2625 0 : (*(ptr_void_t())) = aRhs;
2626 0 : mType = Tvoid_t;
2627 0 : return (*(this));
2628 : }
2629 :
2630 0 : auto CacheOpResult::operator=(const CacheMatchResult& aRhs) -> CacheOpResult&
2631 : {
2632 0 : if (MaybeDestroy(TCacheMatchResult)) {
2633 0 : new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult;
2634 : }
2635 0 : (*(ptr_CacheMatchResult())) = aRhs;
2636 0 : mType = TCacheMatchResult;
2637 0 : return (*(this));
2638 : }
2639 :
2640 0 : auto CacheOpResult::operator=(const CacheMatchAllResult& aRhs) -> CacheOpResult&
2641 : {
2642 0 : if (MaybeDestroy(TCacheMatchAllResult)) {
2643 0 : new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult;
2644 : }
2645 0 : (*(ptr_CacheMatchAllResult())) = aRhs;
2646 0 : mType = TCacheMatchAllResult;
2647 0 : return (*(this));
2648 : }
2649 :
2650 0 : auto CacheOpResult::operator=(const CachePutAllResult& aRhs) -> CacheOpResult&
2651 : {
2652 0 : if (MaybeDestroy(TCachePutAllResult)) {
2653 0 : new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult;
2654 : }
2655 0 : (*(ptr_CachePutAllResult())) = aRhs;
2656 0 : mType = TCachePutAllResult;
2657 0 : return (*(this));
2658 : }
2659 :
2660 0 : auto CacheOpResult::operator=(const CacheDeleteResult& aRhs) -> CacheOpResult&
2661 : {
2662 0 : if (MaybeDestroy(TCacheDeleteResult)) {
2663 0 : new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult;
2664 : }
2665 0 : (*(ptr_CacheDeleteResult())) = aRhs;
2666 0 : mType = TCacheDeleteResult;
2667 0 : return (*(this));
2668 : }
2669 :
2670 0 : auto CacheOpResult::operator=(const CacheKeysResult& aRhs) -> CacheOpResult&
2671 : {
2672 0 : if (MaybeDestroy(TCacheKeysResult)) {
2673 0 : new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult;
2674 : }
2675 0 : (*(ptr_CacheKeysResult())) = aRhs;
2676 0 : mType = TCacheKeysResult;
2677 0 : return (*(this));
2678 : }
2679 :
2680 0 : auto CacheOpResult::operator=(const StorageMatchResult& aRhs) -> CacheOpResult&
2681 : {
2682 0 : if (MaybeDestroy(TStorageMatchResult)) {
2683 0 : new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult;
2684 : }
2685 0 : (*(ptr_StorageMatchResult())) = aRhs;
2686 0 : mType = TStorageMatchResult;
2687 0 : return (*(this));
2688 : }
2689 :
2690 0 : auto CacheOpResult::operator=(const StorageHasResult& aRhs) -> CacheOpResult&
2691 : {
2692 0 : if (MaybeDestroy(TStorageHasResult)) {
2693 0 : new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult;
2694 : }
2695 0 : (*(ptr_StorageHasResult())) = aRhs;
2696 0 : mType = TStorageHasResult;
2697 0 : return (*(this));
2698 : }
2699 :
2700 0 : auto CacheOpResult::operator=(const StorageOpenResult& aRhs) -> CacheOpResult&
2701 : {
2702 0 : if (MaybeDestroy(TStorageOpenResult)) {
2703 0 : new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult;
2704 : }
2705 0 : (*(ptr_StorageOpenResult())) = aRhs;
2706 0 : mType = TStorageOpenResult;
2707 0 : return (*(this));
2708 : }
2709 :
2710 0 : auto CacheOpResult::operator=(const StorageDeleteResult& aRhs) -> CacheOpResult&
2711 : {
2712 0 : if (MaybeDestroy(TStorageDeleteResult)) {
2713 0 : new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult;
2714 : }
2715 0 : (*(ptr_StorageDeleteResult())) = aRhs;
2716 0 : mType = TStorageDeleteResult;
2717 0 : return (*(this));
2718 : }
2719 :
2720 0 : auto CacheOpResult::operator=(const StorageKeysResult& aRhs) -> CacheOpResult&
2721 : {
2722 0 : if (MaybeDestroy(TStorageKeysResult)) {
2723 0 : new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult;
2724 : }
2725 0 : (*(ptr_StorageKeysResult())) = aRhs;
2726 0 : mType = TStorageKeysResult;
2727 0 : return (*(this));
2728 : }
2729 :
2730 0 : auto CacheOpResult::operator=(const CacheOpResult& aRhs) -> CacheOpResult&
2731 : {
2732 0 : (aRhs).AssertSanity();
2733 0 : Type t = (aRhs).type();
2734 0 : switch (t) {
2735 : case Tvoid_t:
2736 : {
2737 0 : if (MaybeDestroy(t)) {
2738 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
2739 : }
2740 0 : (*(ptr_void_t())) = (aRhs).get_void_t();
2741 0 : break;
2742 : }
2743 : case TCacheMatchResult:
2744 : {
2745 0 : if (MaybeDestroy(t)) {
2746 0 : new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult;
2747 : }
2748 0 : (*(ptr_CacheMatchResult())) = (aRhs).get_CacheMatchResult();
2749 0 : break;
2750 : }
2751 : case TCacheMatchAllResult:
2752 : {
2753 0 : if (MaybeDestroy(t)) {
2754 0 : new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult;
2755 : }
2756 0 : (*(ptr_CacheMatchAllResult())) = (aRhs).get_CacheMatchAllResult();
2757 0 : break;
2758 : }
2759 : case TCachePutAllResult:
2760 : {
2761 0 : if (MaybeDestroy(t)) {
2762 0 : new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult;
2763 : }
2764 0 : (*(ptr_CachePutAllResult())) = (aRhs).get_CachePutAllResult();
2765 0 : break;
2766 : }
2767 : case TCacheDeleteResult:
2768 : {
2769 0 : if (MaybeDestroy(t)) {
2770 0 : new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult;
2771 : }
2772 0 : (*(ptr_CacheDeleteResult())) = (aRhs).get_CacheDeleteResult();
2773 0 : break;
2774 : }
2775 : case TCacheKeysResult:
2776 : {
2777 0 : if (MaybeDestroy(t)) {
2778 0 : new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult;
2779 : }
2780 0 : (*(ptr_CacheKeysResult())) = (aRhs).get_CacheKeysResult();
2781 0 : break;
2782 : }
2783 : case TStorageMatchResult:
2784 : {
2785 0 : if (MaybeDestroy(t)) {
2786 0 : new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult;
2787 : }
2788 0 : (*(ptr_StorageMatchResult())) = (aRhs).get_StorageMatchResult();
2789 0 : break;
2790 : }
2791 : case TStorageHasResult:
2792 : {
2793 0 : if (MaybeDestroy(t)) {
2794 0 : new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult;
2795 : }
2796 0 : (*(ptr_StorageHasResult())) = (aRhs).get_StorageHasResult();
2797 0 : break;
2798 : }
2799 : case TStorageOpenResult:
2800 : {
2801 0 : if (MaybeDestroy(t)) {
2802 0 : new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult;
2803 : }
2804 0 : (*(ptr_StorageOpenResult())) = (aRhs).get_StorageOpenResult();
2805 0 : break;
2806 : }
2807 : case TStorageDeleteResult:
2808 : {
2809 0 : if (MaybeDestroy(t)) {
2810 0 : new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult;
2811 : }
2812 0 : (*(ptr_StorageDeleteResult())) = (aRhs).get_StorageDeleteResult();
2813 0 : break;
2814 : }
2815 : case TStorageKeysResult:
2816 : {
2817 0 : if (MaybeDestroy(t)) {
2818 0 : new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult;
2819 : }
2820 0 : (*(ptr_StorageKeysResult())) = (aRhs).get_StorageKeysResult();
2821 0 : break;
2822 : }
2823 : case T__None:
2824 : {
2825 0 : static_cast<void>(MaybeDestroy(t));
2826 0 : break;
2827 : }
2828 : default:
2829 : {
2830 0 : mozilla::ipc::LogicError("unreached");
2831 0 : break;
2832 : }
2833 : }
2834 0 : mType = t;
2835 0 : return (*(this));
2836 : }
2837 :
2838 0 : auto CacheOpResult::operator==(const void_t& aRhs) const -> bool
2839 : {
2840 0 : return (get_void_t()) == (aRhs);
2841 : }
2842 :
2843 0 : auto CacheOpResult::operator==(const CacheMatchResult& aRhs) const -> bool
2844 : {
2845 0 : return (get_CacheMatchResult()) == (aRhs);
2846 : }
2847 :
2848 0 : auto CacheOpResult::operator==(const CacheMatchAllResult& aRhs) const -> bool
2849 : {
2850 0 : return (get_CacheMatchAllResult()) == (aRhs);
2851 : }
2852 :
2853 0 : auto CacheOpResult::operator==(const CachePutAllResult& aRhs) const -> bool
2854 : {
2855 0 : return (get_CachePutAllResult()) == (aRhs);
2856 : }
2857 :
2858 0 : auto CacheOpResult::operator==(const CacheDeleteResult& aRhs) const -> bool
2859 : {
2860 0 : return (get_CacheDeleteResult()) == (aRhs);
2861 : }
2862 :
2863 0 : auto CacheOpResult::operator==(const CacheKeysResult& aRhs) const -> bool
2864 : {
2865 0 : return (get_CacheKeysResult()) == (aRhs);
2866 : }
2867 :
2868 0 : auto CacheOpResult::operator==(const StorageMatchResult& aRhs) const -> bool
2869 : {
2870 0 : return (get_StorageMatchResult()) == (aRhs);
2871 : }
2872 :
2873 0 : auto CacheOpResult::operator==(const StorageHasResult& aRhs) const -> bool
2874 : {
2875 0 : return (get_StorageHasResult()) == (aRhs);
2876 : }
2877 :
2878 0 : auto CacheOpResult::operator==(const StorageOpenResult& aRhs) const -> bool
2879 : {
2880 0 : return (get_StorageOpenResult()) == (aRhs);
2881 : }
2882 :
2883 0 : auto CacheOpResult::operator==(const StorageDeleteResult& aRhs) const -> bool
2884 : {
2885 0 : return (get_StorageDeleteResult()) == (aRhs);
2886 : }
2887 :
2888 0 : auto CacheOpResult::operator==(const StorageKeysResult& aRhs) const -> bool
2889 : {
2890 0 : return (get_StorageKeysResult()) == (aRhs);
2891 : }
2892 :
2893 0 : auto CacheOpResult::operator==(const CacheOpResult& aRhs) const -> bool
2894 : {
2895 0 : if ((type()) != ((aRhs).type())) {
2896 0 : return false;
2897 : }
2898 :
2899 0 : switch (type()) {
2900 : case Tvoid_t:
2901 : {
2902 0 : return (get_void_t()) == ((aRhs).get_void_t());
2903 : }
2904 : case TCacheMatchResult:
2905 : {
2906 0 : return (get_CacheMatchResult()) == ((aRhs).get_CacheMatchResult());
2907 : }
2908 : case TCacheMatchAllResult:
2909 : {
2910 0 : return (get_CacheMatchAllResult()) == ((aRhs).get_CacheMatchAllResult());
2911 : }
2912 : case TCachePutAllResult:
2913 : {
2914 0 : return (get_CachePutAllResult()) == ((aRhs).get_CachePutAllResult());
2915 : }
2916 : case TCacheDeleteResult:
2917 : {
2918 0 : return (get_CacheDeleteResult()) == ((aRhs).get_CacheDeleteResult());
2919 : }
2920 : case TCacheKeysResult:
2921 : {
2922 0 : return (get_CacheKeysResult()) == ((aRhs).get_CacheKeysResult());
2923 : }
2924 : case TStorageMatchResult:
2925 : {
2926 0 : return (get_StorageMatchResult()) == ((aRhs).get_StorageMatchResult());
2927 : }
2928 : case TStorageHasResult:
2929 : {
2930 0 : return (get_StorageHasResult()) == ((aRhs).get_StorageHasResult());
2931 : }
2932 : case TStorageOpenResult:
2933 : {
2934 0 : return (get_StorageOpenResult()) == ((aRhs).get_StorageOpenResult());
2935 : }
2936 : case TStorageDeleteResult:
2937 : {
2938 0 : return (get_StorageDeleteResult()) == ((aRhs).get_StorageDeleteResult());
2939 : }
2940 : case TStorageKeysResult:
2941 : {
2942 0 : return (get_StorageKeysResult()) == ((aRhs).get_StorageKeysResult());
2943 : }
2944 : default:
2945 : {
2946 0 : mozilla::ipc::LogicError("unreached");
2947 0 : return false;
2948 : }
2949 : }
2950 : }
2951 :
2952 0 : auto CacheOpResult::get(void_t* aOutValue) const -> void
2953 : {
2954 0 : (*(aOutValue)) = get_void_t();
2955 0 : }
2956 :
2957 0 : auto CacheOpResult::get(CacheMatchResult* aOutValue) const -> void
2958 : {
2959 0 : (*(aOutValue)) = get_CacheMatchResult();
2960 0 : }
2961 :
2962 0 : auto CacheOpResult::get(CacheMatchAllResult* aOutValue) const -> void
2963 : {
2964 0 : (*(aOutValue)) = get_CacheMatchAllResult();
2965 0 : }
2966 :
2967 0 : auto CacheOpResult::get(CachePutAllResult* aOutValue) const -> void
2968 : {
2969 0 : (*(aOutValue)) = get_CachePutAllResult();
2970 0 : }
2971 :
2972 0 : auto CacheOpResult::get(CacheDeleteResult* aOutValue) const -> void
2973 : {
2974 0 : (*(aOutValue)) = get_CacheDeleteResult();
2975 0 : }
2976 :
2977 0 : auto CacheOpResult::get(CacheKeysResult* aOutValue) const -> void
2978 : {
2979 0 : (*(aOutValue)) = get_CacheKeysResult();
2980 0 : }
2981 :
2982 0 : auto CacheOpResult::get(StorageMatchResult* aOutValue) const -> void
2983 : {
2984 0 : (*(aOutValue)) = get_StorageMatchResult();
2985 0 : }
2986 :
2987 0 : auto CacheOpResult::get(StorageHasResult* aOutValue) const -> void
2988 : {
2989 0 : (*(aOutValue)) = get_StorageHasResult();
2990 0 : }
2991 :
2992 0 : auto CacheOpResult::get(StorageOpenResult* aOutValue) const -> void
2993 : {
2994 0 : (*(aOutValue)) = get_StorageOpenResult();
2995 0 : }
2996 :
2997 0 : auto CacheOpResult::get(StorageDeleteResult* aOutValue) const -> void
2998 : {
2999 0 : (*(aOutValue)) = get_StorageDeleteResult();
3000 0 : }
3001 :
3002 0 : auto CacheOpResult::get(StorageKeysResult* aOutValue) const -> void
3003 : {
3004 0 : (*(aOutValue)) = get_StorageKeysResult();
3005 0 : }
3006 :
3007 : } // namespace cache
3008 : } // namespace dom
3009 : } // namespace mozilla
|
