//
// Automatically generated by ipdlc.
// Edit at your own risk
//


#include "mozilla/widget/LookAndFeelTypes.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 LookAndFeelFont|
//
namespace mozilla {
namespace widget {
auto LookAndFeelFont::operator==(const LookAndFeelFont& _o) const -> bool
{
    if ((!((haveFont()) == ((_o).haveFont())))) {
        return false;
    }
    if ((!((name()) == ((_o).name())))) {
        return false;
    }
    if ((!((size()) == ((_o).size())))) {
        return false;
    }
    if ((!((weight()) == ((_o).weight())))) {
        return false;
    }
    if ((!((italic()) == ((_o).italic())))) {
        return false;
    }
    return true;
}

auto LookAndFeelFont::operator!=(const LookAndFeelFont& _o) const -> bool
{
    return (!(operator==(_o)));
}

auto LookAndFeelFont::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(LookAndFeelFont, weight_) - offsetof(LookAndFeelFont, size_)) == 4,
        "Bad assumptions about field layout!");
}

} // namespace widget
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::widget::LookAndFeelFont>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).haveFont());
    // Sentinel = 'haveFont'
    (aWriter)->WriteSentinel(241238844);
    IPC::WriteParam(aWriter, (aVar).name());
    // Sentinel = 'name'
    (aWriter)->WriteSentinel(69075362);
    IPC::WriteParam(aWriter, (aVar).italic());
    // Sentinel = 'italic'
    (aWriter)->WriteSentinel(146604663);
    (aWriter)->WriteBytes((&((aVar).size())), 8);
    // Sentinel = 'size | weight'
    (aWriter)->WriteSentinel(583009536);
}

