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


#include "mozilla/ipc/PChildToParentStreamParent.h"
#include "mozilla/ipc/PChildToParentStreamChild.h"
#include "mozilla/ipc/PParentToChildStreamParent.h"
#include "mozilla/ipc/PParentToChildStreamChild.h"
#include "mozilla/ipc/InputStreamParams.h"


//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct HeaderEntry|
//
namespace mozilla {
namespace ipc {
auto HeaderEntry::operator==(const HeaderEntry& _o) const -> bool
{
    if ((!((name()) == ((_o).name())))) {
        return false;
    }
    if ((!((value()) == ((_o).value())))) {
        return false;
    }
    return true;
}

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::HeaderEntry>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).name());
    // Sentinel = 'name'
    (aMsg)->WriteSentinel(15034981);
    WriteIPDLParam(aMsg, aActor, (aVar).value());
    // Sentinel = 'value'
    (aMsg)->WriteSentinel(3456818542);
}

auto IPDLParamTraits<mozilla::ipc::HeaderEntry>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->name())))))) {
        aActor->FatalError("Error deserializing 'name' (nsCString) member of 'HeaderEntry'");
        return false;
    }
    // Sentinel = 'name'
    if ((!((aMsg)->ReadSentinel(aIter, 15034981)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsCString) member of 'HeaderEntry'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->value())))))) {
        aActor->FatalError("Error deserializing 'value' (nsCString) member of 'HeaderEntry'");
        return false;
    }
    // Sentinel = 'value'
    if ((!((aMsg)->ReadSentinel(aIter, 3456818542)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsCString) member of 'HeaderEntry'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StringInputStreamParams|
//
namespace mozilla {
namespace ipc {
auto StringInputStreamParams::operator==(const StringInputStreamParams& _o) const -> bool
{
    if ((!((data()) == ((_o).data())))) {
        return false;
    }
    return true;
}

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::StringInputStreamParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).data());
    // Sentinel = 'data'
    (aMsg)->WriteSentinel(843352540);
}

auto IPDLParamTraits<mozilla::ipc::StringInputStreamParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->data())))))) {
        aActor->FatalError("Error deserializing 'data' (nsCString) member of 'StringInputStreamParams'");
        return false;
    }
    // Sentinel = 'data'
    if ((!((aMsg)->ReadSentinel(aIter, 843352540)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsCString) member of 'StringInputStreamParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileInputStreamParams|
//
namespace mozilla {
namespace ipc {
auto FileInputStreamParams::operator==(const FileInputStreamParams& _o) const -> bool
{
    if ((!((fileDescriptorIndex()) == ((_o).fileDescriptorIndex())))) {
        return false;
    }
    if ((!((behaviorFlags()) == ((_o).behaviorFlags())))) {
        return false;
    }
    if ((!((ioFlags()) == ((_o).ioFlags())))) {
        return false;
    }
    return true;
}

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

auto FileInputStreamParams::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(FileInputStreamParams, ioFlags_) - offsetof(FileInputStreamParams, fileDescriptorIndex_)) == 8,
        "Bad assumptions about field layout!");
}

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::FileInputStreamParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    (aMsg)->WriteBytes((&((aVar).fileDescriptorIndex())), 12);
    // Sentinel = 'fileDescriptorIndex | behaviorFlags | ioFlags'
    (aMsg)->WriteSentinel(2285764100);
}

