Line data Source code
1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/dom/indexedDB/PBackgroundIDBSharedTypes.h"
8 :
9 :
10 : //-----------------------------------------------------------------------------
11 : // Method definitions for the IPDL type |struct SerializedKeyRange|
12 : //
13 : namespace mozilla {
14 : namespace dom {
15 : namespace indexedDB {
16 0 : MOZ_IMPLICIT SerializedKeyRange::SerializedKeyRange() :
17 : lower_(),
18 : upper_(),
19 : lowerOpen_(),
20 : upperOpen_(),
21 0 : isOnly_()
22 : {
23 0 : Init();
24 0 : }
25 :
26 0 : SerializedKeyRange::~SerializedKeyRange()
27 : {
28 0 : }
29 :
30 0 : auto SerializedKeyRange::operator==(const SerializedKeyRange& _o) const -> bool
31 : {
32 0 : if ((!((lower()) == ((_o).lower())))) {
33 0 : return false;
34 : }
35 0 : if ((!((upper()) == ((_o).upper())))) {
36 0 : return false;
37 : }
38 0 : if ((!((lowerOpen()) == ((_o).lowerOpen())))) {
39 0 : return false;
40 : }
41 0 : if ((!((upperOpen()) == ((_o).upperOpen())))) {
42 0 : return false;
43 : }
44 0 : if ((!((isOnly()) == ((_o).isOnly())))) {
45 0 : return false;
46 : }
47 0 : return true;
48 : }
49 :
50 0 : auto SerializedKeyRange::operator!=(const SerializedKeyRange& _o) const -> bool
51 : {
52 0 : return (!(operator==(_o)));
53 : }
54 :
55 0 : auto SerializedKeyRange::Init() -> void
56 : {
57 0 : }
58 :
59 0 : auto SerializedKeyRange::Assign(
60 : const Key& _lower,
61 : const Key& _upper,
62 : const bool& _lowerOpen,
63 : const bool& _upperOpen,
64 : const bool& _isOnly) -> void
65 : {
66 0 : lower_ = _lower;
67 0 : upper_ = _upper;
68 0 : lowerOpen_ = _lowerOpen;
69 0 : upperOpen_ = _upperOpen;
70 0 : isOnly_ = _isOnly;
71 0 : }
72 :
73 : } // namespace indexedDB
74 : } // namespace dom
75 : } // namespace mozilla
76 :
77 : //-----------------------------------------------------------------------------
78 : // Method definitions for the IPDL type |union BlobOrMutableFile|
79 : //
80 : namespace mozilla {
81 : namespace dom {
82 : namespace indexedDB {
83 0 : auto BlobOrMutableFile::MaybeDestroy(Type aNewType) -> bool
84 : {
85 0 : if ((mType) == (T__None)) {
86 0 : return true;
87 : }
88 0 : if ((mType) == (aNewType)) {
89 0 : return false;
90 : }
91 0 : switch (mType) {
92 : case Tnull_t:
93 : {
94 0 : (ptr_null_t())->~null_t__tdef();
95 0 : break;
96 : }
97 : case TIPCBlob:
98 : {
99 0 : (ptr_IPCBlob())->~IPCBlob__tdef();
100 0 : break;
101 : }
102 : case TPBackgroundMutableFileParent:
103 : {
104 0 : (ptr_PBackgroundMutableFileParent())->~PBackgroundMutableFileParent__tdef();
105 0 : break;
106 : }
107 : case TPBackgroundMutableFileChild:
108 : {
109 0 : (ptr_PBackgroundMutableFileChild())->~PBackgroundMutableFileChild__tdef();
110 0 : break;
111 : }
112 : default:
113 : {
114 0 : mozilla::ipc::LogicError("not reached");
115 0 : break;
116 : }
117 : }
118 0 : return true;
119 : }
120 :
121 0 : MOZ_IMPLICIT BlobOrMutableFile::BlobOrMutableFile(const null_t& aOther)
122 : {
123 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
124 0 : mType = Tnull_t;
125 0 : }
126 :
127 0 : MOZ_IMPLICIT BlobOrMutableFile::BlobOrMutableFile(const IPCBlob& aOther)
128 : {
129 0 : new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(aOther);
130 0 : mType = TIPCBlob;
131 0 : }
132 :
133 0 : MOZ_IMPLICIT BlobOrMutableFile::BlobOrMutableFile(PBackgroundMutableFileParent* aOther)
134 : {
135 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileParent()) PBackgroundMutableFileParent*(const_cast<PBackgroundMutableFileParent*>(aOther));
136 0 : mType = TPBackgroundMutableFileParent;
137 0 : }
138 :
139 0 : MOZ_IMPLICIT BlobOrMutableFile::BlobOrMutableFile(PBackgroundMutableFileChild* aOther)
140 : {
141 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileChild()) PBackgroundMutableFileChild*(const_cast<PBackgroundMutableFileChild*>(aOther));
142 0 : mType = TPBackgroundMutableFileChild;
143 0 : }
144 :
145 0 : MOZ_IMPLICIT BlobOrMutableFile::BlobOrMutableFile(const BlobOrMutableFile& aOther)
146 : {
147 0 : (aOther).AssertSanity();
148 0 : switch ((aOther).type()) {
149 : case Tnull_t:
150 : {
151 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
152 0 : break;
153 : }
154 : case TIPCBlob:
155 : {
156 0 : new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob((aOther).get_IPCBlob());
157 0 : break;
158 : }
159 : case TPBackgroundMutableFileParent:
160 : {
161 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileParent()) PBackgroundMutableFileParent*(const_cast<PBackgroundMutableFileParent*>((aOther).get_PBackgroundMutableFileParent()));
162 0 : break;
163 : }
164 : case TPBackgroundMutableFileChild:
165 : {
166 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileChild()) PBackgroundMutableFileChild*(const_cast<PBackgroundMutableFileChild*>((aOther).get_PBackgroundMutableFileChild()));
167 0 : break;
168 : }
169 : case T__None:
170 : {
171 0 : break;
172 : }
173 : default:
174 : {
175 0 : mozilla::ipc::LogicError("unreached");
176 0 : return;
177 : }
178 : }
179 0 : mType = (aOther).type();
180 : }
181 :
182 0 : BlobOrMutableFile::~BlobOrMutableFile()
183 : {
184 0 : static_cast<void>(MaybeDestroy(T__None));
185 0 : }
186 :
187 0 : auto BlobOrMutableFile::operator=(const null_t& aRhs) -> BlobOrMutableFile&
188 : {
189 0 : if (MaybeDestroy(Tnull_t)) {
190 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
191 : }
192 0 : (*(ptr_null_t())) = aRhs;
193 0 : mType = Tnull_t;
194 0 : return (*(this));
195 : }
196 :
197 0 : auto BlobOrMutableFile::operator=(const IPCBlob& aRhs) -> BlobOrMutableFile&
198 : {
199 0 : if (MaybeDestroy(TIPCBlob)) {
200 0 : new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob;
201 : }
202 0 : (*(ptr_IPCBlob())) = aRhs;
203 0 : mType = TIPCBlob;
204 0 : return (*(this));
205 : }
206 :
207 0 : auto BlobOrMutableFile::operator=(PBackgroundMutableFileParent* aRhs) -> BlobOrMutableFile&
208 : {
209 0 : if (MaybeDestroy(TPBackgroundMutableFileParent)) {
210 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileParent()) PBackgroundMutableFileParent*;
211 : }
212 0 : (*(ptr_PBackgroundMutableFileParent())) = const_cast<PBackgroundMutableFileParent*>(aRhs);
213 0 : mType = TPBackgroundMutableFileParent;
214 0 : return (*(this));
215 : }
216 :
217 0 : auto BlobOrMutableFile::operator=(PBackgroundMutableFileChild* aRhs) -> BlobOrMutableFile&
218 : {
219 0 : if (MaybeDestroy(TPBackgroundMutableFileChild)) {
220 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileChild()) PBackgroundMutableFileChild*;
221 : }
222 0 : (*(ptr_PBackgroundMutableFileChild())) = const_cast<PBackgroundMutableFileChild*>(aRhs);
223 0 : mType = TPBackgroundMutableFileChild;
224 0 : return (*(this));
225 : }
226 :
227 0 : auto BlobOrMutableFile::operator=(const BlobOrMutableFile& aRhs) -> BlobOrMutableFile&
228 : {
229 0 : (aRhs).AssertSanity();
230 0 : Type t = (aRhs).type();
231 0 : switch (t) {
232 : case Tnull_t:
233 : {
234 0 : if (MaybeDestroy(t)) {
235 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
236 : }
237 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
238 0 : break;
239 : }
240 : case TIPCBlob:
241 : {
242 0 : if (MaybeDestroy(t)) {
243 0 : new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob;
244 : }
245 0 : (*(ptr_IPCBlob())) = (aRhs).get_IPCBlob();
246 0 : break;
247 : }
248 : case TPBackgroundMutableFileParent:
249 : {
250 0 : if (MaybeDestroy(t)) {
251 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileParent()) PBackgroundMutableFileParent*;
252 : }
253 0 : (*(ptr_PBackgroundMutableFileParent())) = const_cast<PBackgroundMutableFileParent*>((aRhs).get_PBackgroundMutableFileParent());
254 0 : break;
255 : }
256 : case TPBackgroundMutableFileChild:
257 : {
258 0 : if (MaybeDestroy(t)) {
259 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileChild()) PBackgroundMutableFileChild*;
260 : }
261 0 : (*(ptr_PBackgroundMutableFileChild())) = const_cast<PBackgroundMutableFileChild*>((aRhs).get_PBackgroundMutableFileChild());
262 0 : break;
263 : }
264 : case T__None:
265 : {
266 0 : static_cast<void>(MaybeDestroy(t));
267 0 : break;
268 : }
269 : default:
270 : {
271 0 : mozilla::ipc::LogicError("unreached");
272 0 : break;
273 : }
274 : }
275 0 : mType = t;
276 0 : return (*(this));
277 : }
278 :
279 0 : auto BlobOrMutableFile::operator==(const null_t& aRhs) const -> bool
280 : {
281 0 : return (get_null_t()) == (aRhs);
282 : }
283 :
284 0 : auto BlobOrMutableFile::operator==(const IPCBlob& aRhs) const -> bool
285 : {
286 0 : return (get_IPCBlob()) == (aRhs);
287 : }
288 :
289 0 : auto BlobOrMutableFile::operator==(PBackgroundMutableFileParent* aRhs) const -> bool
290 : {
291 0 : return (get_PBackgroundMutableFileParent()) == (aRhs);
292 : }
293 :
294 0 : auto BlobOrMutableFile::operator==(PBackgroundMutableFileChild* aRhs) const -> bool
295 : {
296 0 : return (get_PBackgroundMutableFileChild()) == (aRhs);
297 : }
298 :
299 0 : auto BlobOrMutableFile::operator==(const BlobOrMutableFile& aRhs) const -> bool
300 : {
301 0 : if ((type()) != ((aRhs).type())) {
302 0 : return false;
303 : }
304 :
305 0 : switch (type()) {
306 : case Tnull_t:
307 : {
308 0 : return (get_null_t()) == ((aRhs).get_null_t());
309 : }
310 : case TIPCBlob:
311 : {
312 0 : return (get_IPCBlob()) == ((aRhs).get_IPCBlob());
313 : }
314 : case TPBackgroundMutableFileParent:
315 : {
316 0 : return (get_PBackgroundMutableFileParent()) == ((aRhs).get_PBackgroundMutableFileParent());
317 : }
318 : case TPBackgroundMutableFileChild:
319 : {
320 0 : return (get_PBackgroundMutableFileChild()) == ((aRhs).get_PBackgroundMutableFileChild());
321 : }
322 : default:
323 : {
324 0 : mozilla::ipc::LogicError("unreached");
325 0 : return false;
326 : }
327 : }
328 : }
329 :
330 0 : auto BlobOrMutableFile::get(null_t* aOutValue) const -> void
331 : {
332 0 : (*(aOutValue)) = get_null_t();
333 0 : }
334 :
335 0 : auto BlobOrMutableFile::get(IPCBlob* aOutValue) const -> void
336 : {
337 0 : (*(aOutValue)) = get_IPCBlob();
338 0 : }
339 :
340 0 : auto BlobOrMutableFile::get(PBackgroundMutableFileParent** aOutValue) const -> void
341 : {
342 0 : (*(aOutValue)) = get_PBackgroundMutableFileParent();
343 0 : }
344 :
345 0 : auto BlobOrMutableFile::get(PBackgroundMutableFileChild** aOutValue) const -> void
346 : {
347 0 : (*(aOutValue)) = get_PBackgroundMutableFileChild();
348 0 : }
349 :
350 : } // namespace indexedDB
351 : } // namespace dom
352 : } // namespace mozilla
353 :
354 : //-----------------------------------------------------------------------------
355 : // Method definitions for the IPDL type |struct SerializedStructuredCloneFile|
356 : //
357 : namespace mozilla {
358 : namespace dom {
359 : namespace indexedDB {
360 0 : MOZ_IMPLICIT SerializedStructuredCloneFile::SerializedStructuredCloneFile() :
361 0 : type_()
362 : {
363 0 : Init();
364 0 : }
365 :
366 0 : SerializedStructuredCloneFile::~SerializedStructuredCloneFile()
367 : {
368 0 : }
369 :
370 0 : auto SerializedStructuredCloneFile::operator==(const SerializedStructuredCloneFile& _o) const -> bool
371 : {
372 0 : if ((!((file()) == ((_o).file())))) {
373 0 : return false;
374 : }
375 0 : if ((!((type()) == ((_o).type())))) {
376 0 : return false;
377 : }
378 0 : return true;
379 : }
380 :
381 0 : auto SerializedStructuredCloneFile::operator!=(const SerializedStructuredCloneFile& _o) const -> bool
382 : {
383 0 : return (!(operator==(_o)));
384 : }
385 :
386 0 : auto SerializedStructuredCloneFile::Init() -> void
387 : {
388 0 : }
389 :
390 0 : auto SerializedStructuredCloneFile::Assign(
391 : const BlobOrMutableFile& _file,
392 : const FileType& _type) -> void
393 : {
394 0 : file_ = _file;
395 0 : type_ = _type;
396 0 : }
397 :
398 : } // namespace indexedDB
399 : } // namespace dom
400 : } // namespace mozilla
401 :
402 : //-----------------------------------------------------------------------------
403 : // Method definitions for the IPDL type |struct SerializedStructuredCloneReadInfo|
404 : //
405 : namespace mozilla {
406 : namespace dom {
407 : namespace indexedDB {
408 0 : MOZ_IMPLICIT SerializedStructuredCloneReadInfo::SerializedStructuredCloneReadInfo() :
409 : data_(),
410 0 : hasPreprocessInfo_()
411 : {
412 0 : Init();
413 0 : }
414 :
415 0 : SerializedStructuredCloneReadInfo::~SerializedStructuredCloneReadInfo()
416 : {
417 0 : }
418 :
419 0 : auto SerializedStructuredCloneReadInfo::operator==(const SerializedStructuredCloneReadInfo& _o) const -> bool
420 : {
421 0 : if ((!((data()) == ((_o).data())))) {
422 0 : return false;
423 : }
424 0 : if ((!((files()) == ((_o).files())))) {
425 0 : return false;
426 : }
427 0 : if ((!((hasPreprocessInfo()) == ((_o).hasPreprocessInfo())))) {
428 0 : return false;
429 : }
430 0 : return true;
431 : }
432 :
433 0 : auto SerializedStructuredCloneReadInfo::operator!=(const SerializedStructuredCloneReadInfo& _o) const -> bool
434 : {
435 0 : return (!(operator==(_o)));
436 : }
437 :
438 0 : auto SerializedStructuredCloneReadInfo::Init() -> void
439 : {
440 0 : }
441 :
442 0 : auto SerializedStructuredCloneReadInfo::Assign(
443 : const SerializedStructuredCloneBuffer& _data,
444 : const nsTArray<SerializedStructuredCloneFile>& _files,
445 : const bool& _hasPreprocessInfo) -> void
446 : {
447 0 : data_ = _data;
448 0 : files_ = _files;
449 0 : hasPreprocessInfo_ = _hasPreprocessInfo;
450 0 : }
451 :
452 : } // namespace indexedDB
453 : } // namespace dom
454 : } // namespace mozilla
455 :
456 : //-----------------------------------------------------------------------------
457 : // Method definitions for the IPDL type |struct SerializedStructuredCloneWriteInfo|
458 : //
459 : namespace mozilla {
460 : namespace dom {
461 : namespace indexedDB {
462 0 : MOZ_IMPLICIT SerializedStructuredCloneWriteInfo::SerializedStructuredCloneWriteInfo() :
463 : data_(),
464 0 : offsetToKeyProp_()
465 : {
466 0 : Init();
467 0 : }
468 :
469 0 : SerializedStructuredCloneWriteInfo::~SerializedStructuredCloneWriteInfo()
470 : {
471 0 : }
472 :
473 0 : auto SerializedStructuredCloneWriteInfo::operator==(const SerializedStructuredCloneWriteInfo& _o) const -> bool
474 : {
475 0 : if ((!((data()) == ((_o).data())))) {
476 0 : return false;
477 : }
478 0 : if ((!((offsetToKeyProp()) == ((_o).offsetToKeyProp())))) {
479 0 : return false;
480 : }
481 0 : return true;
482 : }
483 :
484 0 : auto SerializedStructuredCloneWriteInfo::operator!=(const SerializedStructuredCloneWriteInfo& _o) const -> bool
485 : {
486 0 : return (!(operator==(_o)));
487 : }
488 :
489 0 : auto SerializedStructuredCloneWriteInfo::Init() -> void
490 : {
491 0 : }
492 :
493 0 : auto SerializedStructuredCloneWriteInfo::Assign(
494 : const SerializedStructuredCloneBuffer& _data,
495 : const uint64_t& _offsetToKeyProp) -> void
496 : {
497 0 : data_ = _data;
498 0 : offsetToKeyProp_ = _offsetToKeyProp;
499 0 : }
500 :
501 : } // namespace indexedDB
502 : } // namespace dom
503 : } // namespace mozilla
504 :
505 : //-----------------------------------------------------------------------------
506 : // Method definitions for the IPDL type |struct IndexUpdateInfo|
507 : //
508 : namespace mozilla {
509 : namespace dom {
510 : namespace indexedDB {
511 0 : MOZ_IMPLICIT IndexUpdateInfo::IndexUpdateInfo() :
512 : indexId_(),
513 : value_(),
514 0 : localizedValue_()
515 : {
516 0 : Init();
517 0 : }
518 :
519 0 : IndexUpdateInfo::~IndexUpdateInfo()
520 : {
521 0 : }
522 :
523 0 : auto IndexUpdateInfo::operator==(const IndexUpdateInfo& _o) const -> bool
524 : {
525 0 : if ((!((indexId()) == ((_o).indexId())))) {
526 0 : return false;
527 : }
528 0 : if ((!((value()) == ((_o).value())))) {
529 0 : return false;
530 : }
531 0 : if ((!((localizedValue()) == ((_o).localizedValue())))) {
532 0 : return false;
533 : }
534 0 : return true;
535 : }
536 :
537 0 : auto IndexUpdateInfo::operator!=(const IndexUpdateInfo& _o) const -> bool
538 : {
539 0 : return (!(operator==(_o)));
540 : }
541 :
542 0 : auto IndexUpdateInfo::Init() -> void
543 : {
544 0 : }
545 :
546 0 : auto IndexUpdateInfo::Assign(
547 : const int64_t& _indexId,
548 : const Key& _value,
549 : const Key& _localizedValue) -> void
550 : {
551 0 : indexId_ = _indexId;
552 0 : value_ = _value;
553 0 : localizedValue_ = _localizedValue;
554 0 : }
555 :
556 : } // namespace indexedDB
557 : } // namespace dom
558 : } // namespace mozilla
559 :
560 : //-----------------------------------------------------------------------------
561 : // Method definitions for the IPDL type |union OptionalKeyRange|
562 : //
563 : namespace mozilla {
564 : namespace dom {
565 : namespace indexedDB {
566 0 : auto OptionalKeyRange::MaybeDestroy(Type aNewType) -> bool
567 : {
568 0 : if ((mType) == (T__None)) {
569 0 : return true;
570 : }
571 0 : if ((mType) == (aNewType)) {
572 0 : return false;
573 : }
574 0 : switch (mType) {
575 : case TSerializedKeyRange:
576 : {
577 0 : (ptr_SerializedKeyRange())->~SerializedKeyRange__tdef();
578 0 : break;
579 : }
580 : case Tvoid_t:
581 : {
582 0 : (ptr_void_t())->~void_t__tdef();
583 0 : break;
584 : }
585 : default:
586 : {
587 0 : mozilla::ipc::LogicError("not reached");
588 0 : break;
589 : }
590 : }
591 0 : return true;
592 : }
593 :
594 0 : MOZ_IMPLICIT OptionalKeyRange::OptionalKeyRange(const SerializedKeyRange& aOther)
595 : {
596 0 : new (mozilla::KnownNotNull, ptr_SerializedKeyRange()) SerializedKeyRange(aOther);
597 0 : mType = TSerializedKeyRange;
598 0 : }
599 :
600 0 : MOZ_IMPLICIT OptionalKeyRange::OptionalKeyRange(const void_t& aOther)
601 : {
602 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
603 0 : mType = Tvoid_t;
604 0 : }
605 :
606 0 : MOZ_IMPLICIT OptionalKeyRange::OptionalKeyRange(const OptionalKeyRange& aOther)
607 : {
608 0 : (aOther).AssertSanity();
609 0 : switch ((aOther).type()) {
610 : case TSerializedKeyRange:
611 : {
612 0 : new (mozilla::KnownNotNull, ptr_SerializedKeyRange()) SerializedKeyRange((aOther).get_SerializedKeyRange());
613 0 : break;
614 : }
615 : case Tvoid_t:
616 : {
617 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
618 0 : break;
619 : }
620 : case T__None:
621 : {
622 0 : break;
623 : }
624 : default:
625 : {
626 0 : mozilla::ipc::LogicError("unreached");
627 0 : return;
628 : }
629 : }
630 0 : mType = (aOther).type();
631 : }
632 :
633 0 : OptionalKeyRange::~OptionalKeyRange()
634 : {
635 0 : static_cast<void>(MaybeDestroy(T__None));
636 0 : }
637 :
638 0 : auto OptionalKeyRange::operator=(const SerializedKeyRange& aRhs) -> OptionalKeyRange&
639 : {
640 0 : if (MaybeDestroy(TSerializedKeyRange)) {
641 0 : new (mozilla::KnownNotNull, ptr_SerializedKeyRange()) SerializedKeyRange;
642 : }
643 0 : (*(ptr_SerializedKeyRange())) = aRhs;
644 0 : mType = TSerializedKeyRange;
645 0 : return (*(this));
646 : }
647 :
648 0 : auto OptionalKeyRange::operator=(const void_t& aRhs) -> OptionalKeyRange&
649 : {
650 0 : if (MaybeDestroy(Tvoid_t)) {
651 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
652 : }
653 0 : (*(ptr_void_t())) = aRhs;
654 0 : mType = Tvoid_t;
655 0 : return (*(this));
656 : }
657 :
658 0 : auto OptionalKeyRange::operator=(const OptionalKeyRange& aRhs) -> OptionalKeyRange&
659 : {
660 0 : (aRhs).AssertSanity();
661 0 : Type t = (aRhs).type();
662 0 : switch (t) {
663 : case TSerializedKeyRange:
664 : {
665 0 : if (MaybeDestroy(t)) {
666 0 : new (mozilla::KnownNotNull, ptr_SerializedKeyRange()) SerializedKeyRange;
667 : }
668 0 : (*(ptr_SerializedKeyRange())) = (aRhs).get_SerializedKeyRange();
669 0 : break;
670 : }
671 : case Tvoid_t:
672 : {
673 0 : if (MaybeDestroy(t)) {
674 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
675 : }
676 0 : (*(ptr_void_t())) = (aRhs).get_void_t();
677 0 : break;
678 : }
679 : case T__None:
680 : {
681 0 : static_cast<void>(MaybeDestroy(t));
682 0 : break;
683 : }
684 : default:
685 : {
686 0 : mozilla::ipc::LogicError("unreached");
687 0 : break;
688 : }
689 : }
690 0 : mType = t;
691 0 : return (*(this));
692 : }
693 :
694 0 : auto OptionalKeyRange::operator==(const SerializedKeyRange& aRhs) const -> bool
695 : {
696 0 : return (get_SerializedKeyRange()) == (aRhs);
697 : }
698 :
699 0 : auto OptionalKeyRange::operator==(const void_t& aRhs) const -> bool
700 : {
701 0 : return (get_void_t()) == (aRhs);
702 : }
703 :
704 0 : auto OptionalKeyRange::operator==(const OptionalKeyRange& aRhs) const -> bool
705 : {
706 0 : if ((type()) != ((aRhs).type())) {
707 0 : return false;
708 : }
709 :
710 0 : switch (type()) {
711 : case TSerializedKeyRange:
712 : {
713 0 : return (get_SerializedKeyRange()) == ((aRhs).get_SerializedKeyRange());
714 : }
715 : case Tvoid_t:
716 : {
717 0 : return (get_void_t()) == ((aRhs).get_void_t());
718 : }
719 : default:
720 : {
721 0 : mozilla::ipc::LogicError("unreached");
722 0 : return false;
723 : }
724 : }
725 : }
726 :
727 0 : auto OptionalKeyRange::get(SerializedKeyRange* aOutValue) const -> void
728 : {
729 0 : (*(aOutValue)) = get_SerializedKeyRange();
730 0 : }
731 :
732 0 : auto OptionalKeyRange::get(void_t* aOutValue) const -> void
733 : {
734 0 : (*(aOutValue)) = get_void_t();
735 0 : }
736 :
737 : } // namespace indexedDB
738 : } // namespace dom
739 : } // namespace mozilla
740 :
741 : //-----------------------------------------------------------------------------
742 : // Method definitions for the IPDL type |struct DatabaseMetadata|
743 : //
744 : namespace mozilla {
745 : namespace dom {
746 : namespace indexedDB {
747 0 : MOZ_IMPLICIT DatabaseMetadata::DatabaseMetadata() :
748 : name_(),
749 : version_(),
750 0 : persistenceType_()
751 : {
752 0 : Init();
753 0 : }
754 :
755 0 : DatabaseMetadata::~DatabaseMetadata()
756 : {
757 0 : }
758 :
759 0 : auto DatabaseMetadata::operator==(const DatabaseMetadata& _o) const -> bool
760 : {
761 0 : if ((!((name()) == ((_o).name())))) {
762 0 : return false;
763 : }
764 0 : if ((!((version()) == ((_o).version())))) {
765 0 : return false;
766 : }
767 0 : if ((!((persistenceType()) == ((_o).persistenceType())))) {
768 0 : return false;
769 : }
770 0 : return true;
771 : }
772 :
773 0 : auto DatabaseMetadata::operator!=(const DatabaseMetadata& _o) const -> bool
774 : {
775 0 : return (!(operator==(_o)));
776 : }
777 :
778 0 : auto DatabaseMetadata::Init() -> void
779 : {
780 0 : }
781 :
782 0 : auto DatabaseMetadata::Assign(
783 : const nsString& _name,
784 : const uint64_t& _version,
785 : const PersistenceType& _persistenceType) -> void
786 : {
787 0 : name_ = _name;
788 0 : version_ = _version;
789 0 : persistenceType_ = _persistenceType;
790 0 : }
791 :
792 : } // namespace indexedDB
793 : } // namespace dom
794 : } // namespace mozilla
795 :
796 : //-----------------------------------------------------------------------------
797 : // Method definitions for the IPDL type |struct ObjectStoreMetadata|
798 : //
799 : namespace mozilla {
800 : namespace dom {
801 : namespace indexedDB {
802 0 : MOZ_IMPLICIT ObjectStoreMetadata::ObjectStoreMetadata() :
803 : id_(),
804 : name_(),
805 : keyPath_(),
806 0 : autoIncrement_()
807 : {
808 0 : Init();
809 0 : }
810 :
811 0 : ObjectStoreMetadata::~ObjectStoreMetadata()
812 : {
813 0 : }
814 :
815 0 : auto ObjectStoreMetadata::operator==(const ObjectStoreMetadata& _o) const -> bool
816 : {
817 0 : if ((!((id()) == ((_o).id())))) {
818 0 : return false;
819 : }
820 0 : if ((!((name()) == ((_o).name())))) {
821 0 : return false;
822 : }
823 0 : if ((!((keyPath()) == ((_o).keyPath())))) {
824 0 : return false;
825 : }
826 0 : if ((!((autoIncrement()) == ((_o).autoIncrement())))) {
827 0 : return false;
828 : }
829 0 : return true;
830 : }
831 :
832 0 : auto ObjectStoreMetadata::operator!=(const ObjectStoreMetadata& _o) const -> bool
833 : {
834 0 : return (!(operator==(_o)));
835 : }
836 :
837 0 : auto ObjectStoreMetadata::Init() -> void
838 : {
839 0 : }
840 :
841 0 : auto ObjectStoreMetadata::Assign(
842 : const int64_t& _id,
843 : const nsString& _name,
844 : const KeyPath& _keyPath,
845 : const bool& _autoIncrement) -> void
846 : {
847 0 : id_ = _id;
848 0 : name_ = _name;
849 0 : keyPath_ = _keyPath;
850 0 : autoIncrement_ = _autoIncrement;
851 0 : }
852 :
853 : } // namespace indexedDB
854 : } // namespace dom
855 : } // namespace mozilla
856 :
857 : //-----------------------------------------------------------------------------
858 : // Method definitions for the IPDL type |struct IndexMetadata|
859 : //
860 : namespace mozilla {
861 : namespace dom {
862 : namespace indexedDB {
863 0 : MOZ_IMPLICIT IndexMetadata::IndexMetadata() :
864 : id_(),
865 : name_(),
866 : keyPath_(),
867 : locale_(),
868 : unique_(),
869 : multiEntry_(),
870 0 : autoLocale_()
871 : {
872 0 : Init();
873 0 : }
874 :
875 0 : IndexMetadata::~IndexMetadata()
876 : {
877 0 : }
878 :
879 0 : auto IndexMetadata::operator==(const IndexMetadata& _o) const -> bool
880 : {
881 0 : if ((!((id()) == ((_o).id())))) {
882 0 : return false;
883 : }
884 0 : if ((!((name()) == ((_o).name())))) {
885 0 : return false;
886 : }
887 0 : if ((!((keyPath()) == ((_o).keyPath())))) {
888 0 : return false;
889 : }
890 0 : if ((!((locale()) == ((_o).locale())))) {
891 0 : return false;
892 : }
893 0 : if ((!((unique()) == ((_o).unique())))) {
894 0 : return false;
895 : }
896 0 : if ((!((multiEntry()) == ((_o).multiEntry())))) {
897 0 : return false;
898 : }
899 0 : if ((!((autoLocale()) == ((_o).autoLocale())))) {
900 0 : return false;
901 : }
902 0 : return true;
903 : }
904 :
905 0 : auto IndexMetadata::operator!=(const IndexMetadata& _o) const -> bool
906 : {
907 0 : return (!(operator==(_o)));
908 : }
909 :
910 0 : auto IndexMetadata::Init() -> void
911 : {
912 0 : }
913 :
914 0 : auto IndexMetadata::Assign(
915 : const int64_t& _id,
916 : const nsString& _name,
917 : const KeyPath& _keyPath,
918 : const nsCString& _locale,
919 : const bool& _unique,
920 : const bool& _multiEntry,
921 : const bool& _autoLocale) -> void
922 : {
923 0 : id_ = _id;
924 0 : name_ = _name;
925 0 : keyPath_ = _keyPath;
926 0 : locale_ = _locale;
927 0 : unique_ = _unique;
928 0 : multiEntry_ = _multiEntry;
929 0 : autoLocale_ = _autoLocale;
930 0 : }
931 :
932 : } // namespace indexedDB
933 : } // namespace dom
934 : } // namespace mozilla
935 :
936 : //-----------------------------------------------------------------------------
937 : // Method definitions for the IPDL type |struct DatabaseSpec|
938 : //
939 : namespace mozilla {
940 : namespace dom {
941 : namespace indexedDB {
942 0 : MOZ_IMPLICIT DatabaseSpec::DatabaseSpec()
943 : {
944 0 : Init();
945 0 : }
946 :
947 0 : DatabaseSpec::~DatabaseSpec()
948 : {
949 0 : }
950 :
951 0 : auto DatabaseSpec::operator==(const DatabaseSpec& _o) const -> bool
952 : {
953 0 : if ((!((metadata()) == ((_o).metadata())))) {
954 0 : return false;
955 : }
956 0 : if ((!((objectStores()) == ((_o).objectStores())))) {
957 0 : return false;
958 : }
959 0 : return true;
960 : }
961 :
962 0 : auto DatabaseSpec::operator!=(const DatabaseSpec& _o) const -> bool
963 : {
964 0 : return (!(operator==(_o)));
965 : }
966 :
967 0 : auto DatabaseSpec::Init() -> void
968 : {
969 0 : }
970 :
971 0 : auto DatabaseSpec::Assign(
972 : const DatabaseMetadata& _metadata,
973 : const nsTArray<ObjectStoreSpec>& _objectStores) -> void
974 : {
975 0 : metadata_ = _metadata;
976 0 : objectStores_ = _objectStores;
977 0 : }
978 :
979 : } // namespace indexedDB
980 : } // namespace dom
981 : } // namespace mozilla
982 :
983 : //-----------------------------------------------------------------------------
984 : // Method definitions for the IPDL type |struct ObjectStoreSpec|
985 : //
986 : namespace mozilla {
987 : namespace dom {
988 : namespace indexedDB {
989 0 : MOZ_IMPLICIT ObjectStoreSpec::ObjectStoreSpec()
990 : {
991 0 : Init();
992 0 : }
993 :
994 0 : ObjectStoreSpec::~ObjectStoreSpec()
995 : {
996 0 : }
997 :
998 0 : auto ObjectStoreSpec::operator==(const ObjectStoreSpec& _o) const -> bool
999 : {
1000 0 : if ((!((metadata()) == ((_o).metadata())))) {
1001 0 : return false;
1002 : }
1003 0 : if ((!((indexes()) == ((_o).indexes())))) {
1004 0 : return false;
1005 : }
1006 0 : return true;
1007 : }
1008 :
1009 0 : auto ObjectStoreSpec::operator!=(const ObjectStoreSpec& _o) const -> bool
1010 : {
1011 0 : return (!(operator==(_o)));
1012 : }
1013 :
1014 0 : auto ObjectStoreSpec::Init() -> void
1015 : {
1016 0 : }
1017 :
1018 0 : auto ObjectStoreSpec::Assign(
1019 : const ObjectStoreMetadata& _metadata,
1020 : const nsTArray<IndexMetadata>& _indexes) -> void
1021 : {
1022 0 : metadata_ = _metadata;
1023 0 : indexes_ = _indexes;
1024 0 : }
1025 :
1026 : } // namespace indexedDB
1027 : } // namespace dom
1028 : } // namespace mozilla
1029 :
1030 : //-----------------------------------------------------------------------------
1031 : // Method definitions for the IPDL type |struct ObjectStoreOpenCursorParams|
1032 : //
1033 : namespace mozilla {
1034 : namespace dom {
1035 : namespace indexedDB {
1036 0 : MOZ_IMPLICIT ObjectStoreOpenCursorParams::ObjectStoreOpenCursorParams() :
1037 : objectStoreId_(),
1038 0 : direction_()
1039 : {
1040 0 : Init();
1041 0 : }
1042 :
1043 0 : ObjectStoreOpenCursorParams::~ObjectStoreOpenCursorParams()
1044 : {
1045 0 : }
1046 :
1047 0 : auto ObjectStoreOpenCursorParams::operator==(const ObjectStoreOpenCursorParams& _o) const -> bool
1048 : {
1049 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
1050 0 : return false;
1051 : }
1052 0 : if ((!((optionalKeyRange()) == ((_o).optionalKeyRange())))) {
1053 0 : return false;
1054 : }
1055 0 : if ((!((direction()) == ((_o).direction())))) {
1056 0 : return false;
1057 : }
1058 0 : return true;
1059 : }
1060 :
1061 0 : auto ObjectStoreOpenCursorParams::operator!=(const ObjectStoreOpenCursorParams& _o) const -> bool
1062 : {
1063 0 : return (!(operator==(_o)));
1064 : }
1065 :
1066 0 : auto ObjectStoreOpenCursorParams::Init() -> void
1067 : {
1068 0 : }
1069 :
1070 0 : auto ObjectStoreOpenCursorParams::Assign(
1071 : const int64_t& _objectStoreId,
1072 : const OptionalKeyRange& _optionalKeyRange,
1073 : const Direction& _direction) -> void
1074 : {
1075 0 : objectStoreId_ = _objectStoreId;
1076 0 : optionalKeyRange_ = _optionalKeyRange;
1077 0 : direction_ = _direction;
1078 0 : }
1079 :
1080 : } // namespace indexedDB
1081 : } // namespace dom
1082 : } // namespace mozilla
1083 :
1084 : //-----------------------------------------------------------------------------
1085 : // Method definitions for the IPDL type |struct ObjectStoreOpenKeyCursorParams|
1086 : //
1087 : namespace mozilla {
1088 : namespace dom {
1089 : namespace indexedDB {
1090 0 : MOZ_IMPLICIT ObjectStoreOpenKeyCursorParams::ObjectStoreOpenKeyCursorParams() :
1091 : objectStoreId_(),
1092 0 : direction_()
1093 : {
1094 0 : Init();
1095 0 : }
1096 :
1097 0 : ObjectStoreOpenKeyCursorParams::~ObjectStoreOpenKeyCursorParams()
1098 : {
1099 0 : }
1100 :
1101 0 : auto ObjectStoreOpenKeyCursorParams::operator==(const ObjectStoreOpenKeyCursorParams& _o) const -> bool
1102 : {
1103 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
1104 0 : return false;
1105 : }
1106 0 : if ((!((optionalKeyRange()) == ((_o).optionalKeyRange())))) {
1107 0 : return false;
1108 : }
1109 0 : if ((!((direction()) == ((_o).direction())))) {
1110 0 : return false;
1111 : }
1112 0 : return true;
1113 : }
1114 :
1115 0 : auto ObjectStoreOpenKeyCursorParams::operator!=(const ObjectStoreOpenKeyCursorParams& _o) const -> bool
1116 : {
1117 0 : return (!(operator==(_o)));
1118 : }
1119 :
1120 0 : auto ObjectStoreOpenKeyCursorParams::Init() -> void
1121 : {
1122 0 : }
1123 :
1124 0 : auto ObjectStoreOpenKeyCursorParams::Assign(
1125 : const int64_t& _objectStoreId,
1126 : const OptionalKeyRange& _optionalKeyRange,
1127 : const Direction& _direction) -> void
1128 : {
1129 0 : objectStoreId_ = _objectStoreId;
1130 0 : optionalKeyRange_ = _optionalKeyRange;
1131 0 : direction_ = _direction;
1132 0 : }
1133 :
1134 : } // namespace indexedDB
1135 : } // namespace dom
1136 : } // namespace mozilla
1137 :
1138 : //-----------------------------------------------------------------------------
1139 : // Method definitions for the IPDL type |struct IndexOpenCursorParams|
1140 : //
1141 : namespace mozilla {
1142 : namespace dom {
1143 : namespace indexedDB {
1144 0 : MOZ_IMPLICIT IndexOpenCursorParams::IndexOpenCursorParams() :
1145 : objectStoreId_(),
1146 : indexId_(),
1147 0 : direction_()
1148 : {
1149 0 : Init();
1150 0 : }
1151 :
1152 0 : IndexOpenCursorParams::~IndexOpenCursorParams()
1153 : {
1154 0 : }
1155 :
1156 0 : auto IndexOpenCursorParams::operator==(const IndexOpenCursorParams& _o) const -> bool
1157 : {
1158 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
1159 0 : return false;
1160 : }
1161 0 : if ((!((indexId()) == ((_o).indexId())))) {
1162 0 : return false;
1163 : }
1164 0 : if ((!((optionalKeyRange()) == ((_o).optionalKeyRange())))) {
1165 0 : return false;
1166 : }
1167 0 : if ((!((direction()) == ((_o).direction())))) {
1168 0 : return false;
1169 : }
1170 0 : return true;
1171 : }
1172 :
1173 0 : auto IndexOpenCursorParams::operator!=(const IndexOpenCursorParams& _o) const -> bool
1174 : {
1175 0 : return (!(operator==(_o)));
1176 : }
1177 :
1178 0 : auto IndexOpenCursorParams::Init() -> void
1179 : {
1180 0 : }
1181 :
1182 0 : auto IndexOpenCursorParams::Assign(
1183 : const int64_t& _objectStoreId,
1184 : const int64_t& _indexId,
1185 : const OptionalKeyRange& _optionalKeyRange,
1186 : const Direction& _direction) -> void
1187 : {
1188 0 : objectStoreId_ = _objectStoreId;
1189 0 : indexId_ = _indexId;
1190 0 : optionalKeyRange_ = _optionalKeyRange;
1191 0 : direction_ = _direction;
1192 0 : }
1193 :
1194 : } // namespace indexedDB
1195 : } // namespace dom
1196 : } // namespace mozilla
1197 :
1198 : //-----------------------------------------------------------------------------
1199 : // Method definitions for the IPDL type |struct IndexOpenKeyCursorParams|
1200 : //
1201 : namespace mozilla {
1202 : namespace dom {
1203 : namespace indexedDB {
1204 0 : MOZ_IMPLICIT IndexOpenKeyCursorParams::IndexOpenKeyCursorParams() :
1205 : objectStoreId_(),
1206 : indexId_(),
1207 0 : direction_()
1208 : {
1209 0 : Init();
1210 0 : }
1211 :
1212 0 : IndexOpenKeyCursorParams::~IndexOpenKeyCursorParams()
1213 : {
1214 0 : }
1215 :
1216 0 : auto IndexOpenKeyCursorParams::operator==(const IndexOpenKeyCursorParams& _o) const -> bool
1217 : {
1218 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
1219 0 : return false;
1220 : }
1221 0 : if ((!((indexId()) == ((_o).indexId())))) {
1222 0 : return false;
1223 : }
1224 0 : if ((!((optionalKeyRange()) == ((_o).optionalKeyRange())))) {
1225 0 : return false;
1226 : }
1227 0 : if ((!((direction()) == ((_o).direction())))) {
1228 0 : return false;
1229 : }
1230 0 : return true;
1231 : }
1232 :
1233 0 : auto IndexOpenKeyCursorParams::operator!=(const IndexOpenKeyCursorParams& _o) const -> bool
1234 : {
1235 0 : return (!(operator==(_o)));
1236 : }
1237 :
1238 0 : auto IndexOpenKeyCursorParams::Init() -> void
1239 : {
1240 0 : }
1241 :
1242 0 : auto IndexOpenKeyCursorParams::Assign(
1243 : const int64_t& _objectStoreId,
1244 : const int64_t& _indexId,
1245 : const OptionalKeyRange& _optionalKeyRange,
1246 : const Direction& _direction) -> void
1247 : {
1248 0 : objectStoreId_ = _objectStoreId;
1249 0 : indexId_ = _indexId;
1250 0 : optionalKeyRange_ = _optionalKeyRange;
1251 0 : direction_ = _direction;
1252 0 : }
1253 :
1254 : } // namespace indexedDB
1255 : } // namespace dom
1256 : } // namespace mozilla
1257 :
1258 : //-----------------------------------------------------------------------------
1259 : // Method definitions for the IPDL type |union OpenCursorParams|
1260 : //
1261 : namespace mozilla {
1262 : namespace dom {
1263 : namespace indexedDB {
1264 0 : auto OpenCursorParams::MaybeDestroy(Type aNewType) -> bool
1265 : {
1266 0 : if ((mType) == (T__None)) {
1267 0 : return true;
1268 : }
1269 0 : if ((mType) == (aNewType)) {
1270 0 : return false;
1271 : }
1272 0 : switch (mType) {
1273 : case TObjectStoreOpenCursorParams:
1274 : {
1275 0 : (ptr_ObjectStoreOpenCursorParams())->~ObjectStoreOpenCursorParams__tdef();
1276 0 : break;
1277 : }
1278 : case TObjectStoreOpenKeyCursorParams:
1279 : {
1280 0 : (ptr_ObjectStoreOpenKeyCursorParams())->~ObjectStoreOpenKeyCursorParams__tdef();
1281 0 : break;
1282 : }
1283 : case TIndexOpenCursorParams:
1284 : {
1285 0 : (ptr_IndexOpenCursorParams())->~IndexOpenCursorParams__tdef();
1286 0 : break;
1287 : }
1288 : case TIndexOpenKeyCursorParams:
1289 : {
1290 0 : (ptr_IndexOpenKeyCursorParams())->~IndexOpenKeyCursorParams__tdef();
1291 0 : break;
1292 : }
1293 : default:
1294 : {
1295 0 : mozilla::ipc::LogicError("not reached");
1296 0 : break;
1297 : }
1298 : }
1299 0 : return true;
1300 : }
1301 :
1302 0 : MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const ObjectStoreOpenCursorParams& aOther)
1303 : {
1304 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(aOther);
1305 0 : mType = TObjectStoreOpenCursorParams;
1306 0 : }
1307 :
1308 0 : MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const ObjectStoreOpenKeyCursorParams& aOther)
1309 : {
1310 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(aOther);
1311 0 : mType = TObjectStoreOpenKeyCursorParams;
1312 0 : }
1313 :
1314 0 : MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const IndexOpenCursorParams& aOther)
1315 : {
1316 0 : new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(aOther);
1317 0 : mType = TIndexOpenCursorParams;
1318 0 : }
1319 :
1320 0 : MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const IndexOpenKeyCursorParams& aOther)
1321 : {
1322 0 : new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(aOther);
1323 0 : mType = TIndexOpenKeyCursorParams;
1324 0 : }
1325 :
1326 0 : MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const OpenCursorParams& aOther)
1327 : {
1328 0 : (aOther).AssertSanity();
1329 0 : switch ((aOther).type()) {
1330 : case TObjectStoreOpenCursorParams:
1331 : {
1332 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams((aOther).get_ObjectStoreOpenCursorParams());
1333 0 : break;
1334 : }
1335 : case TObjectStoreOpenKeyCursorParams:
1336 : {
1337 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams((aOther).get_ObjectStoreOpenKeyCursorParams());
1338 0 : break;
1339 : }
1340 : case TIndexOpenCursorParams:
1341 : {
1342 0 : new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams((aOther).get_IndexOpenCursorParams());
1343 0 : break;
1344 : }
1345 : case TIndexOpenKeyCursorParams:
1346 : {
1347 0 : new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams((aOther).get_IndexOpenKeyCursorParams());
1348 0 : break;
1349 : }
1350 : case T__None:
1351 : {
1352 0 : break;
1353 : }
1354 : default:
1355 : {
1356 0 : mozilla::ipc::LogicError("unreached");
1357 0 : return;
1358 : }
1359 : }
1360 0 : mType = (aOther).type();
1361 : }
1362 :
1363 0 : OpenCursorParams::~OpenCursorParams()
1364 : {
1365 0 : static_cast<void>(MaybeDestroy(T__None));
1366 0 : }
1367 :
1368 0 : auto OpenCursorParams::operator=(const ObjectStoreOpenCursorParams& aRhs) -> OpenCursorParams&
1369 : {
1370 0 : if (MaybeDestroy(TObjectStoreOpenCursorParams)) {
1371 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams;
1372 : }
1373 0 : (*(ptr_ObjectStoreOpenCursorParams())) = aRhs;
1374 0 : mType = TObjectStoreOpenCursorParams;
1375 0 : return (*(this));
1376 : }
1377 :
1378 0 : auto OpenCursorParams::operator=(const ObjectStoreOpenKeyCursorParams& aRhs) -> OpenCursorParams&
1379 : {
1380 0 : if (MaybeDestroy(TObjectStoreOpenKeyCursorParams)) {
1381 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams;
1382 : }
1383 0 : (*(ptr_ObjectStoreOpenKeyCursorParams())) = aRhs;
1384 0 : mType = TObjectStoreOpenKeyCursorParams;
1385 0 : return (*(this));
1386 : }
1387 :
1388 0 : auto OpenCursorParams::operator=(const IndexOpenCursorParams& aRhs) -> OpenCursorParams&
1389 : {
1390 0 : if (MaybeDestroy(TIndexOpenCursorParams)) {
1391 0 : new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams;
1392 : }
1393 0 : (*(ptr_IndexOpenCursorParams())) = aRhs;
1394 0 : mType = TIndexOpenCursorParams;
1395 0 : return (*(this));
1396 : }
1397 :
1398 0 : auto OpenCursorParams::operator=(const IndexOpenKeyCursorParams& aRhs) -> OpenCursorParams&
1399 : {
1400 0 : if (MaybeDestroy(TIndexOpenKeyCursorParams)) {
1401 0 : new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams;
1402 : }
1403 0 : (*(ptr_IndexOpenKeyCursorParams())) = aRhs;
1404 0 : mType = TIndexOpenKeyCursorParams;
1405 0 : return (*(this));
1406 : }
1407 :
1408 0 : auto OpenCursorParams::operator=(const OpenCursorParams& aRhs) -> OpenCursorParams&
1409 : {
1410 0 : (aRhs).AssertSanity();
1411 0 : Type t = (aRhs).type();
1412 0 : switch (t) {
1413 : case TObjectStoreOpenCursorParams:
1414 : {
1415 0 : if (MaybeDestroy(t)) {
1416 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams;
1417 : }
1418 0 : (*(ptr_ObjectStoreOpenCursorParams())) = (aRhs).get_ObjectStoreOpenCursorParams();
1419 0 : break;
1420 : }
1421 : case TObjectStoreOpenKeyCursorParams:
1422 : {
1423 0 : if (MaybeDestroy(t)) {
1424 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams;
1425 : }
1426 0 : (*(ptr_ObjectStoreOpenKeyCursorParams())) = (aRhs).get_ObjectStoreOpenKeyCursorParams();
1427 0 : break;
1428 : }
1429 : case TIndexOpenCursorParams:
1430 : {
1431 0 : if (MaybeDestroy(t)) {
1432 0 : new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams;
1433 : }
1434 0 : (*(ptr_IndexOpenCursorParams())) = (aRhs).get_IndexOpenCursorParams();
1435 0 : break;
1436 : }
1437 : case TIndexOpenKeyCursorParams:
1438 : {
1439 0 : if (MaybeDestroy(t)) {
1440 0 : new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams;
1441 : }
1442 0 : (*(ptr_IndexOpenKeyCursorParams())) = (aRhs).get_IndexOpenKeyCursorParams();
1443 0 : break;
1444 : }
1445 : case T__None:
1446 : {
1447 0 : static_cast<void>(MaybeDestroy(t));
1448 0 : break;
1449 : }
1450 : default:
1451 : {
1452 0 : mozilla::ipc::LogicError("unreached");
1453 0 : break;
1454 : }
1455 : }
1456 0 : mType = t;
1457 0 : return (*(this));
1458 : }
1459 :
1460 0 : auto OpenCursorParams::operator==(const ObjectStoreOpenCursorParams& aRhs) const -> bool
1461 : {
1462 0 : return (get_ObjectStoreOpenCursorParams()) == (aRhs);
1463 : }
1464 :
1465 0 : auto OpenCursorParams::operator==(const ObjectStoreOpenKeyCursorParams& aRhs) const -> bool
1466 : {
1467 0 : return (get_ObjectStoreOpenKeyCursorParams()) == (aRhs);
1468 : }
1469 :
1470 0 : auto OpenCursorParams::operator==(const IndexOpenCursorParams& aRhs) const -> bool
1471 : {
1472 0 : return (get_IndexOpenCursorParams()) == (aRhs);
1473 : }
1474 :
1475 0 : auto OpenCursorParams::operator==(const IndexOpenKeyCursorParams& aRhs) const -> bool
1476 : {
1477 0 : return (get_IndexOpenKeyCursorParams()) == (aRhs);
1478 : }
1479 :
1480 0 : auto OpenCursorParams::operator==(const OpenCursorParams& aRhs) const -> bool
1481 : {
1482 0 : if ((type()) != ((aRhs).type())) {
1483 0 : return false;
1484 : }
1485 :
1486 0 : switch (type()) {
1487 : case TObjectStoreOpenCursorParams:
1488 : {
1489 0 : return (get_ObjectStoreOpenCursorParams()) == ((aRhs).get_ObjectStoreOpenCursorParams());
1490 : }
1491 : case TObjectStoreOpenKeyCursorParams:
1492 : {
1493 0 : return (get_ObjectStoreOpenKeyCursorParams()) == ((aRhs).get_ObjectStoreOpenKeyCursorParams());
1494 : }
1495 : case TIndexOpenCursorParams:
1496 : {
1497 0 : return (get_IndexOpenCursorParams()) == ((aRhs).get_IndexOpenCursorParams());
1498 : }
1499 : case TIndexOpenKeyCursorParams:
1500 : {
1501 0 : return (get_IndexOpenKeyCursorParams()) == ((aRhs).get_IndexOpenKeyCursorParams());
1502 : }
1503 : default:
1504 : {
1505 0 : mozilla::ipc::LogicError("unreached");
1506 0 : return false;
1507 : }
1508 : }
1509 : }
1510 :
1511 0 : auto OpenCursorParams::get(ObjectStoreOpenCursorParams* aOutValue) const -> void
1512 : {
1513 0 : (*(aOutValue)) = get_ObjectStoreOpenCursorParams();
1514 0 : }
1515 :
1516 0 : auto OpenCursorParams::get(ObjectStoreOpenKeyCursorParams* aOutValue) const -> void
1517 : {
1518 0 : (*(aOutValue)) = get_ObjectStoreOpenKeyCursorParams();
1519 0 : }
1520 :
1521 0 : auto OpenCursorParams::get(IndexOpenCursorParams* aOutValue) const -> void
1522 : {
1523 0 : (*(aOutValue)) = get_IndexOpenCursorParams();
1524 0 : }
1525 :
1526 0 : auto OpenCursorParams::get(IndexOpenKeyCursorParams* aOutValue) const -> void
1527 : {
1528 0 : (*(aOutValue)) = get_IndexOpenKeyCursorParams();
1529 0 : }
1530 :
1531 : } // namespace indexedDB
1532 : } // namespace dom
1533 : } // namespace mozilla
1534 :
1535 : //-----------------------------------------------------------------------------
1536 : // Method definitions for the IPDL type |union DatabaseOrMutableFile|
1537 : //
1538 : namespace mozilla {
1539 : namespace dom {
1540 : namespace indexedDB {
1541 0 : auto DatabaseOrMutableFile::MaybeDestroy(Type aNewType) -> bool
1542 : {
1543 0 : if ((mType) == (T__None)) {
1544 0 : return true;
1545 : }
1546 0 : if ((mType) == (aNewType)) {
1547 0 : return false;
1548 : }
1549 0 : switch (mType) {
1550 : case TPBackgroundIDBDatabaseFileParent:
1551 : {
1552 0 : (ptr_PBackgroundIDBDatabaseFileParent())->~PBackgroundIDBDatabaseFileParent__tdef();
1553 0 : break;
1554 : }
1555 : case TPBackgroundIDBDatabaseFileChild:
1556 : {
1557 0 : (ptr_PBackgroundIDBDatabaseFileChild())->~PBackgroundIDBDatabaseFileChild__tdef();
1558 0 : break;
1559 : }
1560 : case TPBackgroundMutableFileParent:
1561 : {
1562 0 : (ptr_PBackgroundMutableFileParent())->~PBackgroundMutableFileParent__tdef();
1563 0 : break;
1564 : }
1565 : case TPBackgroundMutableFileChild:
1566 : {
1567 0 : (ptr_PBackgroundMutableFileChild())->~PBackgroundMutableFileChild__tdef();
1568 0 : break;
1569 : }
1570 : default:
1571 : {
1572 0 : mozilla::ipc::LogicError("not reached");
1573 0 : break;
1574 : }
1575 : }
1576 0 : return true;
1577 : }
1578 :
1579 0 : MOZ_IMPLICIT DatabaseOrMutableFile::DatabaseOrMutableFile(PBackgroundIDBDatabaseFileParent* aOther)
1580 : {
1581 0 : new (mozilla::KnownNotNull, ptr_PBackgroundIDBDatabaseFileParent()) PBackgroundIDBDatabaseFileParent*(const_cast<PBackgroundIDBDatabaseFileParent*>(aOther));
1582 0 : mType = TPBackgroundIDBDatabaseFileParent;
1583 0 : }
1584 :
1585 0 : MOZ_IMPLICIT DatabaseOrMutableFile::DatabaseOrMutableFile(PBackgroundIDBDatabaseFileChild* aOther)
1586 : {
1587 0 : new (mozilla::KnownNotNull, ptr_PBackgroundIDBDatabaseFileChild()) PBackgroundIDBDatabaseFileChild*(const_cast<PBackgroundIDBDatabaseFileChild*>(aOther));
1588 0 : mType = TPBackgroundIDBDatabaseFileChild;
1589 0 : }
1590 :
1591 0 : MOZ_IMPLICIT DatabaseOrMutableFile::DatabaseOrMutableFile(PBackgroundMutableFileParent* aOther)
1592 : {
1593 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileParent()) PBackgroundMutableFileParent*(const_cast<PBackgroundMutableFileParent*>(aOther));
1594 0 : mType = TPBackgroundMutableFileParent;
1595 0 : }
1596 :
1597 0 : MOZ_IMPLICIT DatabaseOrMutableFile::DatabaseOrMutableFile(PBackgroundMutableFileChild* aOther)
1598 : {
1599 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileChild()) PBackgroundMutableFileChild*(const_cast<PBackgroundMutableFileChild*>(aOther));
1600 0 : mType = TPBackgroundMutableFileChild;
1601 0 : }
1602 :
1603 0 : MOZ_IMPLICIT DatabaseOrMutableFile::DatabaseOrMutableFile(const DatabaseOrMutableFile& aOther)
1604 : {
1605 0 : (aOther).AssertSanity();
1606 0 : switch ((aOther).type()) {
1607 : case TPBackgroundIDBDatabaseFileParent:
1608 : {
1609 0 : new (mozilla::KnownNotNull, ptr_PBackgroundIDBDatabaseFileParent()) PBackgroundIDBDatabaseFileParent*(const_cast<PBackgroundIDBDatabaseFileParent*>((aOther).get_PBackgroundIDBDatabaseFileParent()));
1610 0 : break;
1611 : }
1612 : case TPBackgroundIDBDatabaseFileChild:
1613 : {
1614 0 : new (mozilla::KnownNotNull, ptr_PBackgroundIDBDatabaseFileChild()) PBackgroundIDBDatabaseFileChild*(const_cast<PBackgroundIDBDatabaseFileChild*>((aOther).get_PBackgroundIDBDatabaseFileChild()));
1615 0 : break;
1616 : }
1617 : case TPBackgroundMutableFileParent:
1618 : {
1619 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileParent()) PBackgroundMutableFileParent*(const_cast<PBackgroundMutableFileParent*>((aOther).get_PBackgroundMutableFileParent()));
1620 0 : break;
1621 : }
1622 : case TPBackgroundMutableFileChild:
1623 : {
1624 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileChild()) PBackgroundMutableFileChild*(const_cast<PBackgroundMutableFileChild*>((aOther).get_PBackgroundMutableFileChild()));
1625 0 : break;
1626 : }
1627 : case T__None:
1628 : {
1629 0 : break;
1630 : }
1631 : default:
1632 : {
1633 0 : mozilla::ipc::LogicError("unreached");
1634 0 : return;
1635 : }
1636 : }
1637 0 : mType = (aOther).type();
1638 : }
1639 :
1640 0 : DatabaseOrMutableFile::~DatabaseOrMutableFile()
1641 : {
1642 0 : static_cast<void>(MaybeDestroy(T__None));
1643 0 : }
1644 :
1645 0 : auto DatabaseOrMutableFile::operator=(PBackgroundIDBDatabaseFileParent* aRhs) -> DatabaseOrMutableFile&
1646 : {
1647 0 : if (MaybeDestroy(TPBackgroundIDBDatabaseFileParent)) {
1648 0 : new (mozilla::KnownNotNull, ptr_PBackgroundIDBDatabaseFileParent()) PBackgroundIDBDatabaseFileParent*;
1649 : }
1650 0 : (*(ptr_PBackgroundIDBDatabaseFileParent())) = const_cast<PBackgroundIDBDatabaseFileParent*>(aRhs);
1651 0 : mType = TPBackgroundIDBDatabaseFileParent;
1652 0 : return (*(this));
1653 : }
1654 :
1655 0 : auto DatabaseOrMutableFile::operator=(PBackgroundIDBDatabaseFileChild* aRhs) -> DatabaseOrMutableFile&
1656 : {
1657 0 : if (MaybeDestroy(TPBackgroundIDBDatabaseFileChild)) {
1658 0 : new (mozilla::KnownNotNull, ptr_PBackgroundIDBDatabaseFileChild()) PBackgroundIDBDatabaseFileChild*;
1659 : }
1660 0 : (*(ptr_PBackgroundIDBDatabaseFileChild())) = const_cast<PBackgroundIDBDatabaseFileChild*>(aRhs);
1661 0 : mType = TPBackgroundIDBDatabaseFileChild;
1662 0 : return (*(this));
1663 : }
1664 :
1665 0 : auto DatabaseOrMutableFile::operator=(PBackgroundMutableFileParent* aRhs) -> DatabaseOrMutableFile&
1666 : {
1667 0 : if (MaybeDestroy(TPBackgroundMutableFileParent)) {
1668 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileParent()) PBackgroundMutableFileParent*;
1669 : }
1670 0 : (*(ptr_PBackgroundMutableFileParent())) = const_cast<PBackgroundMutableFileParent*>(aRhs);
1671 0 : mType = TPBackgroundMutableFileParent;
1672 0 : return (*(this));
1673 : }
1674 :
1675 0 : auto DatabaseOrMutableFile::operator=(PBackgroundMutableFileChild* aRhs) -> DatabaseOrMutableFile&
1676 : {
1677 0 : if (MaybeDestroy(TPBackgroundMutableFileChild)) {
1678 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileChild()) PBackgroundMutableFileChild*;
1679 : }
1680 0 : (*(ptr_PBackgroundMutableFileChild())) = const_cast<PBackgroundMutableFileChild*>(aRhs);
1681 0 : mType = TPBackgroundMutableFileChild;
1682 0 : return (*(this));
1683 : }
1684 :
1685 0 : auto DatabaseOrMutableFile::operator=(const DatabaseOrMutableFile& aRhs) -> DatabaseOrMutableFile&
1686 : {
1687 0 : (aRhs).AssertSanity();
1688 0 : Type t = (aRhs).type();
1689 0 : switch (t) {
1690 : case TPBackgroundIDBDatabaseFileParent:
1691 : {
1692 0 : if (MaybeDestroy(t)) {
1693 0 : new (mozilla::KnownNotNull, ptr_PBackgroundIDBDatabaseFileParent()) PBackgroundIDBDatabaseFileParent*;
1694 : }
1695 0 : (*(ptr_PBackgroundIDBDatabaseFileParent())) = const_cast<PBackgroundIDBDatabaseFileParent*>((aRhs).get_PBackgroundIDBDatabaseFileParent());
1696 0 : break;
1697 : }
1698 : case TPBackgroundIDBDatabaseFileChild:
1699 : {
1700 0 : if (MaybeDestroy(t)) {
1701 0 : new (mozilla::KnownNotNull, ptr_PBackgroundIDBDatabaseFileChild()) PBackgroundIDBDatabaseFileChild*;
1702 : }
1703 0 : (*(ptr_PBackgroundIDBDatabaseFileChild())) = const_cast<PBackgroundIDBDatabaseFileChild*>((aRhs).get_PBackgroundIDBDatabaseFileChild());
1704 0 : break;
1705 : }
1706 : case TPBackgroundMutableFileParent:
1707 : {
1708 0 : if (MaybeDestroy(t)) {
1709 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileParent()) PBackgroundMutableFileParent*;
1710 : }
1711 0 : (*(ptr_PBackgroundMutableFileParent())) = const_cast<PBackgroundMutableFileParent*>((aRhs).get_PBackgroundMutableFileParent());
1712 0 : break;
1713 : }
1714 : case TPBackgroundMutableFileChild:
1715 : {
1716 0 : if (MaybeDestroy(t)) {
1717 0 : new (mozilla::KnownNotNull, ptr_PBackgroundMutableFileChild()) PBackgroundMutableFileChild*;
1718 : }
1719 0 : (*(ptr_PBackgroundMutableFileChild())) = const_cast<PBackgroundMutableFileChild*>((aRhs).get_PBackgroundMutableFileChild());
1720 0 : break;
1721 : }
1722 : case T__None:
1723 : {
1724 0 : static_cast<void>(MaybeDestroy(t));
1725 0 : break;
1726 : }
1727 : default:
1728 : {
1729 0 : mozilla::ipc::LogicError("unreached");
1730 0 : break;
1731 : }
1732 : }
1733 0 : mType = t;
1734 0 : return (*(this));
1735 : }
1736 :
1737 0 : auto DatabaseOrMutableFile::operator==(PBackgroundIDBDatabaseFileParent* aRhs) const -> bool
1738 : {
1739 0 : return (get_PBackgroundIDBDatabaseFileParent()) == (aRhs);
1740 : }
1741 :
1742 0 : auto DatabaseOrMutableFile::operator==(PBackgroundIDBDatabaseFileChild* aRhs) const -> bool
1743 : {
1744 0 : return (get_PBackgroundIDBDatabaseFileChild()) == (aRhs);
1745 : }
1746 :
1747 0 : auto DatabaseOrMutableFile::operator==(PBackgroundMutableFileParent* aRhs) const -> bool
1748 : {
1749 0 : return (get_PBackgroundMutableFileParent()) == (aRhs);
1750 : }
1751 :
1752 0 : auto DatabaseOrMutableFile::operator==(PBackgroundMutableFileChild* aRhs) const -> bool
1753 : {
1754 0 : return (get_PBackgroundMutableFileChild()) == (aRhs);
1755 : }
1756 :
1757 0 : auto DatabaseOrMutableFile::operator==(const DatabaseOrMutableFile& aRhs) const -> bool
1758 : {
1759 0 : if ((type()) != ((aRhs).type())) {
1760 0 : return false;
1761 : }
1762 :
1763 0 : switch (type()) {
1764 : case TPBackgroundIDBDatabaseFileParent:
1765 : {
1766 0 : return (get_PBackgroundIDBDatabaseFileParent()) == ((aRhs).get_PBackgroundIDBDatabaseFileParent());
1767 : }
1768 : case TPBackgroundIDBDatabaseFileChild:
1769 : {
1770 0 : return (get_PBackgroundIDBDatabaseFileChild()) == ((aRhs).get_PBackgroundIDBDatabaseFileChild());
1771 : }
1772 : case TPBackgroundMutableFileParent:
1773 : {
1774 0 : return (get_PBackgroundMutableFileParent()) == ((aRhs).get_PBackgroundMutableFileParent());
1775 : }
1776 : case TPBackgroundMutableFileChild:
1777 : {
1778 0 : return (get_PBackgroundMutableFileChild()) == ((aRhs).get_PBackgroundMutableFileChild());
1779 : }
1780 : default:
1781 : {
1782 0 : mozilla::ipc::LogicError("unreached");
1783 0 : return false;
1784 : }
1785 : }
1786 : }
1787 :
1788 0 : auto DatabaseOrMutableFile::get(PBackgroundIDBDatabaseFileParent** aOutValue) const -> void
1789 : {
1790 0 : (*(aOutValue)) = get_PBackgroundIDBDatabaseFileParent();
1791 0 : }
1792 :
1793 0 : auto DatabaseOrMutableFile::get(PBackgroundIDBDatabaseFileChild** aOutValue) const -> void
1794 : {
1795 0 : (*(aOutValue)) = get_PBackgroundIDBDatabaseFileChild();
1796 0 : }
1797 :
1798 0 : auto DatabaseOrMutableFile::get(PBackgroundMutableFileParent** aOutValue) const -> void
1799 : {
1800 0 : (*(aOutValue)) = get_PBackgroundMutableFileParent();
1801 0 : }
1802 :
1803 0 : auto DatabaseOrMutableFile::get(PBackgroundMutableFileChild** aOutValue) const -> void
1804 : {
1805 0 : (*(aOutValue)) = get_PBackgroundMutableFileChild();
1806 0 : }
1807 :
1808 : } // namespace indexedDB
1809 : } // namespace dom
1810 : } // namespace mozilla
1811 :
1812 : //-----------------------------------------------------------------------------
1813 : // Method definitions for the IPDL type |struct FileAddInfo|
1814 : //
1815 : namespace mozilla {
1816 : namespace dom {
1817 : namespace indexedDB {
1818 0 : MOZ_IMPLICIT FileAddInfo::FileAddInfo() :
1819 0 : type_()
1820 : {
1821 0 : Init();
1822 0 : }
1823 :
1824 0 : FileAddInfo::~FileAddInfo()
1825 : {
1826 0 : }
1827 :
1828 0 : auto FileAddInfo::operator==(const FileAddInfo& _o) const -> bool
1829 : {
1830 0 : if ((!((file()) == ((_o).file())))) {
1831 0 : return false;
1832 : }
1833 0 : if ((!((type()) == ((_o).type())))) {
1834 0 : return false;
1835 : }
1836 0 : return true;
1837 : }
1838 :
1839 0 : auto FileAddInfo::operator!=(const FileAddInfo& _o) const -> bool
1840 : {
1841 0 : return (!(operator==(_o)));
1842 : }
1843 :
1844 0 : auto FileAddInfo::Init() -> void
1845 : {
1846 0 : }
1847 :
1848 0 : auto FileAddInfo::Assign(
1849 : const DatabaseOrMutableFile& _file,
1850 : const FileType& _type) -> void
1851 : {
1852 0 : file_ = _file;
1853 0 : type_ = _type;
1854 0 : }
1855 :
1856 : } // namespace indexedDB
1857 : } // namespace dom
1858 : } // namespace mozilla
1859 :
1860 : //-----------------------------------------------------------------------------
1861 : // Method definitions for the IPDL type |struct ObjectStoreAddPutParams|
1862 : //
1863 : namespace mozilla {
1864 : namespace dom {
1865 : namespace indexedDB {
1866 0 : MOZ_IMPLICIT ObjectStoreAddPutParams::ObjectStoreAddPutParams() :
1867 : objectStoreId_(),
1868 0 : key_()
1869 : {
1870 0 : Init();
1871 0 : }
1872 :
1873 0 : ObjectStoreAddPutParams::~ObjectStoreAddPutParams()
1874 : {
1875 0 : }
1876 :
1877 0 : auto ObjectStoreAddPutParams::operator==(const ObjectStoreAddPutParams& _o) const -> bool
1878 : {
1879 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
1880 0 : return false;
1881 : }
1882 0 : if ((!((cloneInfo()) == ((_o).cloneInfo())))) {
1883 0 : return false;
1884 : }
1885 0 : if ((!((key()) == ((_o).key())))) {
1886 0 : return false;
1887 : }
1888 0 : if ((!((indexUpdateInfos()) == ((_o).indexUpdateInfos())))) {
1889 0 : return false;
1890 : }
1891 0 : if ((!((fileAddInfos()) == ((_o).fileAddInfos())))) {
1892 0 : return false;
1893 : }
1894 0 : return true;
1895 : }
1896 :
1897 0 : auto ObjectStoreAddPutParams::operator!=(const ObjectStoreAddPutParams& _o) const -> bool
1898 : {
1899 0 : return (!(operator==(_o)));
1900 : }
1901 :
1902 0 : auto ObjectStoreAddPutParams::Init() -> void
1903 : {
1904 0 : }
1905 :
1906 0 : auto ObjectStoreAddPutParams::Assign(
1907 : const int64_t& _objectStoreId,
1908 : const SerializedStructuredCloneWriteInfo& _cloneInfo,
1909 : const Key& _key,
1910 : const nsTArray<IndexUpdateInfo>& _indexUpdateInfos,
1911 : const nsTArray<FileAddInfo>& _fileAddInfos) -> void
1912 : {
1913 0 : objectStoreId_ = _objectStoreId;
1914 0 : cloneInfo_ = _cloneInfo;
1915 0 : key_ = _key;
1916 0 : indexUpdateInfos_ = _indexUpdateInfos;
1917 0 : fileAddInfos_ = _fileAddInfos;
1918 0 : }
1919 :
1920 : } // namespace indexedDB
1921 : } // namespace dom
1922 : } // namespace mozilla
1923 :
1924 : //-----------------------------------------------------------------------------
1925 : // Method definitions for the IPDL type |struct ObjectStoreAddParams|
1926 : //
1927 : namespace mozilla {
1928 : namespace dom {
1929 : namespace indexedDB {
1930 0 : MOZ_IMPLICIT ObjectStoreAddParams::ObjectStoreAddParams()
1931 : {
1932 0 : Init();
1933 0 : }
1934 :
1935 0 : ObjectStoreAddParams::~ObjectStoreAddParams()
1936 : {
1937 0 : }
1938 :
1939 0 : auto ObjectStoreAddParams::operator==(const ObjectStoreAddParams& _o) const -> bool
1940 : {
1941 0 : if ((!((commonParams()) == ((_o).commonParams())))) {
1942 0 : return false;
1943 : }
1944 0 : return true;
1945 : }
1946 :
1947 0 : auto ObjectStoreAddParams::operator!=(const ObjectStoreAddParams& _o) const -> bool
1948 : {
1949 0 : return (!(operator==(_o)));
1950 : }
1951 :
1952 0 : auto ObjectStoreAddParams::Init() -> void
1953 : {
1954 0 : }
1955 :
1956 0 : auto ObjectStoreAddParams::Assign(const ObjectStoreAddPutParams& _commonParams) -> void
1957 : {
1958 0 : commonParams_ = _commonParams;
1959 0 : }
1960 :
1961 : } // namespace indexedDB
1962 : } // namespace dom
1963 : } // namespace mozilla
1964 :
1965 : //-----------------------------------------------------------------------------
1966 : // Method definitions for the IPDL type |struct ObjectStorePutParams|
1967 : //
1968 : namespace mozilla {
1969 : namespace dom {
1970 : namespace indexedDB {
1971 0 : MOZ_IMPLICIT ObjectStorePutParams::ObjectStorePutParams()
1972 : {
1973 0 : Init();
1974 0 : }
1975 :
1976 0 : ObjectStorePutParams::~ObjectStorePutParams()
1977 : {
1978 0 : }
1979 :
1980 0 : auto ObjectStorePutParams::operator==(const ObjectStorePutParams& _o) const -> bool
1981 : {
1982 0 : if ((!((commonParams()) == ((_o).commonParams())))) {
1983 0 : return false;
1984 : }
1985 0 : return true;
1986 : }
1987 :
1988 0 : auto ObjectStorePutParams::operator!=(const ObjectStorePutParams& _o) const -> bool
1989 : {
1990 0 : return (!(operator==(_o)));
1991 : }
1992 :
1993 0 : auto ObjectStorePutParams::Init() -> void
1994 : {
1995 0 : }
1996 :
1997 0 : auto ObjectStorePutParams::Assign(const ObjectStoreAddPutParams& _commonParams) -> void
1998 : {
1999 0 : commonParams_ = _commonParams;
2000 0 : }
2001 :
2002 : } // namespace indexedDB
2003 : } // namespace dom
2004 : } // namespace mozilla
2005 :
2006 : //-----------------------------------------------------------------------------
2007 : // Method definitions for the IPDL type |struct ObjectStoreGetParams|
2008 : //
2009 : namespace mozilla {
2010 : namespace dom {
2011 : namespace indexedDB {
2012 0 : MOZ_IMPLICIT ObjectStoreGetParams::ObjectStoreGetParams() :
2013 0 : objectStoreId_()
2014 : {
2015 0 : Init();
2016 0 : }
2017 :
2018 0 : ObjectStoreGetParams::~ObjectStoreGetParams()
2019 : {
2020 0 : }
2021 :
2022 0 : auto ObjectStoreGetParams::operator==(const ObjectStoreGetParams& _o) const -> bool
2023 : {
2024 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
2025 0 : return false;
2026 : }
2027 0 : if ((!((keyRange()) == ((_o).keyRange())))) {
2028 0 : return false;
2029 : }
2030 0 : return true;
2031 : }
2032 :
2033 0 : auto ObjectStoreGetParams::operator!=(const ObjectStoreGetParams& _o) const -> bool
2034 : {
2035 0 : return (!(operator==(_o)));
2036 : }
2037 :
2038 0 : auto ObjectStoreGetParams::Init() -> void
2039 : {
2040 0 : }
2041 :
2042 0 : auto ObjectStoreGetParams::Assign(
2043 : const int64_t& _objectStoreId,
2044 : const SerializedKeyRange& _keyRange) -> void
2045 : {
2046 0 : objectStoreId_ = _objectStoreId;
2047 0 : keyRange_ = _keyRange;
2048 0 : }
2049 :
2050 : } // namespace indexedDB
2051 : } // namespace dom
2052 : } // namespace mozilla
2053 :
2054 : //-----------------------------------------------------------------------------
2055 : // Method definitions for the IPDL type |struct ObjectStoreGetKeyParams|
2056 : //
2057 : namespace mozilla {
2058 : namespace dom {
2059 : namespace indexedDB {
2060 0 : MOZ_IMPLICIT ObjectStoreGetKeyParams::ObjectStoreGetKeyParams() :
2061 0 : objectStoreId_()
2062 : {
2063 0 : Init();
2064 0 : }
2065 :
2066 0 : ObjectStoreGetKeyParams::~ObjectStoreGetKeyParams()
2067 : {
2068 0 : }
2069 :
2070 0 : auto ObjectStoreGetKeyParams::operator==(const ObjectStoreGetKeyParams& _o) const -> bool
2071 : {
2072 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
2073 0 : return false;
2074 : }
2075 0 : if ((!((keyRange()) == ((_o).keyRange())))) {
2076 0 : return false;
2077 : }
2078 0 : return true;
2079 : }
2080 :
2081 0 : auto ObjectStoreGetKeyParams::operator!=(const ObjectStoreGetKeyParams& _o) const -> bool
2082 : {
2083 0 : return (!(operator==(_o)));
2084 : }
2085 :
2086 0 : auto ObjectStoreGetKeyParams::Init() -> void
2087 : {
2088 0 : }
2089 :
2090 0 : auto ObjectStoreGetKeyParams::Assign(
2091 : const int64_t& _objectStoreId,
2092 : const SerializedKeyRange& _keyRange) -> void
2093 : {
2094 0 : objectStoreId_ = _objectStoreId;
2095 0 : keyRange_ = _keyRange;
2096 0 : }
2097 :
2098 : } // namespace indexedDB
2099 : } // namespace dom
2100 : } // namespace mozilla
2101 :
2102 : //-----------------------------------------------------------------------------
2103 : // Method definitions for the IPDL type |struct ObjectStoreGetAllParams|
2104 : //
2105 : namespace mozilla {
2106 : namespace dom {
2107 : namespace indexedDB {
2108 0 : MOZ_IMPLICIT ObjectStoreGetAllParams::ObjectStoreGetAllParams() :
2109 : objectStoreId_(),
2110 0 : limit_()
2111 : {
2112 0 : Init();
2113 0 : }
2114 :
2115 0 : ObjectStoreGetAllParams::~ObjectStoreGetAllParams()
2116 : {
2117 0 : }
2118 :
2119 0 : auto ObjectStoreGetAllParams::operator==(const ObjectStoreGetAllParams& _o) const -> bool
2120 : {
2121 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
2122 0 : return false;
2123 : }
2124 0 : if ((!((optionalKeyRange()) == ((_o).optionalKeyRange())))) {
2125 0 : return false;
2126 : }
2127 0 : if ((!((limit()) == ((_o).limit())))) {
2128 0 : return false;
2129 : }
2130 0 : return true;
2131 : }
2132 :
2133 0 : auto ObjectStoreGetAllParams::operator!=(const ObjectStoreGetAllParams& _o) const -> bool
2134 : {
2135 0 : return (!(operator==(_o)));
2136 : }
2137 :
2138 0 : auto ObjectStoreGetAllParams::Init() -> void
2139 : {
2140 0 : }
2141 :
2142 0 : auto ObjectStoreGetAllParams::Assign(
2143 : const int64_t& _objectStoreId,
2144 : const OptionalKeyRange& _optionalKeyRange,
2145 : const uint32_t& _limit) -> void
2146 : {
2147 0 : objectStoreId_ = _objectStoreId;
2148 0 : optionalKeyRange_ = _optionalKeyRange;
2149 0 : limit_ = _limit;
2150 0 : }
2151 :
2152 : } // namespace indexedDB
2153 : } // namespace dom
2154 : } // namespace mozilla
2155 :
2156 : //-----------------------------------------------------------------------------
2157 : // Method definitions for the IPDL type |struct ObjectStoreGetAllKeysParams|
2158 : //
2159 : namespace mozilla {
2160 : namespace dom {
2161 : namespace indexedDB {
2162 0 : MOZ_IMPLICIT ObjectStoreGetAllKeysParams::ObjectStoreGetAllKeysParams() :
2163 : objectStoreId_(),
2164 0 : limit_()
2165 : {
2166 0 : Init();
2167 0 : }
2168 :
2169 0 : ObjectStoreGetAllKeysParams::~ObjectStoreGetAllKeysParams()
2170 : {
2171 0 : }
2172 :
2173 0 : auto ObjectStoreGetAllKeysParams::operator==(const ObjectStoreGetAllKeysParams& _o) const -> bool
2174 : {
2175 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
2176 0 : return false;
2177 : }
2178 0 : if ((!((optionalKeyRange()) == ((_o).optionalKeyRange())))) {
2179 0 : return false;
2180 : }
2181 0 : if ((!((limit()) == ((_o).limit())))) {
2182 0 : return false;
2183 : }
2184 0 : return true;
2185 : }
2186 :
2187 0 : auto ObjectStoreGetAllKeysParams::operator!=(const ObjectStoreGetAllKeysParams& _o) const -> bool
2188 : {
2189 0 : return (!(operator==(_o)));
2190 : }
2191 :
2192 0 : auto ObjectStoreGetAllKeysParams::Init() -> void
2193 : {
2194 0 : }
2195 :
2196 0 : auto ObjectStoreGetAllKeysParams::Assign(
2197 : const int64_t& _objectStoreId,
2198 : const OptionalKeyRange& _optionalKeyRange,
2199 : const uint32_t& _limit) -> void
2200 : {
2201 0 : objectStoreId_ = _objectStoreId;
2202 0 : optionalKeyRange_ = _optionalKeyRange;
2203 0 : limit_ = _limit;
2204 0 : }
2205 :
2206 : } // namespace indexedDB
2207 : } // namespace dom
2208 : } // namespace mozilla
2209 :
2210 : //-----------------------------------------------------------------------------
2211 : // Method definitions for the IPDL type |struct ObjectStoreDeleteParams|
2212 : //
2213 : namespace mozilla {
2214 : namespace dom {
2215 : namespace indexedDB {
2216 0 : MOZ_IMPLICIT ObjectStoreDeleteParams::ObjectStoreDeleteParams() :
2217 0 : objectStoreId_()
2218 : {
2219 0 : Init();
2220 0 : }
2221 :
2222 0 : ObjectStoreDeleteParams::~ObjectStoreDeleteParams()
2223 : {
2224 0 : }
2225 :
2226 0 : auto ObjectStoreDeleteParams::operator==(const ObjectStoreDeleteParams& _o) const -> bool
2227 : {
2228 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
2229 0 : return false;
2230 : }
2231 0 : if ((!((keyRange()) == ((_o).keyRange())))) {
2232 0 : return false;
2233 : }
2234 0 : return true;
2235 : }
2236 :
2237 0 : auto ObjectStoreDeleteParams::operator!=(const ObjectStoreDeleteParams& _o) const -> bool
2238 : {
2239 0 : return (!(operator==(_o)));
2240 : }
2241 :
2242 0 : auto ObjectStoreDeleteParams::Init() -> void
2243 : {
2244 0 : }
2245 :
2246 0 : auto ObjectStoreDeleteParams::Assign(
2247 : const int64_t& _objectStoreId,
2248 : const SerializedKeyRange& _keyRange) -> void
2249 : {
2250 0 : objectStoreId_ = _objectStoreId;
2251 0 : keyRange_ = _keyRange;
2252 0 : }
2253 :
2254 : } // namespace indexedDB
2255 : } // namespace dom
2256 : } // namespace mozilla
2257 :
2258 : //-----------------------------------------------------------------------------
2259 : // Method definitions for the IPDL type |struct ObjectStoreClearParams|
2260 : //
2261 : namespace mozilla {
2262 : namespace dom {
2263 : namespace indexedDB {
2264 0 : MOZ_IMPLICIT ObjectStoreClearParams::ObjectStoreClearParams() :
2265 0 : objectStoreId_()
2266 : {
2267 0 : Init();
2268 0 : }
2269 :
2270 0 : ObjectStoreClearParams::~ObjectStoreClearParams()
2271 : {
2272 0 : }
2273 :
2274 0 : auto ObjectStoreClearParams::operator==(const ObjectStoreClearParams& _o) const -> bool
2275 : {
2276 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
2277 0 : return false;
2278 : }
2279 0 : return true;
2280 : }
2281 :
2282 0 : auto ObjectStoreClearParams::operator!=(const ObjectStoreClearParams& _o) const -> bool
2283 : {
2284 0 : return (!(operator==(_o)));
2285 : }
2286 :
2287 0 : auto ObjectStoreClearParams::Init() -> void
2288 : {
2289 0 : }
2290 :
2291 0 : auto ObjectStoreClearParams::Assign(const int64_t& _objectStoreId) -> void
2292 : {
2293 0 : objectStoreId_ = _objectStoreId;
2294 0 : }
2295 :
2296 : } // namespace indexedDB
2297 : } // namespace dom
2298 : } // namespace mozilla
2299 :
2300 : //-----------------------------------------------------------------------------
2301 : // Method definitions for the IPDL type |struct ObjectStoreCountParams|
2302 : //
2303 : namespace mozilla {
2304 : namespace dom {
2305 : namespace indexedDB {
2306 0 : MOZ_IMPLICIT ObjectStoreCountParams::ObjectStoreCountParams() :
2307 0 : objectStoreId_()
2308 : {
2309 0 : Init();
2310 0 : }
2311 :
2312 0 : ObjectStoreCountParams::~ObjectStoreCountParams()
2313 : {
2314 0 : }
2315 :
2316 0 : auto ObjectStoreCountParams::operator==(const ObjectStoreCountParams& _o) const -> bool
2317 : {
2318 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
2319 0 : return false;
2320 : }
2321 0 : if ((!((optionalKeyRange()) == ((_o).optionalKeyRange())))) {
2322 0 : return false;
2323 : }
2324 0 : return true;
2325 : }
2326 :
2327 0 : auto ObjectStoreCountParams::operator!=(const ObjectStoreCountParams& _o) const -> bool
2328 : {
2329 0 : return (!(operator==(_o)));
2330 : }
2331 :
2332 0 : auto ObjectStoreCountParams::Init() -> void
2333 : {
2334 0 : }
2335 :
2336 0 : auto ObjectStoreCountParams::Assign(
2337 : const int64_t& _objectStoreId,
2338 : const OptionalKeyRange& _optionalKeyRange) -> void
2339 : {
2340 0 : objectStoreId_ = _objectStoreId;
2341 0 : optionalKeyRange_ = _optionalKeyRange;
2342 0 : }
2343 :
2344 : } // namespace indexedDB
2345 : } // namespace dom
2346 : } // namespace mozilla
2347 :
2348 : //-----------------------------------------------------------------------------
2349 : // Method definitions for the IPDL type |struct IndexGetParams|
2350 : //
2351 : namespace mozilla {
2352 : namespace dom {
2353 : namespace indexedDB {
2354 0 : MOZ_IMPLICIT IndexGetParams::IndexGetParams() :
2355 : objectStoreId_(),
2356 0 : indexId_()
2357 : {
2358 0 : Init();
2359 0 : }
2360 :
2361 0 : IndexGetParams::~IndexGetParams()
2362 : {
2363 0 : }
2364 :
2365 0 : auto IndexGetParams::operator==(const IndexGetParams& _o) const -> bool
2366 : {
2367 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
2368 0 : return false;
2369 : }
2370 0 : if ((!((indexId()) == ((_o).indexId())))) {
2371 0 : return false;
2372 : }
2373 0 : if ((!((keyRange()) == ((_o).keyRange())))) {
2374 0 : return false;
2375 : }
2376 0 : return true;
2377 : }
2378 :
2379 0 : auto IndexGetParams::operator!=(const IndexGetParams& _o) const -> bool
2380 : {
2381 0 : return (!(operator==(_o)));
2382 : }
2383 :
2384 0 : auto IndexGetParams::Init() -> void
2385 : {
2386 0 : }
2387 :
2388 0 : auto IndexGetParams::Assign(
2389 : const int64_t& _objectStoreId,
2390 : const int64_t& _indexId,
2391 : const SerializedKeyRange& _keyRange) -> void
2392 : {
2393 0 : objectStoreId_ = _objectStoreId;
2394 0 : indexId_ = _indexId;
2395 0 : keyRange_ = _keyRange;
2396 0 : }
2397 :
2398 : } // namespace indexedDB
2399 : } // namespace dom
2400 : } // namespace mozilla
2401 :
2402 : //-----------------------------------------------------------------------------
2403 : // Method definitions for the IPDL type |struct IndexGetKeyParams|
2404 : //
2405 : namespace mozilla {
2406 : namespace dom {
2407 : namespace indexedDB {
2408 0 : MOZ_IMPLICIT IndexGetKeyParams::IndexGetKeyParams() :
2409 : objectStoreId_(),
2410 0 : indexId_()
2411 : {
2412 0 : Init();
2413 0 : }
2414 :
2415 0 : IndexGetKeyParams::~IndexGetKeyParams()
2416 : {
2417 0 : }
2418 :
2419 0 : auto IndexGetKeyParams::operator==(const IndexGetKeyParams& _o) const -> bool
2420 : {
2421 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
2422 0 : return false;
2423 : }
2424 0 : if ((!((indexId()) == ((_o).indexId())))) {
2425 0 : return false;
2426 : }
2427 0 : if ((!((keyRange()) == ((_o).keyRange())))) {
2428 0 : return false;
2429 : }
2430 0 : return true;
2431 : }
2432 :
2433 0 : auto IndexGetKeyParams::operator!=(const IndexGetKeyParams& _o) const -> bool
2434 : {
2435 0 : return (!(operator==(_o)));
2436 : }
2437 :
2438 0 : auto IndexGetKeyParams::Init() -> void
2439 : {
2440 0 : }
2441 :
2442 0 : auto IndexGetKeyParams::Assign(
2443 : const int64_t& _objectStoreId,
2444 : const int64_t& _indexId,
2445 : const SerializedKeyRange& _keyRange) -> void
2446 : {
2447 0 : objectStoreId_ = _objectStoreId;
2448 0 : indexId_ = _indexId;
2449 0 : keyRange_ = _keyRange;
2450 0 : }
2451 :
2452 : } // namespace indexedDB
2453 : } // namespace dom
2454 : } // namespace mozilla
2455 :
2456 : //-----------------------------------------------------------------------------
2457 : // Method definitions for the IPDL type |struct IndexGetAllParams|
2458 : //
2459 : namespace mozilla {
2460 : namespace dom {
2461 : namespace indexedDB {
2462 0 : MOZ_IMPLICIT IndexGetAllParams::IndexGetAllParams() :
2463 : objectStoreId_(),
2464 : indexId_(),
2465 0 : limit_()
2466 : {
2467 0 : Init();
2468 0 : }
2469 :
2470 0 : IndexGetAllParams::~IndexGetAllParams()
2471 : {
2472 0 : }
2473 :
2474 0 : auto IndexGetAllParams::operator==(const IndexGetAllParams& _o) const -> bool
2475 : {
2476 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
2477 0 : return false;
2478 : }
2479 0 : if ((!((indexId()) == ((_o).indexId())))) {
2480 0 : return false;
2481 : }
2482 0 : if ((!((optionalKeyRange()) == ((_o).optionalKeyRange())))) {
2483 0 : return false;
2484 : }
2485 0 : if ((!((limit()) == ((_o).limit())))) {
2486 0 : return false;
2487 : }
2488 0 : return true;
2489 : }
2490 :
2491 0 : auto IndexGetAllParams::operator!=(const IndexGetAllParams& _o) const -> bool
2492 : {
2493 0 : return (!(operator==(_o)));
2494 : }
2495 :
2496 0 : auto IndexGetAllParams::Init() -> void
2497 : {
2498 0 : }
2499 :
2500 0 : auto IndexGetAllParams::Assign(
2501 : const int64_t& _objectStoreId,
2502 : const int64_t& _indexId,
2503 : const OptionalKeyRange& _optionalKeyRange,
2504 : const uint32_t& _limit) -> void
2505 : {
2506 0 : objectStoreId_ = _objectStoreId;
2507 0 : indexId_ = _indexId;
2508 0 : optionalKeyRange_ = _optionalKeyRange;
2509 0 : limit_ = _limit;
2510 0 : }
2511 :
2512 : } // namespace indexedDB
2513 : } // namespace dom
2514 : } // namespace mozilla
2515 :
2516 : //-----------------------------------------------------------------------------
2517 : // Method definitions for the IPDL type |struct IndexGetAllKeysParams|
2518 : //
2519 : namespace mozilla {
2520 : namespace dom {
2521 : namespace indexedDB {
2522 0 : MOZ_IMPLICIT IndexGetAllKeysParams::IndexGetAllKeysParams() :
2523 : objectStoreId_(),
2524 : indexId_(),
2525 0 : limit_()
2526 : {
2527 0 : Init();
2528 0 : }
2529 :
2530 0 : IndexGetAllKeysParams::~IndexGetAllKeysParams()
2531 : {
2532 0 : }
2533 :
2534 0 : auto IndexGetAllKeysParams::operator==(const IndexGetAllKeysParams& _o) const -> bool
2535 : {
2536 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
2537 0 : return false;
2538 : }
2539 0 : if ((!((indexId()) == ((_o).indexId())))) {
2540 0 : return false;
2541 : }
2542 0 : if ((!((optionalKeyRange()) == ((_o).optionalKeyRange())))) {
2543 0 : return false;
2544 : }
2545 0 : if ((!((limit()) == ((_o).limit())))) {
2546 0 : return false;
2547 : }
2548 0 : return true;
2549 : }
2550 :
2551 0 : auto IndexGetAllKeysParams::operator!=(const IndexGetAllKeysParams& _o) const -> bool
2552 : {
2553 0 : return (!(operator==(_o)));
2554 : }
2555 :
2556 0 : auto IndexGetAllKeysParams::Init() -> void
2557 : {
2558 0 : }
2559 :
2560 0 : auto IndexGetAllKeysParams::Assign(
2561 : const int64_t& _objectStoreId,
2562 : const int64_t& _indexId,
2563 : const OptionalKeyRange& _optionalKeyRange,
2564 : const uint32_t& _limit) -> void
2565 : {
2566 0 : objectStoreId_ = _objectStoreId;
2567 0 : indexId_ = _indexId;
2568 0 : optionalKeyRange_ = _optionalKeyRange;
2569 0 : limit_ = _limit;
2570 0 : }
2571 :
2572 : } // namespace indexedDB
2573 : } // namespace dom
2574 : } // namespace mozilla
2575 :
2576 : //-----------------------------------------------------------------------------
2577 : // Method definitions for the IPDL type |struct IndexCountParams|
2578 : //
2579 : namespace mozilla {
2580 : namespace dom {
2581 : namespace indexedDB {
2582 0 : MOZ_IMPLICIT IndexCountParams::IndexCountParams() :
2583 : objectStoreId_(),
2584 0 : indexId_()
2585 : {
2586 0 : Init();
2587 0 : }
2588 :
2589 0 : IndexCountParams::~IndexCountParams()
2590 : {
2591 0 : }
2592 :
2593 0 : auto IndexCountParams::operator==(const IndexCountParams& _o) const -> bool
2594 : {
2595 0 : if ((!((objectStoreId()) == ((_o).objectStoreId())))) {
2596 0 : return false;
2597 : }
2598 0 : if ((!((indexId()) == ((_o).indexId())))) {
2599 0 : return false;
2600 : }
2601 0 : if ((!((optionalKeyRange()) == ((_o).optionalKeyRange())))) {
2602 0 : return false;
2603 : }
2604 0 : return true;
2605 : }
2606 :
2607 0 : auto IndexCountParams::operator!=(const IndexCountParams& _o) const -> bool
2608 : {
2609 0 : return (!(operator==(_o)));
2610 : }
2611 :
2612 0 : auto IndexCountParams::Init() -> void
2613 : {
2614 0 : }
2615 :
2616 0 : auto IndexCountParams::Assign(
2617 : const int64_t& _objectStoreId,
2618 : const int64_t& _indexId,
2619 : const OptionalKeyRange& _optionalKeyRange) -> void
2620 : {
2621 0 : objectStoreId_ = _objectStoreId;
2622 0 : indexId_ = _indexId;
2623 0 : optionalKeyRange_ = _optionalKeyRange;
2624 0 : }
2625 :
2626 : } // namespace indexedDB
2627 : } // namespace dom
2628 : } // namespace mozilla
2629 :
2630 : //-----------------------------------------------------------------------------
2631 : // Method definitions for the IPDL type |union RequestParams|
2632 : //
2633 : namespace mozilla {
2634 : namespace dom {
2635 : namespace indexedDB {
2636 0 : auto RequestParams::MaybeDestroy(Type aNewType) -> bool
2637 : {
2638 0 : if ((mType) == (T__None)) {
2639 0 : return true;
2640 : }
2641 0 : if ((mType) == (aNewType)) {
2642 0 : return false;
2643 : }
2644 0 : switch (mType) {
2645 : case TObjectStoreAddParams:
2646 : {
2647 0 : (ptr_ObjectStoreAddParams())->~ObjectStoreAddParams__tdef();
2648 0 : break;
2649 : }
2650 : case TObjectStorePutParams:
2651 : {
2652 0 : (ptr_ObjectStorePutParams())->~ObjectStorePutParams__tdef();
2653 0 : break;
2654 : }
2655 : case TObjectStoreGetParams:
2656 : {
2657 0 : (ptr_ObjectStoreGetParams())->~ObjectStoreGetParams__tdef();
2658 0 : break;
2659 : }
2660 : case TObjectStoreGetKeyParams:
2661 : {
2662 0 : (ptr_ObjectStoreGetKeyParams())->~ObjectStoreGetKeyParams__tdef();
2663 0 : break;
2664 : }
2665 : case TObjectStoreGetAllParams:
2666 : {
2667 0 : (ptr_ObjectStoreGetAllParams())->~ObjectStoreGetAllParams__tdef();
2668 0 : break;
2669 : }
2670 : case TObjectStoreGetAllKeysParams:
2671 : {
2672 0 : (ptr_ObjectStoreGetAllKeysParams())->~ObjectStoreGetAllKeysParams__tdef();
2673 0 : break;
2674 : }
2675 : case TObjectStoreDeleteParams:
2676 : {
2677 0 : (ptr_ObjectStoreDeleteParams())->~ObjectStoreDeleteParams__tdef();
2678 0 : break;
2679 : }
2680 : case TObjectStoreClearParams:
2681 : {
2682 0 : (ptr_ObjectStoreClearParams())->~ObjectStoreClearParams__tdef();
2683 0 : break;
2684 : }
2685 : case TObjectStoreCountParams:
2686 : {
2687 0 : (ptr_ObjectStoreCountParams())->~ObjectStoreCountParams__tdef();
2688 0 : break;
2689 : }
2690 : case TIndexGetParams:
2691 : {
2692 0 : (ptr_IndexGetParams())->~IndexGetParams__tdef();
2693 0 : break;
2694 : }
2695 : case TIndexGetKeyParams:
2696 : {
2697 0 : (ptr_IndexGetKeyParams())->~IndexGetKeyParams__tdef();
2698 0 : break;
2699 : }
2700 : case TIndexGetAllParams:
2701 : {
2702 0 : (ptr_IndexGetAllParams())->~IndexGetAllParams__tdef();
2703 0 : break;
2704 : }
2705 : case TIndexGetAllKeysParams:
2706 : {
2707 0 : (ptr_IndexGetAllKeysParams())->~IndexGetAllKeysParams__tdef();
2708 0 : break;
2709 : }
2710 : case TIndexCountParams:
2711 : {
2712 0 : (ptr_IndexCountParams())->~IndexCountParams__tdef();
2713 0 : break;
2714 : }
2715 : default:
2716 : {
2717 0 : mozilla::ipc::LogicError("not reached");
2718 0 : break;
2719 : }
2720 : }
2721 0 : return true;
2722 : }
2723 :
2724 0 : MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreAddParams& aOther)
2725 : {
2726 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreAddParams()) ObjectStoreAddParams(aOther);
2727 0 : mType = TObjectStoreAddParams;
2728 0 : }
2729 :
2730 0 : MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStorePutParams& aOther)
2731 : {
2732 0 : new (mozilla::KnownNotNull, ptr_ObjectStorePutParams()) ObjectStorePutParams(aOther);
2733 0 : mType = TObjectStorePutParams;
2734 0 : }
2735 :
2736 0 : MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreGetParams& aOther)
2737 : {
2738 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(aOther);
2739 0 : mType = TObjectStoreGetParams;
2740 0 : }
2741 :
2742 0 : MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreGetKeyParams& aOther)
2743 : {
2744 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(aOther);
2745 0 : mType = TObjectStoreGetKeyParams;
2746 0 : }
2747 :
2748 0 : MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreGetAllParams& aOther)
2749 : {
2750 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(aOther);
2751 0 : mType = TObjectStoreGetAllParams;
2752 0 : }
2753 :
2754 0 : MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreGetAllKeysParams& aOther)
2755 : {
2756 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(aOther);
2757 0 : mType = TObjectStoreGetAllKeysParams;
2758 0 : }
2759 :
2760 0 : MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreDeleteParams& aOther)
2761 : {
2762 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(aOther);
2763 0 : mType = TObjectStoreDeleteParams;
2764 0 : }
2765 :
2766 0 : MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreClearParams& aOther)
2767 : {
2768 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(aOther);
2769 0 : mType = TObjectStoreClearParams;
2770 0 : }
2771 :
2772 0 : MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreCountParams& aOther)
2773 : {
2774 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(aOther);
2775 0 : mType = TObjectStoreCountParams;
2776 0 : }
2777 :
2778 0 : MOZ_IMPLICIT RequestParams::RequestParams(const IndexGetParams& aOther)
2779 : {
2780 0 : new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(aOther);
2781 0 : mType = TIndexGetParams;
2782 0 : }
2783 :
2784 0 : MOZ_IMPLICIT RequestParams::RequestParams(const IndexGetKeyParams& aOther)
2785 : {
2786 0 : new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(aOther);
2787 0 : mType = TIndexGetKeyParams;
2788 0 : }
2789 :
2790 0 : MOZ_IMPLICIT RequestParams::RequestParams(const IndexGetAllParams& aOther)
2791 : {
2792 0 : new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(aOther);
2793 0 : mType = TIndexGetAllParams;
2794 0 : }
2795 :
2796 0 : MOZ_IMPLICIT RequestParams::RequestParams(const IndexGetAllKeysParams& aOther)
2797 : {
2798 0 : new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(aOther);
2799 0 : mType = TIndexGetAllKeysParams;
2800 0 : }
2801 :
2802 0 : MOZ_IMPLICIT RequestParams::RequestParams(const IndexCountParams& aOther)
2803 : {
2804 0 : new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(aOther);
2805 0 : mType = TIndexCountParams;
2806 0 : }
2807 :
2808 0 : MOZ_IMPLICIT RequestParams::RequestParams(const RequestParams& aOther)
2809 : {
2810 0 : (aOther).AssertSanity();
2811 0 : switch ((aOther).type()) {
2812 : case TObjectStoreAddParams:
2813 : {
2814 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreAddParams()) ObjectStoreAddParams((aOther).get_ObjectStoreAddParams());
2815 0 : break;
2816 : }
2817 : case TObjectStorePutParams:
2818 : {
2819 0 : new (mozilla::KnownNotNull, ptr_ObjectStorePutParams()) ObjectStorePutParams((aOther).get_ObjectStorePutParams());
2820 0 : break;
2821 : }
2822 : case TObjectStoreGetParams:
2823 : {
2824 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams((aOther).get_ObjectStoreGetParams());
2825 0 : break;
2826 : }
2827 : case TObjectStoreGetKeyParams:
2828 : {
2829 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams((aOther).get_ObjectStoreGetKeyParams());
2830 0 : break;
2831 : }
2832 : case TObjectStoreGetAllParams:
2833 : {
2834 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams((aOther).get_ObjectStoreGetAllParams());
2835 0 : break;
2836 : }
2837 : case TObjectStoreGetAllKeysParams:
2838 : {
2839 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams((aOther).get_ObjectStoreGetAllKeysParams());
2840 0 : break;
2841 : }
2842 : case TObjectStoreDeleteParams:
2843 : {
2844 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams((aOther).get_ObjectStoreDeleteParams());
2845 0 : break;
2846 : }
2847 : case TObjectStoreClearParams:
2848 : {
2849 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams((aOther).get_ObjectStoreClearParams());
2850 0 : break;
2851 : }
2852 : case TObjectStoreCountParams:
2853 : {
2854 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams((aOther).get_ObjectStoreCountParams());
2855 0 : break;
2856 : }
2857 : case TIndexGetParams:
2858 : {
2859 0 : new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams((aOther).get_IndexGetParams());
2860 0 : break;
2861 : }
2862 : case TIndexGetKeyParams:
2863 : {
2864 0 : new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams((aOther).get_IndexGetKeyParams());
2865 0 : break;
2866 : }
2867 : case TIndexGetAllParams:
2868 : {
2869 0 : new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams((aOther).get_IndexGetAllParams());
2870 0 : break;
2871 : }
2872 : case TIndexGetAllKeysParams:
2873 : {
2874 0 : new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams((aOther).get_IndexGetAllKeysParams());
2875 0 : break;
2876 : }
2877 : case TIndexCountParams:
2878 : {
2879 0 : new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams((aOther).get_IndexCountParams());
2880 0 : break;
2881 : }
2882 : case T__None:
2883 : {
2884 0 : break;
2885 : }
2886 : default:
2887 : {
2888 0 : mozilla::ipc::LogicError("unreached");
2889 0 : return;
2890 : }
2891 : }
2892 0 : mType = (aOther).type();
2893 : }
2894 :
2895 0 : RequestParams::~RequestParams()
2896 : {
2897 0 : static_cast<void>(MaybeDestroy(T__None));
2898 0 : }
2899 :
2900 0 : auto RequestParams::operator=(const ObjectStoreAddParams& aRhs) -> RequestParams&
2901 : {
2902 0 : if (MaybeDestroy(TObjectStoreAddParams)) {
2903 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreAddParams()) ObjectStoreAddParams;
2904 : }
2905 0 : (*(ptr_ObjectStoreAddParams())) = aRhs;
2906 0 : mType = TObjectStoreAddParams;
2907 0 : return (*(this));
2908 : }
2909 :
2910 0 : auto RequestParams::operator=(const ObjectStorePutParams& aRhs) -> RequestParams&
2911 : {
2912 0 : if (MaybeDestroy(TObjectStorePutParams)) {
2913 0 : new (mozilla::KnownNotNull, ptr_ObjectStorePutParams()) ObjectStorePutParams;
2914 : }
2915 0 : (*(ptr_ObjectStorePutParams())) = aRhs;
2916 0 : mType = TObjectStorePutParams;
2917 0 : return (*(this));
2918 : }
2919 :
2920 0 : auto RequestParams::operator=(const ObjectStoreGetParams& aRhs) -> RequestParams&
2921 : {
2922 0 : if (MaybeDestroy(TObjectStoreGetParams)) {
2923 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams;
2924 : }
2925 0 : (*(ptr_ObjectStoreGetParams())) = aRhs;
2926 0 : mType = TObjectStoreGetParams;
2927 0 : return (*(this));
2928 : }
2929 :
2930 0 : auto RequestParams::operator=(const ObjectStoreGetKeyParams& aRhs) -> RequestParams&
2931 : {
2932 0 : if (MaybeDestroy(TObjectStoreGetKeyParams)) {
2933 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams;
2934 : }
2935 0 : (*(ptr_ObjectStoreGetKeyParams())) = aRhs;
2936 0 : mType = TObjectStoreGetKeyParams;
2937 0 : return (*(this));
2938 : }
2939 :
2940 0 : auto RequestParams::operator=(const ObjectStoreGetAllParams& aRhs) -> RequestParams&
2941 : {
2942 0 : if (MaybeDestroy(TObjectStoreGetAllParams)) {
2943 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams;
2944 : }
2945 0 : (*(ptr_ObjectStoreGetAllParams())) = aRhs;
2946 0 : mType = TObjectStoreGetAllParams;
2947 0 : return (*(this));
2948 : }
2949 :
2950 0 : auto RequestParams::operator=(const ObjectStoreGetAllKeysParams& aRhs) -> RequestParams&
2951 : {
2952 0 : if (MaybeDestroy(TObjectStoreGetAllKeysParams)) {
2953 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams;
2954 : }
2955 0 : (*(ptr_ObjectStoreGetAllKeysParams())) = aRhs;
2956 0 : mType = TObjectStoreGetAllKeysParams;
2957 0 : return (*(this));
2958 : }
2959 :
2960 0 : auto RequestParams::operator=(const ObjectStoreDeleteParams& aRhs) -> RequestParams&
2961 : {
2962 0 : if (MaybeDestroy(TObjectStoreDeleteParams)) {
2963 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams;
2964 : }
2965 0 : (*(ptr_ObjectStoreDeleteParams())) = aRhs;
2966 0 : mType = TObjectStoreDeleteParams;
2967 0 : return (*(this));
2968 : }
2969 :
2970 0 : auto RequestParams::operator=(const ObjectStoreClearParams& aRhs) -> RequestParams&
2971 : {
2972 0 : if (MaybeDestroy(TObjectStoreClearParams)) {
2973 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams;
2974 : }
2975 0 : (*(ptr_ObjectStoreClearParams())) = aRhs;
2976 0 : mType = TObjectStoreClearParams;
2977 0 : return (*(this));
2978 : }
2979 :
2980 0 : auto RequestParams::operator=(const ObjectStoreCountParams& aRhs) -> RequestParams&
2981 : {
2982 0 : if (MaybeDestroy(TObjectStoreCountParams)) {
2983 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams;
2984 : }
2985 0 : (*(ptr_ObjectStoreCountParams())) = aRhs;
2986 0 : mType = TObjectStoreCountParams;
2987 0 : return (*(this));
2988 : }
2989 :
2990 0 : auto RequestParams::operator=(const IndexGetParams& aRhs) -> RequestParams&
2991 : {
2992 0 : if (MaybeDestroy(TIndexGetParams)) {
2993 0 : new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams;
2994 : }
2995 0 : (*(ptr_IndexGetParams())) = aRhs;
2996 0 : mType = TIndexGetParams;
2997 0 : return (*(this));
2998 : }
2999 :
3000 0 : auto RequestParams::operator=(const IndexGetKeyParams& aRhs) -> RequestParams&
3001 : {
3002 0 : if (MaybeDestroy(TIndexGetKeyParams)) {
3003 0 : new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams;
3004 : }
3005 0 : (*(ptr_IndexGetKeyParams())) = aRhs;
3006 0 : mType = TIndexGetKeyParams;
3007 0 : return (*(this));
3008 : }
3009 :
3010 0 : auto RequestParams::operator=(const IndexGetAllParams& aRhs) -> RequestParams&
3011 : {
3012 0 : if (MaybeDestroy(TIndexGetAllParams)) {
3013 0 : new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams;
3014 : }
3015 0 : (*(ptr_IndexGetAllParams())) = aRhs;
3016 0 : mType = TIndexGetAllParams;
3017 0 : return (*(this));
3018 : }
3019 :
3020 0 : auto RequestParams::operator=(const IndexGetAllKeysParams& aRhs) -> RequestParams&
3021 : {
3022 0 : if (MaybeDestroy(TIndexGetAllKeysParams)) {
3023 0 : new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams;
3024 : }
3025 0 : (*(ptr_IndexGetAllKeysParams())) = aRhs;
3026 0 : mType = TIndexGetAllKeysParams;
3027 0 : return (*(this));
3028 : }
3029 :
3030 0 : auto RequestParams::operator=(const IndexCountParams& aRhs) -> RequestParams&
3031 : {
3032 0 : if (MaybeDestroy(TIndexCountParams)) {
3033 0 : new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams;
3034 : }
3035 0 : (*(ptr_IndexCountParams())) = aRhs;
3036 0 : mType = TIndexCountParams;
3037 0 : return (*(this));
3038 : }
3039 :
3040 0 : auto RequestParams::operator=(const RequestParams& aRhs) -> RequestParams&
3041 : {
3042 0 : (aRhs).AssertSanity();
3043 0 : Type t = (aRhs).type();
3044 0 : switch (t) {
3045 : case TObjectStoreAddParams:
3046 : {
3047 0 : if (MaybeDestroy(t)) {
3048 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreAddParams()) ObjectStoreAddParams;
3049 : }
3050 0 : (*(ptr_ObjectStoreAddParams())) = (aRhs).get_ObjectStoreAddParams();
3051 0 : break;
3052 : }
3053 : case TObjectStorePutParams:
3054 : {
3055 0 : if (MaybeDestroy(t)) {
3056 0 : new (mozilla::KnownNotNull, ptr_ObjectStorePutParams()) ObjectStorePutParams;
3057 : }
3058 0 : (*(ptr_ObjectStorePutParams())) = (aRhs).get_ObjectStorePutParams();
3059 0 : break;
3060 : }
3061 : case TObjectStoreGetParams:
3062 : {
3063 0 : if (MaybeDestroy(t)) {
3064 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams;
3065 : }
3066 0 : (*(ptr_ObjectStoreGetParams())) = (aRhs).get_ObjectStoreGetParams();
3067 0 : break;
3068 : }
3069 : case TObjectStoreGetKeyParams:
3070 : {
3071 0 : if (MaybeDestroy(t)) {
3072 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams;
3073 : }
3074 0 : (*(ptr_ObjectStoreGetKeyParams())) = (aRhs).get_ObjectStoreGetKeyParams();
3075 0 : break;
3076 : }
3077 : case TObjectStoreGetAllParams:
3078 : {
3079 0 : if (MaybeDestroy(t)) {
3080 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams;
3081 : }
3082 0 : (*(ptr_ObjectStoreGetAllParams())) = (aRhs).get_ObjectStoreGetAllParams();
3083 0 : break;
3084 : }
3085 : case TObjectStoreGetAllKeysParams:
3086 : {
3087 0 : if (MaybeDestroy(t)) {
3088 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams;
3089 : }
3090 0 : (*(ptr_ObjectStoreGetAllKeysParams())) = (aRhs).get_ObjectStoreGetAllKeysParams();
3091 0 : break;
3092 : }
3093 : case TObjectStoreDeleteParams:
3094 : {
3095 0 : if (MaybeDestroy(t)) {
3096 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams;
3097 : }
3098 0 : (*(ptr_ObjectStoreDeleteParams())) = (aRhs).get_ObjectStoreDeleteParams();
3099 0 : break;
3100 : }
3101 : case TObjectStoreClearParams:
3102 : {
3103 0 : if (MaybeDestroy(t)) {
3104 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams;
3105 : }
3106 0 : (*(ptr_ObjectStoreClearParams())) = (aRhs).get_ObjectStoreClearParams();
3107 0 : break;
3108 : }
3109 : case TObjectStoreCountParams:
3110 : {
3111 0 : if (MaybeDestroy(t)) {
3112 0 : new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams;
3113 : }
3114 0 : (*(ptr_ObjectStoreCountParams())) = (aRhs).get_ObjectStoreCountParams();
3115 0 : break;
3116 : }
3117 : case TIndexGetParams:
3118 : {
3119 0 : if (MaybeDestroy(t)) {
3120 0 : new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams;
3121 : }
3122 0 : (*(ptr_IndexGetParams())) = (aRhs).get_IndexGetParams();
3123 0 : break;
3124 : }
3125 : case TIndexGetKeyParams:
3126 : {
3127 0 : if (MaybeDestroy(t)) {
3128 0 : new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams;
3129 : }
3130 0 : (*(ptr_IndexGetKeyParams())) = (aRhs).get_IndexGetKeyParams();
3131 0 : break;
3132 : }
3133 : case TIndexGetAllParams:
3134 : {
3135 0 : if (MaybeDestroy(t)) {
3136 0 : new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams;
3137 : }
3138 0 : (*(ptr_IndexGetAllParams())) = (aRhs).get_IndexGetAllParams();
3139 0 : break;
3140 : }
3141 : case TIndexGetAllKeysParams:
3142 : {
3143 0 : if (MaybeDestroy(t)) {
3144 0 : new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams;
3145 : }
3146 0 : (*(ptr_IndexGetAllKeysParams())) = (aRhs).get_IndexGetAllKeysParams();
3147 0 : break;
3148 : }
3149 : case TIndexCountParams:
3150 : {
3151 0 : if (MaybeDestroy(t)) {
3152 0 : new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams;
3153 : }
3154 0 : (*(ptr_IndexCountParams())) = (aRhs).get_IndexCountParams();
3155 0 : break;
3156 : }
3157 : case T__None:
3158 : {
3159 0 : static_cast<void>(MaybeDestroy(t));
3160 0 : break;
3161 : }
3162 : default:
3163 : {
3164 0 : mozilla::ipc::LogicError("unreached");
3165 0 : break;
3166 : }
3167 : }
3168 0 : mType = t;
3169 0 : return (*(this));
3170 : }
3171 :
3172 0 : auto RequestParams::operator==(const ObjectStoreAddParams& aRhs) const -> bool
3173 : {
3174 0 : return (get_ObjectStoreAddParams()) == (aRhs);
3175 : }
3176 :
3177 0 : auto RequestParams::operator==(const ObjectStorePutParams& aRhs) const -> bool
3178 : {
3179 0 : return (get_ObjectStorePutParams()) == (aRhs);
3180 : }
3181 :
3182 0 : auto RequestParams::operator==(const ObjectStoreGetParams& aRhs) const -> bool
3183 : {
3184 0 : return (get_ObjectStoreGetParams()) == (aRhs);
3185 : }
3186 :
3187 0 : auto RequestParams::operator==(const ObjectStoreGetKeyParams& aRhs) const -> bool
3188 : {
3189 0 : return (get_ObjectStoreGetKeyParams()) == (aRhs);
3190 : }
3191 :
3192 0 : auto RequestParams::operator==(const ObjectStoreGetAllParams& aRhs) const -> bool
3193 : {
3194 0 : return (get_ObjectStoreGetAllParams()) == (aRhs);
3195 : }
3196 :
3197 0 : auto RequestParams::operator==(const ObjectStoreGetAllKeysParams& aRhs) const -> bool
3198 : {
3199 0 : return (get_ObjectStoreGetAllKeysParams()) == (aRhs);
3200 : }
3201 :
3202 0 : auto RequestParams::operator==(const ObjectStoreDeleteParams& aRhs) const -> bool
3203 : {
3204 0 : return (get_ObjectStoreDeleteParams()) == (aRhs);
3205 : }
3206 :
3207 0 : auto RequestParams::operator==(const ObjectStoreClearParams& aRhs) const -> bool
3208 : {
3209 0 : return (get_ObjectStoreClearParams()) == (aRhs);
3210 : }
3211 :
3212 0 : auto RequestParams::operator==(const ObjectStoreCountParams& aRhs) const -> bool
3213 : {
3214 0 : return (get_ObjectStoreCountParams()) == (aRhs);
3215 : }
3216 :
3217 0 : auto RequestParams::operator==(const IndexGetParams& aRhs) const -> bool
3218 : {
3219 0 : return (get_IndexGetParams()) == (aRhs);
3220 : }
3221 :
3222 0 : auto RequestParams::operator==(const IndexGetKeyParams& aRhs) const -> bool
3223 : {
3224 0 : return (get_IndexGetKeyParams()) == (aRhs);
3225 : }
3226 :
3227 0 : auto RequestParams::operator==(const IndexGetAllParams& aRhs) const -> bool
3228 : {
3229 0 : return (get_IndexGetAllParams()) == (aRhs);
3230 : }
3231 :
3232 0 : auto RequestParams::operator==(const IndexGetAllKeysParams& aRhs) const -> bool
3233 : {
3234 0 : return (get_IndexGetAllKeysParams()) == (aRhs);
3235 : }
3236 :
3237 0 : auto RequestParams::operator==(const IndexCountParams& aRhs) const -> bool
3238 : {
3239 0 : return (get_IndexCountParams()) == (aRhs);
3240 : }
3241 :
3242 0 : auto RequestParams::operator==(const RequestParams& aRhs) const -> bool
3243 : {
3244 0 : if ((type()) != ((aRhs).type())) {
3245 0 : return false;
3246 : }
3247 :
3248 0 : switch (type()) {
3249 : case TObjectStoreAddParams:
3250 : {
3251 0 : return (get_ObjectStoreAddParams()) == ((aRhs).get_ObjectStoreAddParams());
3252 : }
3253 : case TObjectStorePutParams:
3254 : {
3255 0 : return (get_ObjectStorePutParams()) == ((aRhs).get_ObjectStorePutParams());
3256 : }
3257 : case TObjectStoreGetParams:
3258 : {
3259 0 : return (get_ObjectStoreGetParams()) == ((aRhs).get_ObjectStoreGetParams());
3260 : }
3261 : case TObjectStoreGetKeyParams:
3262 : {
3263 0 : return (get_ObjectStoreGetKeyParams()) == ((aRhs).get_ObjectStoreGetKeyParams());
3264 : }
3265 : case TObjectStoreGetAllParams:
3266 : {
3267 0 : return (get_ObjectStoreGetAllParams()) == ((aRhs).get_ObjectStoreGetAllParams());
3268 : }
3269 : case TObjectStoreGetAllKeysParams:
3270 : {
3271 0 : return (get_ObjectStoreGetAllKeysParams()) == ((aRhs).get_ObjectStoreGetAllKeysParams());
3272 : }
3273 : case TObjectStoreDeleteParams:
3274 : {
3275 0 : return (get_ObjectStoreDeleteParams()) == ((aRhs).get_ObjectStoreDeleteParams());
3276 : }
3277 : case TObjectStoreClearParams:
3278 : {
3279 0 : return (get_ObjectStoreClearParams()) == ((aRhs).get_ObjectStoreClearParams());
3280 : }
3281 : case TObjectStoreCountParams:
3282 : {
3283 0 : return (get_ObjectStoreCountParams()) == ((aRhs).get_ObjectStoreCountParams());
3284 : }
3285 : case TIndexGetParams:
3286 : {
3287 0 : return (get_IndexGetParams()) == ((aRhs).get_IndexGetParams());
3288 : }
3289 : case TIndexGetKeyParams:
3290 : {
3291 0 : return (get_IndexGetKeyParams()) == ((aRhs).get_IndexGetKeyParams());
3292 : }
3293 : case TIndexGetAllParams:
3294 : {
3295 0 : return (get_IndexGetAllParams()) == ((aRhs).get_IndexGetAllParams());
3296 : }
3297 : case TIndexGetAllKeysParams:
3298 : {
3299 0 : return (get_IndexGetAllKeysParams()) == ((aRhs).get_IndexGetAllKeysParams());
3300 : }
3301 : case TIndexCountParams:
3302 : {
3303 0 : return (get_IndexCountParams()) == ((aRhs).get_IndexCountParams());
3304 : }
3305 : default:
3306 : {
3307 0 : mozilla::ipc::LogicError("unreached");
3308 0 : return false;
3309 : }
3310 : }
3311 : }
3312 :
3313 0 : auto RequestParams::get(ObjectStoreAddParams* aOutValue) const -> void
3314 : {
3315 0 : (*(aOutValue)) = get_ObjectStoreAddParams();
3316 0 : }
3317 :
3318 0 : auto RequestParams::get(ObjectStorePutParams* aOutValue) const -> void
3319 : {
3320 0 : (*(aOutValue)) = get_ObjectStorePutParams();
3321 0 : }
3322 :
3323 0 : auto RequestParams::get(ObjectStoreGetParams* aOutValue) const -> void
3324 : {
3325 0 : (*(aOutValue)) = get_ObjectStoreGetParams();
3326 0 : }
3327 :
3328 0 : auto RequestParams::get(ObjectStoreGetKeyParams* aOutValue) const -> void
3329 : {
3330 0 : (*(aOutValue)) = get_ObjectStoreGetKeyParams();
3331 0 : }
3332 :
3333 0 : auto RequestParams::get(ObjectStoreGetAllParams* aOutValue) const -> void
3334 : {
3335 0 : (*(aOutValue)) = get_ObjectStoreGetAllParams();
3336 0 : }
3337 :
3338 0 : auto RequestParams::get(ObjectStoreGetAllKeysParams* aOutValue) const -> void
3339 : {
3340 0 : (*(aOutValue)) = get_ObjectStoreGetAllKeysParams();
3341 0 : }
3342 :
3343 0 : auto RequestParams::get(ObjectStoreDeleteParams* aOutValue) const -> void
3344 : {
3345 0 : (*(aOutValue)) = get_ObjectStoreDeleteParams();
3346 0 : }
3347 :
3348 0 : auto RequestParams::get(ObjectStoreClearParams* aOutValue) const -> void
3349 : {
3350 0 : (*(aOutValue)) = get_ObjectStoreClearParams();
3351 0 : }
3352 :
3353 0 : auto RequestParams::get(ObjectStoreCountParams* aOutValue) const -> void
3354 : {
3355 0 : (*(aOutValue)) = get_ObjectStoreCountParams();
3356 0 : }
3357 :
3358 0 : auto RequestParams::get(IndexGetParams* aOutValue) const -> void
3359 : {
3360 0 : (*(aOutValue)) = get_IndexGetParams();
3361 0 : }
3362 :
3363 0 : auto RequestParams::get(IndexGetKeyParams* aOutValue) const -> void
3364 : {
3365 0 : (*(aOutValue)) = get_IndexGetKeyParams();
3366 0 : }
3367 :
3368 0 : auto RequestParams::get(IndexGetAllParams* aOutValue) const -> void
3369 : {
3370 0 : (*(aOutValue)) = get_IndexGetAllParams();
3371 0 : }
3372 :
3373 0 : auto RequestParams::get(IndexGetAllKeysParams* aOutValue) const -> void
3374 : {
3375 0 : (*(aOutValue)) = get_IndexGetAllKeysParams();
3376 0 : }
3377 :
3378 0 : auto RequestParams::get(IndexCountParams* aOutValue) const -> void
3379 : {
3380 0 : (*(aOutValue)) = get_IndexCountParams();
3381 0 : }
3382 :
3383 : } // namespace indexedDB
3384 : } // namespace dom
3385 : } // namespace mozilla
3386 :
3387 : //-----------------------------------------------------------------------------
3388 : // Method definitions for the IPDL type |struct LoggingInfo|
3389 : //
3390 : namespace mozilla {
3391 : namespace dom {
3392 : namespace indexedDB {
3393 0 : MOZ_IMPLICIT LoggingInfo::LoggingInfo() :
3394 : backgroundChildLoggingId_(),
3395 : nextTransactionSerialNumber_(),
3396 : nextVersionChangeTransactionSerialNumber_(),
3397 0 : nextRequestSerialNumber_()
3398 : {
3399 0 : Init();
3400 0 : }
3401 :
3402 0 : LoggingInfo::~LoggingInfo()
3403 : {
3404 0 : }
3405 :
3406 0 : auto LoggingInfo::operator==(const LoggingInfo& _o) const -> bool
3407 : {
3408 0 : if ((!((backgroundChildLoggingId()) == ((_o).backgroundChildLoggingId())))) {
3409 0 : return false;
3410 : }
3411 0 : if ((!((nextTransactionSerialNumber()) == ((_o).nextTransactionSerialNumber())))) {
3412 0 : return false;
3413 : }
3414 0 : if ((!((nextVersionChangeTransactionSerialNumber()) == ((_o).nextVersionChangeTransactionSerialNumber())))) {
3415 0 : return false;
3416 : }
3417 0 : if ((!((nextRequestSerialNumber()) == ((_o).nextRequestSerialNumber())))) {
3418 0 : return false;
3419 : }
3420 0 : return true;
3421 : }
3422 :
3423 0 : auto LoggingInfo::operator!=(const LoggingInfo& _o) const -> bool
3424 : {
3425 0 : return (!(operator==(_o)));
3426 : }
3427 :
3428 0 : auto LoggingInfo::Init() -> void
3429 : {
3430 0 : }
3431 :
3432 0 : auto LoggingInfo::Assign(
3433 : const nsID& _backgroundChildLoggingId,
3434 : const int64_t& _nextTransactionSerialNumber,
3435 : const int64_t& _nextVersionChangeTransactionSerialNumber,
3436 : const uint64_t& _nextRequestSerialNumber) -> void
3437 : {
3438 0 : backgroundChildLoggingId_ = _backgroundChildLoggingId;
3439 0 : nextTransactionSerialNumber_ = _nextTransactionSerialNumber;
3440 0 : nextVersionChangeTransactionSerialNumber_ = _nextVersionChangeTransactionSerialNumber;
3441 0 : nextRequestSerialNumber_ = _nextRequestSerialNumber;
3442 0 : }
3443 :
3444 : } // namespace indexedDB
3445 : } // namespace dom
3446 : } // namespace mozilla
|