auto ParamTraits<::mozilla::widget::LookAndFeelFont>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___haveFont = IPC::ReadParam<bool>(aReader);
    if (!maybe___haveFont) {
        aReader->FatalError("Error deserializing 'haveFont' (bool) member of 'LookAndFeelFont'");
        return {};

    }
    auto& _haveFont = *maybe___haveFont;
    // Sentinel = 'haveFont'
    if ((!((aReader)->ReadSentinel(241238844)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'haveFont' (bool) member of 'LookAndFeelFont'");
        return {};
    }
    auto maybe___name = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___name) {
        aReader->FatalError("Error deserializing 'name' (nsString) member of 'LookAndFeelFont'");
        return {};

    }
    auto& _name = *maybe___name;
    // Sentinel = 'name'
    if ((!((aReader)->ReadSentinel(69075362)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'LookAndFeelFont'");
        return {};
    }
    auto maybe___italic = IPC::ReadParam<bool>(aReader);
    if (!maybe___italic) {
        aReader->FatalError("Error deserializing 'italic' (bool) member of 'LookAndFeelFont'");
        return {};

    }
    auto& _italic = *maybe___italic;
    // Sentinel = 'italic'
    if ((!((aReader)->ReadSentinel(146604663)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'italic' (bool) member of 'LookAndFeelFont'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_haveFont),
            std::move(_name),
            float{0},
            float{0},
            std::move(_italic)};
    if ((!((aReader)->ReadBytesInto((&((result__)->size())), 8)))) {
        aReader->FatalError("Error bulk reading fields from float");
        return {};
    }
    // Sentinel = 'size | weight'
    if ((!((aReader)->ReadSentinel(583009536)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from float");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct LookAndFeelTables|
//
namespace mozilla {
namespace widget {
} // namespace widget
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::widget::LookAndFeelTables>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).ints());
    // Sentinel = 'ints'
    (aWriter)->WriteSentinel(72155583);
    IPC::WriteParam(aWriter, (aVar).floats());
    // Sentinel = 'floats'
    (aWriter)->WriteSentinel(146801290);
    IPC::WriteParam(aWriter, (aVar).fonts());
    // Sentinel = 'fonts'
    (aWriter)->WriteSentinel(107217451);
    IPC::WriteParam(aWriter, (aVar).lightColors());
    // Sentinel = 'lightColors'
    (aWriter)->WriteSentinel(451216523);
    IPC::WriteParam(aWriter, (aVar).darkColors());
    // Sentinel = 'darkColors'
    (aWriter)->WriteSentinel(367592469);
    IPC::WriteParam(aWriter, (aVar).intMap());
    // Sentinel = 'intMap'
    (aWriter)->WriteSentinel(143327850);
    IPC::WriteParam(aWriter, (aVar).floatMap());
    // Sentinel = 'floatMap'
    (aWriter)->WriteSentinel(244581173);
    IPC::WriteParam(aWriter, (aVar).fontMap());
    // Sentinel = 'fontMap'
    (aWriter)->WriteSentinel(192545494);
    IPC::WriteParam(aWriter, (aVar).lightColorMap());
    // Sentinel = 'lightColorMap'
    (aWriter)->WriteSentinel(616236342);
    IPC::WriteParam(aWriter, (aVar).darkColorMap());
    // Sentinel = 'darkColorMap'
    (aWriter)->WriteSentinel(517145792);
    IPC::WriteParam(aWriter, (aVar).passwordEcho());
    // Sentinel = 'passwordEcho'
    (aWriter)->WriteSentinel(551355635);
    (aWriter)->WriteBytes((&((aVar).passwordChar())), 2);
    // Sentinel = 'passwordChar'
    (aWriter)->WriteSentinel(551093490);
}

auto ParamTraits<::mozilla::widget::LookAndFeelTables>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___ints = IPC::ReadParam<nsTArray<::int32_t>>(aReader);
    if (!maybe___ints) {
        aReader->FatalError("Error deserializing 'ints' (int32_t[]) member of 'LookAndFeelTables'");
        return {};

    }
    auto& _ints = *maybe___ints;
    // Sentinel = 'ints'
    if ((!((aReader)->ReadSentinel(72155583)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ints' (int32_t[]) member of 'LookAndFeelTables'");
        return {};
    }
    auto maybe___floats = IPC::ReadParam<nsTArray<float>>(aReader);
    if (!maybe___floats) {
        aReader->FatalError("Error deserializing 'floats' (float[]) member of 'LookAndFeelTables'");
        return {};

    }
    auto& _floats = *maybe___floats;
    // Sentinel = 'floats'
    if ((!((aReader)->ReadSentinel(146801290)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'floats' (float[]) member of 'LookAndFeelTables'");
        return {};
    }
    auto maybe___fonts = IPC::ReadParam<nsTArray<::mozilla::widget::LookAndFeelFont>>(aReader);
    if (!maybe___fonts) {
        aReader->FatalError("Error deserializing 'fonts' (LookAndFeelFont[]) member of 'LookAndFeelTables'");
        return {};

    }
    auto& _fonts = *maybe___fonts;
    // Sentinel = 'fonts'
    if ((!((aReader)->ReadSentinel(107217451)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fonts' (LookAndFeelFont[]) member of 'LookAndFeelTables'");
        return {};
    }
    auto maybe___lightColors = IPC::ReadParam<nsTArray<::nscolor>>(aReader);
    if (!maybe___lightColors) {
        aReader->FatalError("Error deserializing 'lightColors' (nscolor[]) member of 'LookAndFeelTables'");
        return {};

    }
    auto& _lightColors = *maybe___lightColors;
    // Sentinel = 'lightColors'
    if ((!((aReader)->ReadSentinel(451216523)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'lightColors' (nscolor[]) member of 'LookAndFeelTables'");
        return {};
    }
    auto maybe___darkColors = IPC::ReadParam<nsTArray<::nscolor>>(aReader);
    if (!maybe___darkColors) {
        aReader->FatalError("Error deserializing 'darkColors' (nscolor[]) member of 'LookAndFeelTables'");
        return {};

    }
    auto& _darkColors = *maybe___darkColors;
    // Sentinel = 'darkColors'
    if ((!((aReader)->ReadSentinel(367592469)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'darkColors' (nscolor[]) member of 'LookAndFeelTables'");
        return {};
    }
    auto maybe___intMap = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___intMap) {
        aReader->FatalError("Error deserializing 'intMap' (uint8_t[]) member of 'LookAndFeelTables'");
        return {};

    }
    auto& _intMap = *maybe___intMap;
    // Sentinel = 'intMap'
    if ((!((aReader)->ReadSentinel(143327850)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'intMap' (uint8_t[]) member of 'LookAndFeelTables'");
        return {};
    }
    auto maybe___floatMap = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___floatMap) {
        aReader->FatalError("Error deserializing 'floatMap' (uint8_t[]) member of 'LookAndFeelTables'");
        return {};

    }
    auto& _floatMap = *maybe___floatMap;
    // Sentinel = 'floatMap'
    if ((!((aReader)->ReadSentinel(244581173)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'floatMap' (uint8_t[]) member of 'LookAndFeelTables'");
        return {};
    }
    auto maybe___fontMap = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___fontMap) {
        aReader->FatalError("Error deserializing 'fontMap' (uint8_t[]) member of 'LookAndFeelTables'");
        return {};

    }
    auto& _fontMap = *maybe___fontMap;
    // Sentinel = 'fontMap'
    if ((!((aReader)->ReadSentinel(192545494)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fontMap' (uint8_t[]) member of 'LookAndFeelTables'");
        return {};
    }
    auto maybe___lightColorMap = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___lightColorMap) {
        aReader->FatalError("Error deserializing 'lightColorMap' (uint8_t[]) member of 'LookAndFeelTables'");
        return {};

    }
    auto& _lightColorMap = *maybe___lightColorMap;
    // Sentinel = 'lightColorMap'
    if ((!((aReader)->ReadSentinel(616236342)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'lightColorMap' (uint8_t[]) member of 'LookAndFeelTables'");
        return {};
    }
    auto maybe___darkColorMap = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___darkColorMap) {
        aReader->FatalError("Error deserializing 'darkColorMap' (uint8_t[]) member of 'LookAndFeelTables'");
        return {};

    }
    auto& _darkColorMap = *maybe___darkColorMap;
    // Sentinel = 'darkColorMap'
    if ((!((aReader)->ReadSentinel(517145792)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'darkColorMap' (uint8_t[]) member of 'LookAndFeelTables'");
        return {};
    }
    auto maybe___passwordEcho = IPC::ReadParam<bool>(aReader);
    if (!maybe___passwordEcho) {
        aReader->FatalError("Error deserializing 'passwordEcho' (bool) member of 'LookAndFeelTables'");
        return {};

    }
    auto& _passwordEcho = *maybe___passwordEcho;
    // Sentinel = 'passwordEcho'
    if ((!((aReader)->ReadSentinel(551355635)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'passwordEcho' (bool) member of 'LookAndFeelTables'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_ints),
            std::move(_floats),
            std::move(_fonts),
            std::move(_lightColors),
            std::move(_darkColors),
            std::move(_intMap),
            std::move(_floatMap),
            std::move(_fontMap),
            std::move(_lightColorMap),
            std::move(_darkColorMap),
            ::uint16_t{0},
            std::move(_passwordEcho)};
    if ((!((aReader)->ReadBytesInto((&((result__)->passwordChar())), 2)))) {
        aReader->FatalError("Error bulk reading fields from uint16_t");
        return {};
    }
    // Sentinel = 'passwordChar'
    if ((!((aReader)->ReadSentinel(551093490)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint16_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FullLookAndFeel|
//
namespace mozilla {
namespace widget {
} // namespace widget
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::widget::FullLookAndFeel>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).tables());
    // Sentinel = 'tables'
    (aWriter)->WriteSentinel(145490556);
}

auto ParamTraits<::mozilla::widget::FullLookAndFeel>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___tables = IPC::ReadParam<::mozilla::widget::LookAndFeelTables>(aReader);
    if (!maybe___tables) {
        aReader->FatalError("Error deserializing 'tables' (LookAndFeelTables) member of 'FullLookAndFeel'");
        return {};

    }
    auto& _tables = *maybe___tables;
    // Sentinel = 'tables'
    if ((!((aReader)->ReadSentinel(145490556)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'tables' (LookAndFeelTables) member of 'FullLookAndFeel'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_tables)};
    return result__;
}

} // namespace IPC