auto IPDLParamTraits<mozilla::ipc::FileInputStreamParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!((aMsg)->ReadBytesInto(aIter, (&((aVar)->fileDescriptorIndex())), 12)))) {
        aActor->FatalError("Error bulk reading fields from uint32_t");
        return false;
    }
    // Sentinel = 'fileDescriptorIndex | behaviorFlags | ioFlags'
    if ((!((aMsg)->ReadSentinel(aIter, 2285764100)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct MultiplexInputStreamParams|
//
namespace mozilla {
namespace ipc {
auto MultiplexInputStreamParams::operator==(const MultiplexInputStreamParams& _o) const -> bool
{
    if ((!((streams()) == ((_o).streams())))) {
        return false;
    }
    if ((!((currentStream()) == ((_o).currentStream())))) {
        return false;
    }
    if ((!((status()) == ((_o).status())))) {
        return false;
    }
    if ((!((startedReadingCurrent()) == ((_o).startedReadingCurrent())))) {
        return false;
    }
    return true;
}

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::MultiplexInputStreamParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).streams());
    // Sentinel = 'streams'
    (aMsg)->WriteSentinel(4240383220);
    WriteIPDLParam(aMsg, aActor, (aVar).status());
    // Sentinel = 'status'
    (aMsg)->WriteSentinel(3714608576);
    WriteIPDLParam(aMsg, aActor, (aVar).startedReadingCurrent());
    // Sentinel = 'startedReadingCurrent'
    (aMsg)->WriteSentinel(970542033);
    (aMsg)->WriteBytes((&((aVar).currentStream())), 4);
    // Sentinel = 'currentStream'
    (aMsg)->WriteSentinel(682778074);
}

auto IPDLParamTraits<mozilla::ipc::MultiplexInputStreamParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->streams())))))) {
        aActor->FatalError("Error deserializing 'streams' (InputStreamParams[]) member of 'MultiplexInputStreamParams'");
        return false;
    }
    // Sentinel = 'streams'
    if ((!((aMsg)->ReadSentinel(aIter, 4240383220)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'streams' (InputStreamParams[]) member of 'MultiplexInputStreamParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->status())))))) {
        aActor->FatalError("Error deserializing 'status' (nsresult) member of 'MultiplexInputStreamParams'");
        return false;
    }
    // Sentinel = 'status'
    if ((!((aMsg)->ReadSentinel(aIter, 3714608576)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'status' (nsresult) member of 'MultiplexInputStreamParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->startedReadingCurrent())))))) {
        aActor->FatalError("Error deserializing 'startedReadingCurrent' (bool) member of 'MultiplexInputStreamParams'");
        return false;
    }
    // Sentinel = 'startedReadingCurrent'
    if ((!((aMsg)->ReadSentinel(aIter, 970542033)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'startedReadingCurrent' (bool) member of 'MultiplexInputStreamParams'");
        return false;
    }
    if ((!((aMsg)->ReadBytesInto(aIter, (&((aVar)->currentStream())), 4)))) {
        aActor->FatalError("Error bulk reading fields from uint32_t");
        return false;
    }
    // Sentinel = 'currentStream'
    if ((!((aMsg)->ReadSentinel(aIter, 682778074)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SlicedInputStreamParams|
//
namespace mozilla {
namespace ipc {
auto SlicedInputStreamParams::operator==(const SlicedInputStreamParams& _o) const -> bool
{
    if ((!((stream()) == ((_o).stream())))) {
        return false;
    }
    if ((!((start()) == ((_o).start())))) {
        return false;
    }
    if ((!((length()) == ((_o).length())))) {
        return false;
    }
    if ((!((curPos()) == ((_o).curPos())))) {
        return false;
    }
    if ((!((closed()) == ((_o).closed())))) {
        return false;
    }
    return true;
}

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

auto SlicedInputStreamParams::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(SlicedInputStreamParams, curPos_) - offsetof(SlicedInputStreamParams, start_)) == 16,
        "Bad assumptions about field layout!");
}

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::SlicedInputStreamParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).stream());
    // Sentinel = 'stream'
    (aMsg)->WriteSentinel(4152748422);
    WriteIPDLParam(aMsg, aActor, (aVar).closed());
    // Sentinel = 'closed'
    (aMsg)->WriteSentinel(561249462);
    (aMsg)->WriteBytes((&((aVar).start())), 24);
    // Sentinel = 'start | length | curPos'
    (aMsg)->WriteSentinel(2006646847);
}

auto IPDLParamTraits<mozilla::ipc::SlicedInputStreamParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->stream())))))) {
        aActor->FatalError("Error deserializing 'stream' (InputStreamParams) member of 'SlicedInputStreamParams'");
        return false;
    }
    // Sentinel = 'stream'
    if ((!((aMsg)->ReadSentinel(aIter, 4152748422)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'stream' (InputStreamParams) member of 'SlicedInputStreamParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->closed())))))) {
        aActor->FatalError("Error deserializing 'closed' (bool) member of 'SlicedInputStreamParams'");
        return false;
    }
    // Sentinel = 'closed'
    if ((!((aMsg)->ReadSentinel(aIter, 561249462)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'closed' (bool) member of 'SlicedInputStreamParams'");
        return false;
    }
    if ((!((aMsg)->ReadBytesInto(aIter, (&((aVar)->start())), 24)))) {
        aActor->FatalError("Error bulk reading fields from uint64_t");
        return false;
    }
    // Sentinel = 'start | length | curPos'
    if ((!((aMsg)->ReadSentinel(aIter, 2006646847)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCBlobInputStreamParams|
//
namespace mozilla {
namespace ipc {
auto IPCBlobInputStreamParams::operator==(const IPCBlobInputStreamParams& _o) const -> bool
{
    if ((!((id()) == ((_o).id())))) {
        return false;
    }
    if ((!((start()) == ((_o).start())))) {
        return false;
    }
    if ((!((length()) == ((_o).length())))) {
        return false;
    }
    return true;
}

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

auto IPCBlobInputStreamParams::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(IPCBlobInputStreamParams, length_) - offsetof(IPCBlobInputStreamParams, start_)) == 8,
        "Bad assumptions about field layout!");
}

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::IPCBlobInputStreamParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).id());
    // Sentinel = 'id'
    (aMsg)->WriteSentinel(2794505629);
    (aMsg)->WriteBytes((&((aVar).start())), 16);
    // Sentinel = 'start | length'
    (aMsg)->WriteSentinel(2165303634);
}

auto IPDLParamTraits<mozilla::ipc::IPCBlobInputStreamParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->id())))))) {
        aActor->FatalError("Error deserializing 'id' (nsID) member of 'IPCBlobInputStreamParams'");
        return false;
    }
    // Sentinel = 'id'
    if ((!((aMsg)->ReadSentinel(aIter, 2794505629)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsID) member of 'IPCBlobInputStreamParams'");
        return false;
    }
    if ((!((aMsg)->ReadBytesInto(aIter, (&((aVar)->start())), 16)))) {
        aActor->FatalError("Error bulk reading fields from uint64_t");
        return false;
    }
    // Sentinel = 'start | length'
    if ((!((aMsg)->ReadSentinel(aIter, 2165303634)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCRemoteStreamType|
//
namespace mozilla {
namespace ipc {
auto IPCRemoteStreamType::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TPChildToParentStreamParent:
        {
            (ptr_PChildToParentStreamParent())->~PChildToParentStreamParent__tdef();
            break;
        }
    case TPChildToParentStreamChild:
        {
            (ptr_PChildToParentStreamChild())->~PChildToParentStreamChild__tdef();
            break;
        }
    case TPParentToChildStreamParent:
        {
            (ptr_PParentToChildStreamParent())->~PParentToChildStreamParent__tdef();
            break;
        }
    case TPParentToChildStreamChild:
        {
            (ptr_PParentToChildStreamChild())->~PParentToChildStreamChild__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT IPCRemoteStreamType::IPCRemoteStreamType(PChildToParentStreamParent* aOther)
{
    new (mozilla::KnownNotNull, ptr_PChildToParentStreamParent()) PChildToParentStreamParent*(const_cast<PChildToParentStreamParent*>(aOther));
    mType = TPChildToParentStreamParent;
}

MOZ_IMPLICIT IPCRemoteStreamType::IPCRemoteStreamType(PChildToParentStreamChild* aOther)
{
    new (mozilla::KnownNotNull, ptr_PChildToParentStreamChild()) PChildToParentStreamChild*(const_cast<PChildToParentStreamChild*>(aOther));
    mType = TPChildToParentStreamChild;
}

MOZ_IMPLICIT IPCRemoteStreamType::IPCRemoteStreamType(PParentToChildStreamParent* aOther)
{
    new (mozilla::KnownNotNull, ptr_PParentToChildStreamParent()) PParentToChildStreamParent*(const_cast<PParentToChildStreamParent*>(aOther));
    mType = TPParentToChildStreamParent;
}

MOZ_IMPLICIT IPCRemoteStreamType::IPCRemoteStreamType(PParentToChildStreamChild* aOther)
{
    new (mozilla::KnownNotNull, ptr_PParentToChildStreamChild()) PParentToChildStreamChild*(const_cast<PParentToChildStreamChild*>(aOther));
    mType = TPParentToChildStreamChild;
}

MOZ_IMPLICIT IPCRemoteStreamType::IPCRemoteStreamType(const IPCRemoteStreamType& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TPChildToParentStreamParent:
        {
            new (mozilla::KnownNotNull, ptr_PChildToParentStreamParent()) PChildToParentStreamParent*(const_cast<PChildToParentStreamParent*>((aOther).get_PChildToParentStreamParent()));
            break;
        }
    case TPChildToParentStreamChild:
        {
            new (mozilla::KnownNotNull, ptr_PChildToParentStreamChild()) PChildToParentStreamChild*(const_cast<PChildToParentStreamChild*>((aOther).get_PChildToParentStreamChild()));
            break;
        }
    case TPParentToChildStreamParent:
        {
            new (mozilla::KnownNotNull, ptr_PParentToChildStreamParent()) PParentToChildStreamParent*(const_cast<PParentToChildStreamParent*>((aOther).get_PParentToChildStreamParent()));
            break;
        }
    case TPParentToChildStreamChild:
        {
            new (mozilla::KnownNotNull, ptr_PParentToChildStreamChild()) PParentToChildStreamChild*(const_cast<PParentToChildStreamChild*>((aOther).get_PParentToChildStreamChild()));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT IPCRemoteStreamType::IPCRemoteStreamType(IPCRemoteStreamType&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TPChildToParentStreamParent:
        {
            new (mozilla::KnownNotNull, ptr_PChildToParentStreamParent()) PChildToParentStreamParent*(const_cast<PChildToParentStreamParent*>(std::move((aOther).get_PChildToParentStreamParent())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPChildToParentStreamChild:
        {
            new (mozilla::KnownNotNull, ptr_PChildToParentStreamChild()) PChildToParentStreamChild*(const_cast<PChildToParentStreamChild*>(std::move((aOther).get_PChildToParentStreamChild())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPParentToChildStreamParent:
        {
            new (mozilla::KnownNotNull, ptr_PParentToChildStreamParent()) PParentToChildStreamParent*(const_cast<PParentToChildStreamParent*>(std::move((aOther).get_PParentToChildStreamParent())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPParentToChildStreamChild:
        {
            new (mozilla::KnownNotNull, ptr_PParentToChildStreamChild()) PParentToChildStreamChild*(const_cast<PParentToChildStreamChild*>(std::move((aOther).get_PParentToChildStreamChild())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

IPCRemoteStreamType::~IPCRemoteStreamType()
{
    static_cast<void>(MaybeDestroy(T__None));
}

auto IPCRemoteStreamType::operator=(PChildToParentStreamParent* aRhs) -> IPCRemoteStreamType&
{
    if (MaybeDestroy(TPChildToParentStreamParent)) {
        new (mozilla::KnownNotNull, ptr_PChildToParentStreamParent()) PChildToParentStreamParent*;
    }
    (*(ptr_PChildToParentStreamParent())) = const_cast<PChildToParentStreamParent*>(aRhs);
    mType = TPChildToParentStreamParent;
    return (*(this));
}

auto IPCRemoteStreamType::operator=(PChildToParentStreamChild* aRhs) -> IPCRemoteStreamType&
{
    if (MaybeDestroy(TPChildToParentStreamChild)) {
        new (mozilla::KnownNotNull, ptr_PChildToParentStreamChild()) PChildToParentStreamChild*;
    }
    (*(ptr_PChildToParentStreamChild())) = const_cast<PChildToParentStreamChild*>(aRhs);
    mType = TPChildToParentStreamChild;
    return (*(this));
}

auto IPCRemoteStreamType::operator=(PParentToChildStreamParent* aRhs) -> IPCRemoteStreamType&
{
    if (MaybeDestroy(TPParentToChildStreamParent)) {
        new (mozilla::KnownNotNull, ptr_PParentToChildStreamParent()) PParentToChildStreamParent*;
    }
    (*(ptr_PParentToChildStreamParent())) = const_cast<PParentToChildStreamParent*>(aRhs);
    mType = TPParentToChildStreamParent;
    return (*(this));
}

auto IPCRemoteStreamType::operator=(PParentToChildStreamChild* aRhs) -> IPCRemoteStreamType&
{
    if (MaybeDestroy(TPParentToChildStreamChild)) {
        new (mozilla::KnownNotNull, ptr_PParentToChildStreamChild()) PParentToChildStreamChild*;
    }
    (*(ptr_PParentToChildStreamChild())) = const_cast<PParentToChildStreamChild*>(aRhs);
    mType = TPParentToChildStreamChild;
    return (*(this));
}

auto IPCRemoteStreamType::operator=(const IPCRemoteStreamType& aRhs) -> IPCRemoteStreamType&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPChildToParentStreamParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PChildToParentStreamParent()) PChildToParentStreamParent*;
            }
            (*(ptr_PChildToParentStreamParent())) = const_cast<PChildToParentStreamParent*>((aRhs).get_PChildToParentStreamParent());
            break;
        }
    case TPChildToParentStreamChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PChildToParentStreamChild()) PChildToParentStreamChild*;
            }
            (*(ptr_PChildToParentStreamChild())) = const_cast<PChildToParentStreamChild*>((aRhs).get_PChildToParentStreamChild());
            break;
        }
    case TPParentToChildStreamParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PParentToChildStreamParent()) PParentToChildStreamParent*;
            }
            (*(ptr_PParentToChildStreamParent())) = const_cast<PParentToChildStreamParent*>((aRhs).get_PParentToChildStreamParent());
            break;
        }
    case TPParentToChildStreamChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PParentToChildStreamChild()) PParentToChildStreamChild*;
            }
            (*(ptr_PParentToChildStreamChild())) = const_cast<PParentToChildStreamChild*>((aRhs).get_PParentToChildStreamChild());
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto IPCRemoteStreamType::operator=(IPCRemoteStreamType&& aRhs) -> IPCRemoteStreamType&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPChildToParentStreamParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PChildToParentStreamParent()) PChildToParentStreamParent*;
            }
            (*(ptr_PChildToParentStreamParent())) = const_cast<PChildToParentStreamParent*>(std::move((aRhs).get_PChildToParentStreamParent()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPChildToParentStreamChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PChildToParentStreamChild()) PChildToParentStreamChild*;
            }
            (*(ptr_PChildToParentStreamChild())) = const_cast<PChildToParentStreamChild*>(std::move((aRhs).get_PChildToParentStreamChild()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPParentToChildStreamParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PParentToChildStreamParent()) PParentToChildStreamParent*;
            }
            (*(ptr_PParentToChildStreamParent())) = const_cast<PParentToChildStreamParent*>(std::move((aRhs).get_PParentToChildStreamParent()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPParentToChildStreamChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PParentToChildStreamChild()) PParentToChildStreamChild*;
            }
            (*(ptr_PParentToChildStreamChild())) = const_cast<PParentToChildStreamChild*>(std::move((aRhs).get_PParentToChildStreamChild()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto IPCRemoteStreamType::operator==(PChildToParentStreamParent* aRhs) const -> bool
{
    return (get_PChildToParentStreamParent()) == (aRhs);
}

auto IPCRemoteStreamType::operator==(PChildToParentStreamChild* aRhs) const -> bool
{
    return (get_PChildToParentStreamChild()) == (aRhs);
}

auto IPCRemoteStreamType::operator==(PParentToChildStreamParent* aRhs) const -> bool
{
    return (get_PParentToChildStreamParent()) == (aRhs);
}

auto IPCRemoteStreamType::operator==(PParentToChildStreamChild* aRhs) const -> bool
{
    return (get_PParentToChildStreamChild()) == (aRhs);
}

auto IPCRemoteStreamType::operator==(const IPCRemoteStreamType& aRhs) const -> bool
{
    if ((type()) != ((aRhs).type())) {
        return false;
    }

    switch (type()) {
    case TPChildToParentStreamParent:
        {
            return (get_PChildToParentStreamParent()) == ((aRhs).get_PChildToParentStreamParent());
        }
    case TPChildToParentStreamChild:
        {
            return (get_PChildToParentStreamChild()) == ((aRhs).get_PChildToParentStreamChild());
        }
    case TPParentToChildStreamParent:
        {
            return (get_PParentToChildStreamParent()) == ((aRhs).get_PParentToChildStreamParent());
        }
    case TPParentToChildStreamChild:
        {
            return (get_PParentToChildStreamChild()) == ((aRhs).get_PParentToChildStreamChild());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto IPCRemoteStreamType::get(PChildToParentStreamParent** aOutValue) const -> void
{
    (*(aOutValue)) = get_PChildToParentStreamParent();
}

auto IPCRemoteStreamType::get(PChildToParentStreamChild** aOutValue) const -> void
{
    (*(aOutValue)) = get_PChildToParentStreamChild();
}

auto IPCRemoteStreamType::get(PParentToChildStreamParent** aOutValue) const -> void
{
    (*(aOutValue)) = get_PParentToChildStreamParent();
}

auto IPCRemoteStreamType::get(PParentToChildStreamChild** aOutValue) const -> void
{
    (*(aOutValue)) = get_PParentToChildStreamChild();
}

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::IPCRemoteStreamType>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    typedef mozilla::ipc::IPCRemoteStreamType union__;
    int type;
    type = (aVar).type();
    WriteIPDLParam(aMsg, aActor, type);
    // Sentinel = 'IPCRemoteStreamType'
    (aMsg)->WriteSentinel(391674895);

    switch (type) {
    case union__::TPChildToParentStreamParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PChildToParentStreamParent(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PChildToParentStreamParent());
                // Sentinel = 'TPChildToParentStreamParent'
                (aMsg)->WriteSentinel(2724777622);
            }
            else {
                aActor->FatalError("wrong side!");
            }
            return;
        }
    case union__::TPChildToParentStreamChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PChildToParentStreamChild(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PChildToParentStreamChild());
                // Sentinel = 'TPChildToParentStreamChild'
                (aMsg)->WriteSentinel(1882094295);
            }
            else {
                aActor->FatalError("wrong side!");
            }
            return;
        }
    case union__::TPParentToChildStreamParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PParentToChildStreamParent(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PParentToChildStreamParent());
                // Sentinel = 'TPParentToChildStreamParent'
                (aMsg)->WriteSentinel(3335986876);
            }
            else {
                aActor->FatalError("wrong side!");
            }
            return;
        }
    case union__::TPParentToChildStreamChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PParentToChildStreamChild(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PParentToChildStreamChild());
                // Sentinel = 'TPParentToChildStreamChild'
                (aMsg)->WriteSentinel(190098493);
            }
            else {
                aActor->FatalError("wrong side!");
            }
            return;
        }
    default:
        {
            aActor->FatalError("unknown union type");
            return;
        }
    }
}

auto IPDLParamTraits<mozilla::ipc::IPCRemoteStreamType>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    typedef mozilla::ipc::IPCRemoteStreamType union__;
    int type;
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&(type)))))) {
        aActor->FatalError("Error deserializing type of union IPCRemoteStreamType");
        return false;
    }
    // Sentinel = 'IPCRemoteStreamType'
    if ((!((aMsg)->ReadSentinel(aIter, 391674895)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union IPCRemoteStreamType");
        return false;
    }

    switch (type) {
    case union__::TPChildToParentStreamParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                {
                    aActor->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::ipc::PChildToParentStreamChild* tmp = nullptr;
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PChildToParentStreamChild())))))) {
                aActor->FatalError("Error deserializing variant TPChildToParentStreamParent of union IPCRemoteStreamType");
                return false;
            }
            if ((!((*((&((aVar)->get_PChildToParentStreamChild()))))))) {
                aActor->FatalError("Error deserializing variant TPChildToParentStreamParent of union IPCRemoteStreamType");
                return false;
            }
            // Sentinel = 'TPChildToParentStreamParent'
            if ((!((aMsg)->ReadSentinel(aIter, 2724777622)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPChildToParentStreamParent of union IPCRemoteStreamType");
                return false;
            }
            return true;
        }
    case union__::TPChildToParentStreamChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                {
                    aActor->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::ipc::PChildToParentStreamParent* tmp = nullptr;
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PChildToParentStreamParent())))))) {
                aActor->FatalError("Error deserializing variant TPChildToParentStreamChild of union IPCRemoteStreamType");
                return false;
            }
            if ((!((*((&((aVar)->get_PChildToParentStreamParent()))))))) {
                aActor->FatalError("Error deserializing variant TPChildToParentStreamChild of union IPCRemoteStreamType");
                return false;
            }
            // Sentinel = 'TPChildToParentStreamChild'
            if ((!((aMsg)->ReadSentinel(aIter, 1882094295)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPChildToParentStreamChild of union IPCRemoteStreamType");
                return false;
            }
            return true;
        }
    case union__::TPParentToChildStreamParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                {
                    aActor->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::ipc::PParentToChildStreamChild* tmp = nullptr;
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PParentToChildStreamChild())))))) {
                aActor->FatalError("Error deserializing variant TPParentToChildStreamParent of union IPCRemoteStreamType");
                return false;
            }
            if ((!((*((&((aVar)->get_PParentToChildStreamChild()))))))) {
                aActor->FatalError("Error deserializing variant TPParentToChildStreamParent of union IPCRemoteStreamType");
                return false;
            }
            // Sentinel = 'TPParentToChildStreamParent'
            if ((!((aMsg)->ReadSentinel(aIter, 3335986876)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPParentToChildStreamParent of union IPCRemoteStreamType");
                return false;
            }
            return true;
        }
    case union__::TPParentToChildStreamChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                {
                    aActor->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::ipc::PParentToChildStreamParent* tmp = nullptr;
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PParentToChildStreamParent())))))) {
                aActor->FatalError("Error deserializing variant TPParentToChildStreamChild of union IPCRemoteStreamType");
                return false;
            }
            if ((!((*((&((aVar)->get_PParentToChildStreamParent()))))))) {
                aActor->FatalError("Error deserializing variant TPParentToChildStreamChild of union IPCRemoteStreamType");
                return false;
            }
            // Sentinel = 'TPParentToChildStreamChild'
            if ((!((aMsg)->ReadSentinel(aIter, 190098493)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPParentToChildStreamChild of union IPCRemoteStreamType");
                return false;
            }
            return true;
        }
    default:
        {
            aActor->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCRemoteStreamParams|
//
namespace mozilla {
namespace ipc {
auto IPCRemoteStreamParams::operator==(const IPCRemoteStreamParams& _o) const -> bool
{
    if ((!((delayedStart()) == ((_o).delayedStart())))) {
        return false;
    }
    if ((!((stream()) == ((_o).stream())))) {
        return false;
    }
    if ((!((length()) == ((_o).length())))) {
        return false;
    }
    return true;
}

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::IPCRemoteStreamParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).delayedStart());
    // Sentinel = 'delayedStart'
    (aMsg)->WriteSentinel(1491822294);
    WriteIPDLParam(aMsg, aActor, (aVar).stream());
    // Sentinel = 'stream'
    (aMsg)->WriteSentinel(4152748422);
    (aMsg)->WriteBytes((&((aVar).length())), 8);
    // Sentinel = 'length'
    (aMsg)->WriteSentinel(1726618354);
}

auto IPDLParamTraits<mozilla::ipc::IPCRemoteStreamParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->delayedStart())))))) {
        aActor->FatalError("Error deserializing 'delayedStart' (bool) member of 'IPCRemoteStreamParams'");
        return false;
    }
    // Sentinel = 'delayedStart'
    if ((!((aMsg)->ReadSentinel(aIter, 1491822294)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'delayedStart' (bool) member of 'IPCRemoteStreamParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->stream())))))) {
        aActor->FatalError("Error deserializing 'stream' (IPCRemoteStreamType) member of 'IPCRemoteStreamParams'");
        return false;
    }
    // Sentinel = 'stream'
    if ((!((aMsg)->ReadSentinel(aIter, 4152748422)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'stream' (IPCRemoteStreamType) member of 'IPCRemoteStreamParams'");
        return false;
    }
    if ((!((aMsg)->ReadBytesInto(aIter, (&((aVar)->length())), 8)))) {
        aActor->FatalError("Error bulk reading fields from int64_t");
        return false;
    }
    // Sentinel = 'length'
    if ((!((aMsg)->ReadSentinel(aIter, 1726618354)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union InputStreamParams|
//
namespace mozilla {
namespace ipc {
auto InputStreamParams::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TStringInputStreamParams:
        {
            (ptr_StringInputStreamParams())->~StringInputStreamParams__tdef();
            break;
        }
    case TFileInputStreamParams:
        {
            (ptr_FileInputStreamParams())->~FileInputStreamParams__tdef();
            break;
        }
    case TBufferedInputStreamParams:
        {
            delete ptr_BufferedInputStreamParams();
            break;
        }
    case TMIMEInputStreamParams:
        {
            delete ptr_MIMEInputStreamParams();
            break;
        }
    case TMultiplexInputStreamParams:
        {
            delete ptr_MultiplexInputStreamParams();
            break;
        }
    case TSlicedInputStreamParams:
        {
            delete ptr_SlicedInputStreamParams();
            break;
        }
    case TIPCBlobInputStreamParams:
        {
            (ptr_IPCBlobInputStreamParams())->~IPCBlobInputStreamParams__tdef();
            break;
        }
    case TInputStreamLengthWrapperParams:
        {
            delete ptr_InputStreamLengthWrapperParams();
            break;
        }
    case TIPCRemoteStreamParams:
        {
            (ptr_IPCRemoteStreamParams())->~IPCRemoteStreamParams__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(const StringInputStreamParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_StringInputStreamParams()) StringInputStreamParams(aOther);
    mType = TStringInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(StringInputStreamParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StringInputStreamParams()) StringInputStreamParams(std::move(aOther));
    mType = TStringInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(const FileInputStreamParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileInputStreamParams()) FileInputStreamParams(aOther);
    mType = TFileInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(FileInputStreamParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileInputStreamParams()) FileInputStreamParams(std::move(aOther));
    mType = TFileInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(const BufferedInputStreamParams& aOther)
{
    ptr_BufferedInputStreamParams() = new BufferedInputStreamParams(aOther);
    mType = TBufferedInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(BufferedInputStreamParams&& aOther)
{
    ptr_BufferedInputStreamParams() = new BufferedInputStreamParams(std::move(aOther));
    mType = TBufferedInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(const MIMEInputStreamParams& aOther)
{
    ptr_MIMEInputStreamParams() = new MIMEInputStreamParams(aOther);
    mType = TMIMEInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(MIMEInputStreamParams&& aOther)
{
    ptr_MIMEInputStreamParams() = new MIMEInputStreamParams(std::move(aOther));
    mType = TMIMEInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(const MultiplexInputStreamParams& aOther)
{
    ptr_MultiplexInputStreamParams() = new MultiplexInputStreamParams(aOther);
    mType = TMultiplexInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(MultiplexInputStreamParams&& aOther)
{
    ptr_MultiplexInputStreamParams() = new MultiplexInputStreamParams(std::move(aOther));
    mType = TMultiplexInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(const SlicedInputStreamParams& aOther)
{
    ptr_SlicedInputStreamParams() = new SlicedInputStreamParams(aOther);
    mType = TSlicedInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(SlicedInputStreamParams&& aOther)
{
    ptr_SlicedInputStreamParams() = new SlicedInputStreamParams(std::move(aOther));
    mType = TSlicedInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(const IPCBlobInputStreamParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCBlobInputStreamParams()) IPCBlobInputStreamParams(aOther);
    mType = TIPCBlobInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(IPCBlobInputStreamParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCBlobInputStreamParams()) IPCBlobInputStreamParams(std::move(aOther));
    mType = TIPCBlobInputStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(const InputStreamLengthWrapperParams& aOther)
{
    ptr_InputStreamLengthWrapperParams() = new InputStreamLengthWrapperParams(aOther);
    mType = TInputStreamLengthWrapperParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(InputStreamLengthWrapperParams&& aOther)
{
    ptr_InputStreamLengthWrapperParams() = new InputStreamLengthWrapperParams(std::move(aOther));
    mType = TInputStreamLengthWrapperParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(const IPCRemoteStreamParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCRemoteStreamParams()) IPCRemoteStreamParams(aOther);
    mType = TIPCRemoteStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(IPCRemoteStreamParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCRemoteStreamParams()) IPCRemoteStreamParams(std::move(aOther));
    mType = TIPCRemoteStreamParams;
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(const InputStreamParams& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TStringInputStreamParams:
        {
            new (mozilla::KnownNotNull, ptr_StringInputStreamParams()) StringInputStreamParams((aOther).get_StringInputStreamParams());
            break;
        }
    case TFileInputStreamParams:
        {
            new (mozilla::KnownNotNull, ptr_FileInputStreamParams()) FileInputStreamParams((aOther).get_FileInputStreamParams());
            break;
        }
    case TBufferedInputStreamParams:
        {
            ptr_BufferedInputStreamParams() = new BufferedInputStreamParams((aOther).get_BufferedInputStreamParams());
            break;
        }
    case TMIMEInputStreamParams:
        {
            ptr_MIMEInputStreamParams() = new MIMEInputStreamParams((aOther).get_MIMEInputStreamParams());
            break;
        }
    case TMultiplexInputStreamParams:
        {
            ptr_MultiplexInputStreamParams() = new MultiplexInputStreamParams((aOther).get_MultiplexInputStreamParams());
            break;
        }
    case TSlicedInputStreamParams:
        {
            ptr_SlicedInputStreamParams() = new SlicedInputStreamParams((aOther).get_SlicedInputStreamParams());
            break;
        }
    case TIPCBlobInputStreamParams:
        {
            new (mozilla::KnownNotNull, ptr_IPCBlobInputStreamParams()) IPCBlobInputStreamParams((aOther).get_IPCBlobInputStreamParams());
            break;
        }
    case TInputStreamLengthWrapperParams:
        {
            ptr_InputStreamLengthWrapperParams() = new InputStreamLengthWrapperParams((aOther).get_InputStreamLengthWrapperParams());
            break;
        }
    case TIPCRemoteStreamParams:
        {
            new (mozilla::KnownNotNull, ptr_IPCRemoteStreamParams()) IPCRemoteStreamParams((aOther).get_IPCRemoteStreamParams());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT InputStreamParams::InputStreamParams(InputStreamParams&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TStringInputStreamParams:
        {
            new (mozilla::KnownNotNull, ptr_StringInputStreamParams()) StringInputStreamParams(std::move((aOther).get_StringInputStreamParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileInputStreamParams:
        {
            new (mozilla::KnownNotNull, ptr_FileInputStreamParams()) FileInputStreamParams(std::move((aOther).get_FileInputStreamParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TBufferedInputStreamParams:
        {
            ptr_BufferedInputStreamParams() = (aOther).ptr_BufferedInputStreamParams();
            break;
        }
    case TMIMEInputStreamParams:
        {
            ptr_MIMEInputStreamParams() = (aOther).ptr_MIMEInputStreamParams();
            break;
        }
    case TMultiplexInputStreamParams:
        {
            ptr_MultiplexInputStreamParams() = (aOther).ptr_MultiplexInputStreamParams();
            break;
        }
    case TSlicedInputStreamParams:
        {
            ptr_SlicedInputStreamParams() = (aOther).ptr_SlicedInputStreamParams();
            break;
        }
    case TIPCBlobInputStreamParams:
        {
            new (mozilla::KnownNotNull, ptr_IPCBlobInputStreamParams()) IPCBlobInputStreamParams(std::move((aOther).get_IPCBlobInputStreamParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TInputStreamLengthWrapperParams:
        {
            ptr_InputStreamLengthWrapperParams() = (aOther).ptr_InputStreamLengthWrapperParams();
            break;
        }
    case TIPCRemoteStreamParams:
        {
            new (mozilla::KnownNotNull, ptr_IPCRemoteStreamParams()) IPCRemoteStreamParams(std::move((aOther).get_IPCRemoteStreamParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

InputStreamParams::~InputStreamParams()
{
    static_cast<void>(MaybeDestroy(T__None));
}

auto InputStreamParams::operator=(const StringInputStreamParams& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TStringInputStreamParams)) {
        new (mozilla::KnownNotNull, ptr_StringInputStreamParams()) StringInputStreamParams;
    }
    (*(ptr_StringInputStreamParams())) = aRhs;
    mType = TStringInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(StringInputStreamParams&& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TStringInputStreamParams)) {
        new (mozilla::KnownNotNull, ptr_StringInputStreamParams()) StringInputStreamParams;
    }
    (*(ptr_StringInputStreamParams())) = std::move(aRhs);
    mType = TStringInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(const FileInputStreamParams& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TFileInputStreamParams)) {
        new (mozilla::KnownNotNull, ptr_FileInputStreamParams()) FileInputStreamParams;
    }
    (*(ptr_FileInputStreamParams())) = aRhs;
    mType = TFileInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(FileInputStreamParams&& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TFileInputStreamParams)) {
        new (mozilla::KnownNotNull, ptr_FileInputStreamParams()) FileInputStreamParams;
    }
    (*(ptr_FileInputStreamParams())) = std::move(aRhs);
    mType = TFileInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(const BufferedInputStreamParams& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TBufferedInputStreamParams)) {
        ptr_BufferedInputStreamParams() = new BufferedInputStreamParams;
    }
    (*(ptr_BufferedInputStreamParams())) = aRhs;
    mType = TBufferedInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(BufferedInputStreamParams&& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TBufferedInputStreamParams)) {
        ptr_BufferedInputStreamParams() = new BufferedInputStreamParams;
    }
    (*(ptr_BufferedInputStreamParams())) = std::move(aRhs);
    mType = TBufferedInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(const MIMEInputStreamParams& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TMIMEInputStreamParams)) {
        ptr_MIMEInputStreamParams() = new MIMEInputStreamParams;
    }
    (*(ptr_MIMEInputStreamParams())) = aRhs;
    mType = TMIMEInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(MIMEInputStreamParams&& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TMIMEInputStreamParams)) {
        ptr_MIMEInputStreamParams() = new MIMEInputStreamParams;
    }
    (*(ptr_MIMEInputStreamParams())) = std::move(aRhs);
    mType = TMIMEInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(const MultiplexInputStreamParams& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TMultiplexInputStreamParams)) {
        ptr_MultiplexInputStreamParams() = new MultiplexInputStreamParams;
    }
    (*(ptr_MultiplexInputStreamParams())) = aRhs;
    mType = TMultiplexInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(MultiplexInputStreamParams&& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TMultiplexInputStreamParams)) {
        ptr_MultiplexInputStreamParams() = new MultiplexInputStreamParams;
    }
    (*(ptr_MultiplexInputStreamParams())) = std::move(aRhs);
    mType = TMultiplexInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(const SlicedInputStreamParams& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TSlicedInputStreamParams)) {
        ptr_SlicedInputStreamParams() = new SlicedInputStreamParams;
    }
    (*(ptr_SlicedInputStreamParams())) = aRhs;
    mType = TSlicedInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(SlicedInputStreamParams&& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TSlicedInputStreamParams)) {
        ptr_SlicedInputStreamParams() = new SlicedInputStreamParams;
    }
    (*(ptr_SlicedInputStreamParams())) = std::move(aRhs);
    mType = TSlicedInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(const IPCBlobInputStreamParams& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TIPCBlobInputStreamParams)) {
        new (mozilla::KnownNotNull, ptr_IPCBlobInputStreamParams()) IPCBlobInputStreamParams;
    }
    (*(ptr_IPCBlobInputStreamParams())) = aRhs;
    mType = TIPCBlobInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(IPCBlobInputStreamParams&& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TIPCBlobInputStreamParams)) {
        new (mozilla::KnownNotNull, ptr_IPCBlobInputStreamParams()) IPCBlobInputStreamParams;
    }
    (*(ptr_IPCBlobInputStreamParams())) = std::move(aRhs);
    mType = TIPCBlobInputStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(const InputStreamLengthWrapperParams& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TInputStreamLengthWrapperParams)) {
        ptr_InputStreamLengthWrapperParams() = new InputStreamLengthWrapperParams;
    }
    (*(ptr_InputStreamLengthWrapperParams())) = aRhs;
    mType = TInputStreamLengthWrapperParams;
    return (*(this));
}

auto InputStreamParams::operator=(InputStreamLengthWrapperParams&& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TInputStreamLengthWrapperParams)) {
        ptr_InputStreamLengthWrapperParams() = new InputStreamLengthWrapperParams;
    }
    (*(ptr_InputStreamLengthWrapperParams())) = std::move(aRhs);
    mType = TInputStreamLengthWrapperParams;
    return (*(this));
}

auto InputStreamParams::operator=(const IPCRemoteStreamParams& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TIPCRemoteStreamParams)) {
        new (mozilla::KnownNotNull, ptr_IPCRemoteStreamParams()) IPCRemoteStreamParams;
    }
    (*(ptr_IPCRemoteStreamParams())) = aRhs;
    mType = TIPCRemoteStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(IPCRemoteStreamParams&& aRhs) -> InputStreamParams&
{
    if (MaybeDestroy(TIPCRemoteStreamParams)) {
        new (mozilla::KnownNotNull, ptr_IPCRemoteStreamParams()) IPCRemoteStreamParams;
    }
    (*(ptr_IPCRemoteStreamParams())) = std::move(aRhs);
    mType = TIPCRemoteStreamParams;
    return (*(this));
}

auto InputStreamParams::operator=(const InputStreamParams& aRhs) -> InputStreamParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TStringInputStreamParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_StringInputStreamParams()) StringInputStreamParams;
            }
            (*(ptr_StringInputStreamParams())) = (aRhs).get_StringInputStreamParams();
            break;
        }
    case TFileInputStreamParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileInputStreamParams()) FileInputStreamParams;
            }
            (*(ptr_FileInputStreamParams())) = (aRhs).get_FileInputStreamParams();
            break;
        }
    case TBufferedInputStreamParams:
        {
            if (MaybeDestroy(t)) {
                ptr_BufferedInputStreamParams() = new BufferedInputStreamParams;
            }
            (*(ptr_BufferedInputStreamParams())) = (aRhs).get_BufferedInputStreamParams();
            break;
        }
    case TMIMEInputStreamParams:
        {
            if (MaybeDestroy(t)) {
                ptr_MIMEInputStreamParams() = new MIMEInputStreamParams;
            }
            (*(ptr_MIMEInputStreamParams())) = (aRhs).get_MIMEInputStreamParams();
            break;
        }
    case TMultiplexInputStreamParams:
        {
            if (MaybeDestroy(t)) {
                ptr_MultiplexInputStreamParams() = new MultiplexInputStreamParams;
            }
            (*(ptr_MultiplexInputStreamParams())) = (aRhs).get_MultiplexInputStreamParams();
            break;
        }
    case TSlicedInputStreamParams:
        {
            if (MaybeDestroy(t)) {
                ptr_SlicedInputStreamParams() = new SlicedInputStreamParams;
            }
            (*(ptr_SlicedInputStreamParams())) = (aRhs).get_SlicedInputStreamParams();
            break;
        }
    case TIPCBlobInputStreamParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IPCBlobInputStreamParams()) IPCBlobInputStreamParams;
            }
            (*(ptr_IPCBlobInputStreamParams())) = (aRhs).get_IPCBlobInputStreamParams();
            break;
        }
    case TInputStreamLengthWrapperParams:
        {
            if (MaybeDestroy(t)) {
                ptr_InputStreamLengthWrapperParams() = new InputStreamLengthWrapperParams;
            }
            (*(ptr_InputStreamLengthWrapperParams())) = (aRhs).get_InputStreamLengthWrapperParams();
            break;
        }
    case TIPCRemoteStreamParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IPCRemoteStreamParams()) IPCRemoteStreamParams;
            }
            (*(ptr_IPCRemoteStreamParams())) = (aRhs).get_IPCRemoteStreamParams();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto InputStreamParams::operator=(InputStreamParams&& aRhs) -> InputStreamParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TStringInputStreamParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_StringInputStreamParams()) StringInputStreamParams;
            }
            (*(ptr_StringInputStreamParams())) = std::move((aRhs).get_StringInputStreamParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileInputStreamParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileInputStreamParams()) FileInputStreamParams;
            }
            (*(ptr_FileInputStreamParams())) = std::move((aRhs).get_FileInputStreamParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TBufferedInputStreamParams:
        {
            static_cast<void>(MaybeDestroy(T__None));
            ptr_BufferedInputStreamParams() = (aRhs).ptr_BufferedInputStreamParams();
            break;
        }
    case TMIMEInputStreamParams:
        {
            static_cast<void>(MaybeDestroy(T__None));
            ptr_MIMEInputStreamParams() = (aRhs).ptr_MIMEInputStreamParams();
            break;
        }
    case TMultiplexInputStreamParams:
        {
            static_cast<void>(MaybeDestroy(T__None));
            ptr_MultiplexInputStreamParams() = (aRhs).ptr_MultiplexInputStreamParams();
            break;
        }
    case TSlicedInputStreamParams:
        {
            static_cast<void>(MaybeDestroy(T__None));
            ptr_SlicedInputStreamParams() = (aRhs).ptr_SlicedInputStreamParams();
            break;
        }
    case TIPCBlobInputStreamParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IPCBlobInputStreamParams()) IPCBlobInputStreamParams;
            }
            (*(ptr_IPCBlobInputStreamParams())) = std::move((aRhs).get_IPCBlobInputStreamParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TInputStreamLengthWrapperParams:
        {
            static_cast<void>(MaybeDestroy(T__None));
            ptr_InputStreamLengthWrapperParams() = (aRhs).ptr_InputStreamLengthWrapperParams();
            break;
        }
    case TIPCRemoteStreamParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IPCRemoteStreamParams()) IPCRemoteStreamParams;
            }
            (*(ptr_IPCRemoteStreamParams())) = std::move((aRhs).get_IPCRemoteStreamParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto InputStreamParams::operator==(const StringInputStreamParams& aRhs) const -> bool
{
    return (get_StringInputStreamParams()) == (aRhs);
}

auto InputStreamParams::operator==(const FileInputStreamParams& aRhs) const -> bool
{
    return (get_FileInputStreamParams()) == (aRhs);
}

auto InputStreamParams::operator==(const BufferedInputStreamParams& aRhs) const -> bool
{
    return (get_BufferedInputStreamParams()) == (aRhs);
}

auto InputStreamParams::operator==(const MIMEInputStreamParams& aRhs) const -> bool
{
    return (get_MIMEInputStreamParams()) == (aRhs);
}

auto InputStreamParams::operator==(const MultiplexInputStreamParams& aRhs) const -> bool
{
    return (get_MultiplexInputStreamParams()) == (aRhs);
}

auto InputStreamParams::operator==(const SlicedInputStreamParams& aRhs) const -> bool
{
    return (get_SlicedInputStreamParams()) == (aRhs);
}

auto InputStreamParams::operator==(const IPCBlobInputStreamParams& aRhs) const -> bool
{
    return (get_IPCBlobInputStreamParams()) == (aRhs);
}

auto InputStreamParams::operator==(const InputStreamLengthWrapperParams& aRhs) const -> bool
{
    return (get_InputStreamLengthWrapperParams()) == (aRhs);
}

auto InputStreamParams::operator==(const IPCRemoteStreamParams& aRhs) const -> bool
{
    return (get_IPCRemoteStreamParams()) == (aRhs);
}

auto InputStreamParams::operator==(const InputStreamParams& aRhs) const -> bool
{
    if ((type()) != ((aRhs).type())) {
        return false;
    }

    switch (type()) {
    case TStringInputStreamParams:
        {
            return (get_StringInputStreamParams()) == ((aRhs).get_StringInputStreamParams());
        }
    case TFileInputStreamParams:
        {
            return (get_FileInputStreamParams()) == ((aRhs).get_FileInputStreamParams());
        }
    case TBufferedInputStreamParams:
        {
            return (get_BufferedInputStreamParams()) == ((aRhs).get_BufferedInputStreamParams());
        }
    case TMIMEInputStreamParams:
        {
            return (get_MIMEInputStreamParams()) == ((aRhs).get_MIMEInputStreamParams());
        }
    case TMultiplexInputStreamParams:
        {
            return (get_MultiplexInputStreamParams()) == ((aRhs).get_MultiplexInputStreamParams());
        }
    case TSlicedInputStreamParams:
        {
            return (get_SlicedInputStreamParams()) == ((aRhs).get_SlicedInputStreamParams());
        }
    case TIPCBlobInputStreamParams:
        {
            return (get_IPCBlobInputStreamParams()) == ((aRhs).get_IPCBlobInputStreamParams());
        }
    case TInputStreamLengthWrapperParams:
        {
            return (get_InputStreamLengthWrapperParams()) == ((aRhs).get_InputStreamLengthWrapperParams());
        }
    case TIPCRemoteStreamParams:
        {
            return (get_IPCRemoteStreamParams()) == ((aRhs).get_IPCRemoteStreamParams());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto InputStreamParams::get(StringInputStreamParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_StringInputStreamParams();
}

auto InputStreamParams::get(FileInputStreamParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileInputStreamParams();
}

auto InputStreamParams::get(BufferedInputStreamParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_BufferedInputStreamParams();
}

auto InputStreamParams::get(MIMEInputStreamParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_MIMEInputStreamParams();
}

auto InputStreamParams::get(MultiplexInputStreamParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_MultiplexInputStreamParams();
}

auto InputStreamParams::get(SlicedInputStreamParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_SlicedInputStreamParams();
}

auto InputStreamParams::get(IPCBlobInputStreamParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_IPCBlobInputStreamParams();
}

auto InputStreamParams::get(InputStreamLengthWrapperParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_InputStreamLengthWrapperParams();
}

auto InputStreamParams::get(IPCRemoteStreamParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_IPCRemoteStreamParams();
}

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::InputStreamParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    typedef mozilla::ipc::InputStreamParams union__;
    int type;
    type = (aVar).type();
    WriteIPDLParam(aMsg, aActor, type);
    // Sentinel = 'InputStreamParams'
    (aMsg)->WriteSentinel(4114814015);

    switch (type) {
    case union__::TStringInputStreamParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_StringInputStreamParams());
            // Sentinel = 'TStringInputStreamParams'
            (aMsg)->WriteSentinel(3395831651);
            return;
        }
    case union__::TFileInputStreamParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileInputStreamParams());
            // Sentinel = 'TFileInputStreamParams'
            (aMsg)->WriteSentinel(2543620282);
            return;
        }
    case union__::TBufferedInputStreamParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_BufferedInputStreamParams());
            // Sentinel = 'TBufferedInputStreamParams'
            (aMsg)->WriteSentinel(1698289307);
            return;
        }
    case union__::TMIMEInputStreamParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_MIMEInputStreamParams());
            // Sentinel = 'TMIMEInputStreamParams'
            (aMsg)->WriteSentinel(1948001964);
            return;
        }
    case union__::TMultiplexInputStreamParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_MultiplexInputStreamParams());
            // Sentinel = 'TMultiplexInputStreamParams'
            (aMsg)->WriteSentinel(3317853213);
            return;
        }
    case union__::TSlicedInputStreamParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SlicedInputStreamParams());
            // Sentinel = 'TSlicedInputStreamParams'
            (aMsg)->WriteSentinel(445810472);
            return;
        }
    case union__::TIPCBlobInputStreamParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_IPCBlobInputStreamParams());
            // Sentinel = 'TIPCBlobInputStreamParams'
            (aMsg)->WriteSentinel(2436989998);
            return;
        }
    case union__::TInputStreamLengthWrapperParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_InputStreamLengthWrapperParams());
            // Sentinel = 'TInputStreamLengthWrapperParams'
            (aMsg)->WriteSentinel(332208640);
            return;
        }
    case union__::TIPCRemoteStreamParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_IPCRemoteStreamParams());
            // Sentinel = 'TIPCRemoteStreamParams'
            (aMsg)->WriteSentinel(2698834612);
            return;
        }
    default:
        {
            aActor->FatalError("unknown union type");
            return;
        }
    }
}

