//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/SerialPortIPCTypes.h"
#include "mozilla/dom/SerialTypes.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 |struct IPCSerialPortInfo|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCSerialPortInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).id());
// Sentinel = 'id'
(aWriter)->WriteSentinel(20447438);
IPC::WriteParam(aWriter, (aVar).path());
// Sentinel = 'path'
(aWriter)->WriteSentinel(70713774);
IPC::WriteParam(aWriter, (aVar).friendlyName());
// Sentinel = 'friendlyName'
(aWriter)->WriteSentinel(537658591);
IPC::WriteParam(aWriter, (aVar).usbVendorId());
// Sentinel = 'usbVendorId'
(aWriter)->WriteSentinel(453313638);
IPC::WriteParam(aWriter, (aVar).usbProductId());
// Sentinel = 'usbProductId'
(aWriter)->WriteSentinel(540345561);
IPC::WriteParam(aWriter, (aVar).bluetoothServiceClassId());
// Sentinel = 'bluetoothServiceClassId'
(aWriter)->WriteSentinel(1912211787);
}
auto ParamTraits<::mozilla::dom::IPCSerialPortInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___id = IPC::ReadParam<::nsString>(aReader);
if (!maybe___id) {
aReader->FatalError("Error deserializing 'id' (nsString) member of 'IPCSerialPortInfo'");
return {};
}
auto& _id = *maybe___id;
// Sentinel = 'id'
if ((!((aReader)->ReadSentinel(20447438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsString) member of 'IPCSerialPortInfo'");
return {};
}
auto maybe___path = IPC::ReadParam<::nsString>(aReader);
if (!maybe___path) {
aReader->FatalError("Error deserializing 'path' (nsString) member of 'IPCSerialPortInfo'");
return {};
}
auto& _path = *maybe___path;
// Sentinel = 'path'
if ((!((aReader)->ReadSentinel(70713774)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'path' (nsString) member of 'IPCSerialPortInfo'");
return {};
}
auto maybe___friendlyName = IPC::ReadParam<::nsString>(aReader);
if (!maybe___friendlyName) {
aReader->FatalError("Error deserializing 'friendlyName' (nsString) member of 'IPCSerialPortInfo'");
return {};
}
auto& _friendlyName = *maybe___friendlyName;
// Sentinel = 'friendlyName'
if ((!((aReader)->ReadSentinel(537658591)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'friendlyName' (nsString) member of 'IPCSerialPortInfo'");
return {};
}
auto maybe___usbVendorId = IPC::ReadParam<mozilla::Maybe<::uint16_t>>(aReader);
if (!maybe___usbVendorId) {
aReader->FatalError("Error deserializing 'usbVendorId' (uint16_t?) member of 'IPCSerialPortInfo'");
return {};
}
auto& _usbVendorId = *maybe___usbVendorId;
// Sentinel = 'usbVendorId'
if ((!((aReader)->ReadSentinel(453313638)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'usbVendorId' (uint16_t?) member of 'IPCSerialPortInfo'");
return {};
}
auto maybe___usbProductId = IPC::ReadParam<mozilla::Maybe<::uint16_t>>(aReader);
if (!maybe___usbProductId) {
aReader->FatalError("Error deserializing 'usbProductId' (uint16_t?) member of 'IPCSerialPortInfo'");
return {};
}
auto& _usbProductId = *maybe___usbProductId;
// Sentinel = 'usbProductId'
if ((!((aReader)->ReadSentinel(540345561)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'usbProductId' (uint16_t?) member of 'IPCSerialPortInfo'");
return {};
}
auto maybe___bluetoothServiceClassId = IPC::ReadParam<mozilla::Maybe<::nsString>>(aReader);
if (!maybe___bluetoothServiceClassId) {
aReader->FatalError("Error deserializing 'bluetoothServiceClassId' (nsString?) member of 'IPCSerialPortInfo'");
return {};
}
auto& _bluetoothServiceClassId = *maybe___bluetoothServiceClassId;
// Sentinel = 'bluetoothServiceClassId'
if ((!((aReader)->ReadSentinel(1912211787)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bluetoothServiceClassId' (nsString?) member of 'IPCSerialPortInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_id),
std::move(_path),
std::move(_friendlyName),
std::move(_usbVendorId),
std::move(_usbProductId),
std::move(_bluetoothServiceClassId)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCSerialOptions|
//
namespace mozilla {
namespace dom {
auto IPCSerialOptions::StaticAssertions() const -> void
{
static_assert(
(offsetof(IPCSerialOptions, bufferSize_) - offsetof(IPCSerialOptions, baudRate_)) == 4,
"Bad assumptions about field layout!");
static_assert(
(offsetof(IPCSerialOptions, stopBits_) - offsetof(IPCSerialOptions, dataBits_)) == 1,
"Bad assumptions about field layout!");
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCSerialOptions>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).parity());
// Sentinel = 'parity'
(aWriter)->WriteSentinel(149881498);
IPC::WriteParam(aWriter, (aVar).flowControl());
// Sentinel = 'flowControl'
(aWriter)->WriteSentinel(457770138);
(aWriter)->WriteBytes((&((aVar).baudRate())), 8);
// Sentinel = 'baudRate | bufferSize'
(aWriter)->WriteSentinel(1450248186);
(aWriter)->WriteBytes((&((aVar).dataBits())), 2);
// Sentinel = 'dataBits | stopBits'
(aWriter)->WriteSentinel(1199376193);
}
auto ParamTraits<::mozilla::dom::IPCSerialOptions>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___parity = IPC::ReadParam<::mozilla::dom::ParityType>(aReader);
if (!maybe___parity) {
aReader->FatalError("Error deserializing 'parity' (ParityType) member of 'IPCSerialOptions'");
return {};
}
auto& _parity = *maybe___parity;
// Sentinel = 'parity'
if ((!((aReader)->ReadSentinel(149881498)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'parity' (ParityType) member of 'IPCSerialOptions'");
return {};
}
auto maybe___flowControl = IPC::ReadParam<::mozilla::dom::FlowControlType>(aReader);
if (!maybe___flowControl) {
aReader->FatalError("Error deserializing 'flowControl' (FlowControlType) member of 'IPCSerialOptions'");
return {};
}
auto& _flowControl = *maybe___flowControl;
// Sentinel = 'flowControl'
if ((!((aReader)->ReadSentinel(457770138)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'flowControl' (FlowControlType) member of 'IPCSerialOptions'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0},
::uint8_t{0},
::uint8_t{0},
std::move(_parity),
::uint32_t{0},
std::move(_flowControl)};
if ((!((aReader)->ReadBytesInto((&((result__)->baudRate())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'baudRate | bufferSize'
if ((!((aReader)->ReadSentinel(1450248186)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->dataBits())), 2)))) {
aReader->FatalError("Error bulk reading fields from uint8_t");
return {};
}
// Sentinel = 'dataBits | stopBits'
if ((!((aReader)->ReadSentinel(1199376193)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint8_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCSerialOutputSignals|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCSerialOutputSignals>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).dataTerminalReady());
// Sentinel = 'dataTerminalReady'
(aWriter)->WriteSentinel(1021904588);
IPC::WriteParam(aWriter, (aVar).requestToSend());
// Sentinel = 'requestToSend'
(aWriter)->WriteSentinel(640615767);
IPC::WriteParam(aWriter, (aVar).breakSignal());
// Sentinel = 'breakSignal'
(aWriter)->WriteSentinel(441058404);
}
auto ParamTraits<::mozilla::dom::IPCSerialOutputSignals>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___dataTerminalReady = IPC::ReadParam<mozilla::Maybe<bool>>(aReader);
if (!maybe___dataTerminalReady) {
aReader->FatalError("Error deserializing 'dataTerminalReady' (bool?) member of 'IPCSerialOutputSignals'");
return {};
}
auto& _dataTerminalReady = *maybe___dataTerminalReady;
// Sentinel = 'dataTerminalReady'
if ((!((aReader)->ReadSentinel(1021904588)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dataTerminalReady' (bool?) member of 'IPCSerialOutputSignals'");
return {};
}
auto maybe___requestToSend = IPC::ReadParam<mozilla::Maybe<bool>>(aReader);
if (!maybe___requestToSend) {
aReader->FatalError("Error deserializing 'requestToSend' (bool?) member of 'IPCSerialOutputSignals'");
return {};
}
auto& _requestToSend = *maybe___requestToSend;
// Sentinel = 'requestToSend'
if ((!((aReader)->ReadSentinel(640615767)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestToSend' (bool?) member of 'IPCSerialOutputSignals'");
return {};
}
auto maybe___breakSignal = IPC::ReadParam<mozilla::Maybe<bool>>(aReader);
if (!maybe___breakSignal) {
aReader->FatalError("Error deserializing 'breakSignal' (bool?) member of 'IPCSerialOutputSignals'");
return {};
}
auto& _breakSignal = *maybe___breakSignal;
// Sentinel = 'breakSignal'
if ((!((aReader)->ReadSentinel(441058404)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'breakSignal' (bool?) member of 'IPCSerialOutputSignals'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_dataTerminalReady),
std::move(_requestToSend),
std::move(_breakSignal)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCSerialInputSignals|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCSerialInputSignals>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).dataCarrierDetect());
// Sentinel = 'dataCarrierDetect'
(aWriter)->WriteSentinel(1005389500);
IPC::WriteParam(aWriter, (aVar).clearToSend());
// Sentinel = 'clearToSend'
(aWriter)->WriteSentinel(437584981);
IPC::WriteParam(aWriter, (aVar).ringIndicator());
// Sentinel = 'ringIndicator'
(aWriter)->WriteSentinel(617940302);
IPC::WriteParam(aWriter, (aVar).dataSetReady());
// Sentinel = 'dataSetReady'
(aWriter)->WriteSentinel(511509692);
}
auto ParamTraits<::mozilla::dom::IPCSerialInputSignals>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___dataCarrierDetect = IPC::ReadParam<bool>(aReader);
if (!maybe___dataCarrierDetect) {
aReader->FatalError("Error deserializing 'dataCarrierDetect' (bool) member of 'IPCSerialInputSignals'");
return {};
}
auto& _dataCarrierDetect = *maybe___dataCarrierDetect;
// Sentinel = 'dataCarrierDetect'
if ((!((aReader)->ReadSentinel(1005389500)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dataCarrierDetect' (bool) member of 'IPCSerialInputSignals'");
return {};
}
auto maybe___clearToSend = IPC::ReadParam<bool>(aReader);
if (!maybe___clearToSend) {
aReader->FatalError("Error deserializing 'clearToSend' (bool) member of 'IPCSerialInputSignals'");
return {};
}
auto& _clearToSend = *maybe___clearToSend;
// Sentinel = 'clearToSend'
if ((!((aReader)->ReadSentinel(437584981)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'clearToSend' (bool) member of 'IPCSerialInputSignals'");
return {};
}
auto maybe___ringIndicator = IPC::ReadParam<bool>(aReader);
if (!maybe___ringIndicator) {
aReader->FatalError("Error deserializing 'ringIndicator' (bool) member of 'IPCSerialInputSignals'");
return {};
}
auto& _ringIndicator = *maybe___ringIndicator;
// Sentinel = 'ringIndicator'
if ((!((aReader)->ReadSentinel(617940302)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ringIndicator' (bool) member of 'IPCSerialInputSignals'");
return {};
}
auto maybe___dataSetReady = IPC::ReadParam<bool>(aReader);
if (!maybe___dataSetReady) {
aReader->FatalError("Error deserializing 'dataSetReady' (bool) member of 'IPCSerialInputSignals'");
return {};
}
auto& _dataSetReady = *maybe___dataSetReady;
// Sentinel = 'dataSetReady'
if ((!((aReader)->ReadSentinel(511509692)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dataSetReady' (bool) member of 'IPCSerialInputSignals'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_dataCarrierDetect),
std::move(_clearToSend),
std::move(_ringIndicator),
std::move(_dataSetReady)};
return result__;
}
} // namespace IPC