Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/PrefsTypes.h"
#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union PrefValue|
//
namespace mozilla {
namespace dom {
auto PrefValue::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TnsCString:
{
(ptr_nsCString())->~nsCString__tdef();
break;
}
case Tint32_t:
{
(ptr_int32_t())->~int32_t__tdef();
break;
}
case Tbool:
{
(ptr_bool())->~bool__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT PrefValue::PrefValue(const nsCString& aOther)
{
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(aOther);
mType = TnsCString;
}
MOZ_IMPLICIT PrefValue::PrefValue(nsCString&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move(aOther));
mType = TnsCString;
}
MOZ_IMPLICIT PrefValue::PrefValue(const int32_t& aOther)
{
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(aOther);
mType = Tint32_t;
}
MOZ_IMPLICIT PrefValue::PrefValue(int32_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move(aOther));
mType = Tint32_t;
}
MOZ_IMPLICIT PrefValue::PrefValue(const bool& aOther)
{
new (mozilla::KnownNotNull, ptr_bool()) bool(aOther);
mType = Tbool;
}
MOZ_IMPLICIT PrefValue::PrefValue(bool&& aOther)
{
new (mozilla::KnownNotNull, ptr_bool()) bool(std::move(aOther));
mType = Tbool;
}
MOZ_IMPLICIT PrefValue::PrefValue(const PrefValue& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TnsCString:
{
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString((aOther).get_nsCString());
break;
}
case Tint32_t:
{
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t((aOther).get_int32_t());
break;
}
case Tbool:
{
new (mozilla::KnownNotNull, ptr_bool()) bool((aOther).get_bool());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT PrefValue::PrefValue(PrefValue&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TnsCString:
{
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move((aOther).get_nsCString()));
(aOther).MaybeDestroy();
break;
}
case Tint32_t:
{
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move((aOther).get_int32_t()));
(aOther).MaybeDestroy();
break;
}
case Tbool:
{
new (mozilla::KnownNotNull, ptr_bool()) bool(std::move((aOther).get_bool()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
PrefValue::~PrefValue()
{
MaybeDestroy();
}
auto PrefValue::operator=(const nsCString& aRhs) -> PrefValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(aRhs);
mType = TnsCString;
return (*(this));
}
auto PrefValue::operator=(nsCString&& aRhs) -> PrefValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move(aRhs));
mType = TnsCString;
return (*(this));
}
auto PrefValue::operator=(const int32_t& aRhs) -> PrefValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(aRhs);
mType = Tint32_t;
return (*(this));
}
auto PrefValue::operator=(int32_t&& aRhs) -> PrefValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move(aRhs));
mType = Tint32_t;
return (*(this));
}
auto PrefValue::operator=(const bool& aRhs) -> PrefValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_bool()) bool(aRhs);
mType = Tbool;
return (*(this));
}
auto PrefValue::operator=(bool&& aRhs) -> PrefValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_bool()) bool(std::move(aRhs));
mType = Tbool;
return (*(this));
}
auto PrefValue::operator=(const PrefValue& aRhs) -> PrefValue&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TnsCString:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString((aRhs).get_nsCString());
break;
}
case Tint32_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t((aRhs).get_int32_t());
break;
}
case Tbool:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_bool()) bool((aRhs).get_bool());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto PrefValue::operator=(PrefValue&& aRhs) -> PrefValue&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TnsCString:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move((aRhs).get_nsCString()));
(aRhs).MaybeDestroy();
break;
}
case Tint32_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move((aRhs).get_int32_t()));
(aRhs).MaybeDestroy();
break;
}
case Tbool:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_bool()) bool(std::move((aRhs).get_bool()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::PrefValue>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::PrefValue union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'PrefValue'
(aWriter)->WriteSentinel(290784139);
switch (type) {
case union__::TnsCString:
{
IPC::WriteParam(aWriter, (aVar).get_nsCString());
// Sentinel = 'TnsCString'
(aWriter)->WriteSentinel(353960944);
return;
}
case union__::Tint32_t:
{
IPC::WriteParam(aWriter, (aVar).get_int32_t());
// Sentinel = 'Tint32_t'
(aWriter)->WriteSentinel(217252568);
return;
}
case union__::Tbool:
{
IPC::WriteParam(aWriter, (aVar).get_bool());
// Sentinel = 'Tbool'
(aWriter)->WriteSentinel(96993793);
return;
}
default:
{
aWriter->FatalError("unknown variant of union PrefValue");
return;
}
}
}
auto ParamTraits<::mozilla::dom::PrefValue>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::PrefValue union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union PrefValue");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'PrefValue'
if ((!((aReader)->ReadSentinel(290784139)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union PrefValue");
return {};
}
switch (type) {
case union__::TnsCString:
{
auto maybe__tmp = IPC::ReadParam<::nsCString>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TnsCString of union PrefValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TnsCString'
if ((!((aReader)->ReadSentinel(353960944)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TnsCString of union PrefValue");
return {};
}
return std::move(tmp);
}
case union__::Tint32_t:
{
auto maybe__tmp = IPC::ReadParam<::int32_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tint32_t of union PrefValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tint32_t'
if ((!((aReader)->ReadSentinel(217252568)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tint32_t of union PrefValue");
return {};
}
return std::move(tmp);
}
case union__::Tbool:
{
auto maybe__tmp = IPC::ReadParam<bool>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tbool of union PrefValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tbool'
if ((!((aReader)->ReadSentinel(96993793)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tbool of union PrefValue");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union PrefValue");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct Pref|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::Pref>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).name());
// Sentinel = 'name'
(aWriter)->WriteSentinel(69075362);
IPC::WriteParam(aWriter, (aVar).isLocked());
// Sentinel = 'isLocked'
(aWriter)->WriteSentinel(241369903);
IPC::WriteParam(aWriter, (aVar).isSanitized());
// Sentinel = 'isSanitized'
(aWriter)->WriteSentinel(452658312);
IPC::WriteParam(aWriter, (aVar).defaultValue());
// Sentinel = 'defaultValue'
(aWriter)->WriteSentinel(529597667);
IPC::WriteParam(aWriter, (aVar).userValue());
// Sentinel = 'userValue'
(aWriter)->WriteSentinel(317850557);
}
auto ParamTraits<::mozilla::dom::Pref>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___name = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___name) {
aReader->FatalError("Error deserializing 'name' (nsCString) member of 'Pref'");
return {};
}
auto& _name = *maybe___name;
// Sentinel = 'name'
if ((!((aReader)->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsCString) member of 'Pref'");
return {};
}
auto maybe___isLocked = IPC::ReadParam<bool>(aReader);
if (!maybe___isLocked) {
aReader->FatalError("Error deserializing 'isLocked' (bool) member of 'Pref'");
return {};
}
auto& _isLocked = *maybe___isLocked;
// Sentinel = 'isLocked'
if ((!((aReader)->ReadSentinel(241369903)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isLocked' (bool) member of 'Pref'");
return {};
}
auto maybe___isSanitized = IPC::ReadParam<bool>(aReader);
if (!maybe___isSanitized) {
aReader->FatalError("Error deserializing 'isSanitized' (bool) member of 'Pref'");
return {};
}
auto& _isSanitized = *maybe___isSanitized;
// Sentinel = 'isSanitized'
if ((!((aReader)->ReadSentinel(452658312)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isSanitized' (bool) member of 'Pref'");
return {};
}
auto maybe___defaultValue = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::PrefValue>>(aReader);
if (!maybe___defaultValue) {
aReader->FatalError("Error deserializing 'defaultValue' (PrefValue?) member of 'Pref'");
return {};
}
auto& _defaultValue = *maybe___defaultValue;
// Sentinel = 'defaultValue'
if ((!((aReader)->ReadSentinel(529597667)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'defaultValue' (PrefValue?) member of 'Pref'");
return {};
}
auto maybe___userValue = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::PrefValue>>(aReader);
if (!maybe___userValue) {
aReader->FatalError("Error deserializing 'userValue' (PrefValue?) member of 'Pref'");
return {};
}
auto& _userValue = *maybe___userValue;
// Sentinel = 'userValue'
if ((!((aReader)->ReadSentinel(317850557)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'userValue' (PrefValue?) member of 'Pref'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_name),
std::move(_isLocked),
std::move(_isSanitized),
std::move(_defaultValue),
std::move(_userValue)};
return result__;
}
} // namespace IPC