auto IPDLParamTraits<mozilla::ipc::InputStreamParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    typedef mozilla::ipc::InputStreamParams union__;
    int type;
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&(type)))))) {
        aActor->FatalError("Error deserializing type of union InputStreamParams");
        return false;
    }
    // Sentinel = 'InputStreamParams'
    if ((!((aMsg)->ReadSentinel(aIter, 4114814015)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union InputStreamParams");
        return false;
    }

    switch (type) {
    case union__::TStringInputStreamParams:
        {
            mozilla::ipc::StringInputStreamParams tmp = mozilla::ipc::StringInputStreamParams();
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_StringInputStreamParams())))))) {
                aActor->FatalError("Error deserializing variant TStringInputStreamParams of union InputStreamParams");
                return false;
            }
            // Sentinel = 'TStringInputStreamParams'
            if ((!((aMsg)->ReadSentinel(aIter, 3395831651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStringInputStreamParams of union InputStreamParams");
                return false;
            }
            return true;
        }
    case union__::TFileInputStreamParams:
        {
            mozilla::ipc::FileInputStreamParams tmp = mozilla::ipc::FileInputStreamParams();
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileInputStreamParams())))))) {
                aActor->FatalError("Error deserializing variant TFileInputStreamParams of union InputStreamParams");
                return false;
            }
            // Sentinel = 'TFileInputStreamParams'
            if ((!((aMsg)->ReadSentinel(aIter, 2543620282)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileInputStreamParams of union InputStreamParams");
                return false;
            }
            return true;
        }
    case union__::TBufferedInputStreamParams:
        {
            mozilla::ipc::BufferedInputStreamParams tmp = mozilla::ipc::BufferedInputStreamParams();
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_BufferedInputStreamParams())))))) {
                aActor->FatalError("Error deserializing variant TBufferedInputStreamParams of union InputStreamParams");
                return false;
            }
            // Sentinel = 'TBufferedInputStreamParams'
            if ((!((aMsg)->ReadSentinel(aIter, 1698289307)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TBufferedInputStreamParams of union InputStreamParams");
                return false;
            }
            return true;
        }
    case union__::TMIMEInputStreamParams:
        {
            mozilla::ipc::MIMEInputStreamParams tmp = mozilla::ipc::MIMEInputStreamParams();
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_MIMEInputStreamParams())))))) {
                aActor->FatalError("Error deserializing variant TMIMEInputStreamParams of union InputStreamParams");
                return false;
            }
            // Sentinel = 'TMIMEInputStreamParams'
            if ((!((aMsg)->ReadSentinel(aIter, 1948001964)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TMIMEInputStreamParams of union InputStreamParams");
                return false;
            }
            return true;
        }
    case union__::TMultiplexInputStreamParams:
        {
            mozilla::ipc::MultiplexInputStreamParams tmp = mozilla::ipc::MultiplexInputStreamParams();
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_MultiplexInputStreamParams())))))) {
                aActor->FatalError("Error deserializing variant TMultiplexInputStreamParams of union InputStreamParams");
                return false;
            }
            // Sentinel = 'TMultiplexInputStreamParams'
            if ((!((aMsg)->ReadSentinel(aIter, 3317853213)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TMultiplexInputStreamParams of union InputStreamParams");
                return false;
            }
            return true;
        }
    case union__::TSlicedInputStreamParams:
        {
            mozilla::ipc::SlicedInputStreamParams tmp = mozilla::ipc::SlicedInputStreamParams();
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SlicedInputStreamParams())))))) {
                aActor->FatalError("Error deserializing variant TSlicedInputStreamParams of union InputStreamParams");
                return false;
            }
            // Sentinel = 'TSlicedInputStreamParams'
            if ((!((aMsg)->ReadSentinel(aIter, 445810472)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSlicedInputStreamParams of union InputStreamParams");
                return false;
            }
            return true;
        }
    case union__::TIPCBlobInputStreamParams:
        {
            mozilla::ipc::IPCBlobInputStreamParams tmp = mozilla::ipc::IPCBlobInputStreamParams();
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_IPCBlobInputStreamParams())))))) {
                aActor->FatalError("Error deserializing variant TIPCBlobInputStreamParams of union InputStreamParams");
                return false;
            }
            // Sentinel = 'TIPCBlobInputStreamParams'
            if ((!((aMsg)->ReadSentinel(aIter, 2436989998)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCBlobInputStreamParams of union InputStreamParams");
                return false;
            }
            return true;
        }
    case union__::TInputStreamLengthWrapperParams:
        {
            mozilla::ipc::InputStreamLengthWrapperParams tmp = mozilla::ipc::InputStreamLengthWrapperParams();
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_InputStreamLengthWrapperParams())))))) {
                aActor->FatalError("Error deserializing variant TInputStreamLengthWrapperParams of union InputStreamParams");
                return false;
            }
            // Sentinel = 'TInputStreamLengthWrapperParams'
            if ((!((aMsg)->ReadSentinel(aIter, 332208640)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TInputStreamLengthWrapperParams of union InputStreamParams");
                return false;
            }
            return true;
        }
    case union__::TIPCRemoteStreamParams:
        {
            mozilla::ipc::IPCRemoteStreamParams tmp = mozilla::ipc::IPCRemoteStreamParams();
            (*(aVar)) = std::move(tmp);
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_IPCRemoteStreamParams())))))) {
                aActor->FatalError("Error deserializing variant TIPCRemoteStreamParams of union InputStreamParams");
                return false;
            }
            // Sentinel = 'TIPCRemoteStreamParams'
            if ((!((aMsg)->ReadSentinel(aIter, 2698834612)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCRemoteStreamParams of union InputStreamParams");
                return false;
            }
            return true;
        }
    default:
        {
            aActor->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct BufferedInputStreamParams|
//
namespace mozilla {
namespace ipc {
auto BufferedInputStreamParams::operator==(const BufferedInputStreamParams& _o) const -> bool
{
    if ((!((optionalStream()) == ((_o).optionalStream())))) {
        return false;
    }
    if ((!((bufferSize()) == ((_o).bufferSize())))) {
        return false;
    }
    return true;
}

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::BufferedInputStreamParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).optionalStream());
    // Sentinel = 'optionalStream'
    (aMsg)->WriteSentinel(1003718562);
    (aMsg)->WriteBytes((&((aVar).bufferSize())), 4);
    // Sentinel = 'bufferSize'
    (aMsg)->WriteSentinel(3444538779);
}

auto IPDLParamTraits<mozilla::ipc::BufferedInputStreamParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->optionalStream())))))) {
        aActor->FatalError("Error deserializing 'optionalStream' (InputStreamParams?) member of 'BufferedInputStreamParams'");
        return false;
    }
    // Sentinel = 'optionalStream'
    if ((!((aMsg)->ReadSentinel(aIter, 1003718562)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'optionalStream' (InputStreamParams?) member of 'BufferedInputStreamParams'");
        return false;
    }
    if ((!((aMsg)->ReadBytesInto(aIter, (&((aVar)->bufferSize())), 4)))) {
        aActor->FatalError("Error bulk reading fields from uint32_t");
        return false;
    }
    // Sentinel = 'bufferSize'
    if ((!((aMsg)->ReadSentinel(aIter, 3444538779)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct MIMEInputStreamParams|
//
namespace mozilla {
namespace ipc {
auto MIMEInputStreamParams::operator==(const MIMEInputStreamParams& _o) const -> bool
{
    if ((!((optionalStream()) == ((_o).optionalStream())))) {
        return false;
    }
    if ((!((headers()) == ((_o).headers())))) {
        return false;
    }
    if ((!((startedReading()) == ((_o).startedReading())))) {
        return false;
    }
    return true;
}

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::MIMEInputStreamParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).optionalStream());
    // Sentinel = 'optionalStream'
    (aMsg)->WriteSentinel(1003718562);
    WriteIPDLParam(aMsg, aActor, (aVar).headers());
    // Sentinel = 'headers'
    (aMsg)->WriteSentinel(4284175217);
    WriteIPDLParam(aMsg, aActor, (aVar).startedReading());
    // Sentinel = 'startedReading'
    (aMsg)->WriteSentinel(1906875903);
}

auto IPDLParamTraits<mozilla::ipc::MIMEInputStreamParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->optionalStream())))))) {
        aActor->FatalError("Error deserializing 'optionalStream' (InputStreamParams?) member of 'MIMEInputStreamParams'");
        return false;
    }
    // Sentinel = 'optionalStream'
    if ((!((aMsg)->ReadSentinel(aIter, 1003718562)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'optionalStream' (InputStreamParams?) member of 'MIMEInputStreamParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->headers())))))) {
        aActor->FatalError("Error deserializing 'headers' (HeaderEntry[]) member of 'MIMEInputStreamParams'");
        return false;
    }
    // Sentinel = 'headers'
    if ((!((aMsg)->ReadSentinel(aIter, 4284175217)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'headers' (HeaderEntry[]) member of 'MIMEInputStreamParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->startedReading())))))) {
        aActor->FatalError("Error deserializing 'startedReading' (bool) member of 'MIMEInputStreamParams'");
        return false;
    }
    // Sentinel = 'startedReading'
    if ((!((aMsg)->ReadSentinel(aIter, 1906875903)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'startedReading' (bool) member of 'MIMEInputStreamParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct InputStreamLengthWrapperParams|
//
namespace mozilla {
namespace ipc {
auto InputStreamLengthWrapperParams::operator==(const InputStreamLengthWrapperParams& _o) const -> bool
{
    if ((!((stream()) == ((_o).stream())))) {
        return false;
    }
    if ((!((length()) == ((_o).length())))) {
        return false;
    }
    if ((!((consumed()) == ((_o).consumed())))) {
        return false;
    }
    return true;
}

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::InputStreamLengthWrapperParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).stream());
    // Sentinel = 'stream'
    (aMsg)->WriteSentinel(4152748422);
    WriteIPDLParam(aMsg, aActor, (aVar).consumed());
    // Sentinel = 'consumed'
    (aMsg)->WriteSentinel(722813930);
    (aMsg)->WriteBytes((&((aVar).length())), 8);
    // Sentinel = 'length'
    (aMsg)->WriteSentinel(1726618354);
}

auto IPDLParamTraits<mozilla::ipc::InputStreamLengthWrapperParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->stream())))))) {
        aActor->FatalError("Error deserializing 'stream' (InputStreamParams) member of 'InputStreamLengthWrapperParams'");
        return false;
    }
    // Sentinel = 'stream'
    if ((!((aMsg)->ReadSentinel(aIter, 4152748422)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'stream' (InputStreamParams) member of 'InputStreamLengthWrapperParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->consumed())))))) {
        aActor->FatalError("Error deserializing 'consumed' (bool) member of 'InputStreamLengthWrapperParams'");
        return false;
    }
    // Sentinel = 'consumed'
    if ((!((aMsg)->ReadSentinel(aIter, 722813930)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'consumed' (bool) member of 'InputStreamLengthWrapperParams'");
        return false;
    }
    if ((!((aMsg)->ReadBytesInto(aIter, (&((aVar)->length())), 8)))) {
        aActor->FatalError("Error bulk reading fields from int64_t");
        return false;
    }
    // Sentinel = 'length'
    if ((!((aMsg)->ReadSentinel(aIter, 1726618354)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla