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


#include "mozilla/dom/PBackgroundFileHandle.h"

namespace mozilla {
namespace dom {
namespace PBackgroundFileHandle {

nsresult
CreateEndpoints(
        base::ProcessId aParentDestPid,
        base::ProcessId aChildDestPid,
        mozilla::ipc::Endpoint<mozilla::dom::PBackgroundFileHandleParent>* aParent,
        mozilla::ipc::Endpoint<mozilla::dom::PBackgroundFileHandleChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(mozilla::ipc::PrivateIPDLInterface(), aParentDestPid, aChildDestPid, PBackgroundFileHandleMsgStart, PBackgroundFileHandleMsgStartChild, aParent, aChild);
}
bool
Transition(
        mozilla::ipc::Trigger trigger,
        State* next)
{
    State from = (*(next));
    switch (from) {
    case __Null:
    case __Error:
        if ((Msg___delete____ID) == ((trigger).mMessage)) {
            (*(next)) = __Dead;
            return true;
        }
        return (__Null) == (from);
    case __Dead:
        mozilla::ipc::LogicError("__delete__()d actor");
        return false;
    case __Dying:
        mozilla::ipc::LogicError("__delete__()d (and unexpectedly dying) actor");
        return false;
    default:
        mozilla::ipc::LogicError("corrupted actor state");
        return false;
    }
}
IPC::Message*
Msg_DeleteMe(int32_t routingId)
{
    return new IPC::Message(routingId, Msg_DeleteMe__ID, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PBackgroundFileHandle::Msg_DeleteMe");
}
IPC::Message*
Msg_Finish(int32_t routingId)
{
    return new IPC::Message(routingId, Msg_Finish__ID, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PBackgroundFileHandle::Msg_Finish");
}
IPC::Message*
Msg_Abort(int32_t routingId)
{
    return new IPC::Message(routingId, Msg_Abort__ID, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PBackgroundFileHandle::Msg_Abort");
}
IPC::Message*
Msg_PBackgroundFileRequestConstructor(int32_t routingId)
{
    return new IPC::Message(routingId, Msg_PBackgroundFileRequestConstructor__ID, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PBackgroundFileHandle::Msg_PBackgroundFileRequestConstructor");
}
IPC::Message*
Reply_PBackgroundFileRequestConstructor(int32_t routingId)
{
    return new IPC::Message(routingId, Reply_PBackgroundFileRequestConstructor__ID, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PBackgroundFileHandle::Reply_PBackgroundFileRequestConstructor");
}
IPC::Message*
Msg___delete__(int32_t routingId)
{
    return new IPC::Message(routingId, Msg___delete____ID, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PBackgroundFileHandle::Msg___delete__");
}
IPC::Message*
Reply___delete__(int32_t routingId)
{
    return new IPC::Message(routingId, Reply___delete____ID, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PBackgroundFileHandle::Reply___delete__");
}
IPC::Message*
Msg_Complete(int32_t routingId)
{
    return new IPC::Message(routingId, Msg_Complete__ID, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PBackgroundFileHandle::Msg_Complete");
}

} // namespace PBackgroundFileHandle
} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileRequestGetMetadataParams|
//
namespace mozilla {
namespace dom {
MOZ_IMPLICIT FileRequestGetMetadataParams::FileRequestGetMetadataParams() :
    size_(),
    lastModified_()
{
    Init();
}

FileRequestGetMetadataParams::~FileRequestGetMetadataParams()
{
}

auto FileRequestGetMetadataParams::operator==(const FileRequestGetMetadataParams& _o) const -> bool
{
    if ((!((size()) == ((_o).size())))) {
        return false;
    }
    if ((!((lastModified()) == ((_o).lastModified())))) {
        return false;
    }
    return true;
}

auto FileRequestGetMetadataParams::Init() -> void
{
}

auto FileRequestGetMetadataParams::Assign(
        const bool& _size,
        const bool& _lastModified) -> void
{
    size_ = _size;
    lastModified_ = _lastModified;
}

} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileRequestReadParams|
//
namespace mozilla {
namespace dom {
MOZ_IMPLICIT FileRequestReadParams::FileRequestReadParams() :
    offset_(),
    size_()
{
    Init();
}

FileRequestReadParams::~FileRequestReadParams()
{
}

auto FileRequestReadParams::operator==(const FileRequestReadParams& _o) const -> bool
{
    if ((!((offset()) == ((_o).offset())))) {
        return false;
    }
    if ((!((size()) == ((_o).size())))) {
        return false;
    }
    return true;
}

auto FileRequestReadParams::Init() -> void
{
}

auto FileRequestReadParams::Assign(
        const uint64_t& _offset,
        const uint64_t& _size) -> void
{
    offset_ = _offset;
    size_ = _size;
}

} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileRequestStringData|
//
namespace mozilla {
namespace dom {
MOZ_IMPLICIT FileRequestStringData::FileRequestStringData() :
    string_()
{
    Init();
}

FileRequestStringData::~FileRequestStringData()
{
}

auto FileRequestStringData::operator==(const FileRequestStringData& _o) const -> bool
{
    if ((!((string()) == ((_o).string())))) {
        return false;
    }
    return true;
}

auto FileRequestStringData::Init() -> void
{
}

auto FileRequestStringData::Assign(const nsCString& _string) -> void
{
    string_ = _string;
}

} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileRequestBlobData|
//
namespace mozilla {
namespace dom {
MOZ_IMPLICIT FileRequestBlobData::FileRequestBlobData()
{
    Init();
}

FileRequestBlobData::~FileRequestBlobData()
{
}

auto FileRequestBlobData::operator==(const FileRequestBlobData& _o) const -> bool
{
    if ((!((blobParent()) == ((_o).blobParent())))) {
        return false;
    }
    if ((!((blobChild()) == ((_o).blobChild())))) {
        return false;
    }
    return true;
}

auto FileRequestBlobData::Init() -> void
{
    blobParent_ = nullptr;
    blobChild_ = nullptr;
}

auto FileRequestBlobData::Assign(
        PBlobParent* _blobParent,
        PBlobChild* _blobChild) -> void
{
    blobParent_ = _blobParent;
    blobChild_ = _blobChild;
}

} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileRequestData|
//
namespace mozilla {
namespace dom {
auto FileRequestData::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TFileRequestStringData:
        {
            (ptr_FileRequestStringData())->~FileRequestStringData__tdef();
            break;
        }
    case TFileRequestBlobData:
        {
            (ptr_FileRequestBlobData())->~FileRequestBlobData__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT FileRequestData::FileRequestData(const FileRequestStringData& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestStringData()) FileRequestStringData(aOther);
    mType = TFileRequestStringData;
}

MOZ_IMPLICIT FileRequestData::FileRequestData(const FileRequestBlobData& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestBlobData()) FileRequestBlobData(aOther);
    mType = TFileRequestBlobData;
}

MOZ_IMPLICIT FileRequestData::FileRequestData(const FileRequestData& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TFileRequestStringData:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestStringData()) FileRequestStringData((aOther).get_FileRequestStringData());
            break;
        }
    case TFileRequestBlobData:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestBlobData()) FileRequestBlobData((aOther).get_FileRequestBlobData());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

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

auto FileRequestData::operator=(const FileRequestStringData& aRhs) -> FileRequestData&
{
    if (MaybeDestroy(TFileRequestStringData)) {
        new (mozilla::KnownNotNull, ptr_FileRequestStringData()) FileRequestStringData;
    }
    (*(ptr_FileRequestStringData())) = aRhs;
    mType = TFileRequestStringData;
    return (*(this));
}

auto FileRequestData::operator=(const FileRequestBlobData& aRhs) -> FileRequestData&
{
    if (MaybeDestroy(TFileRequestBlobData)) {
        new (mozilla::KnownNotNull, ptr_FileRequestBlobData()) FileRequestBlobData;
    }
    (*(ptr_FileRequestBlobData())) = aRhs;
    mType = TFileRequestBlobData;
    return (*(this));
}

auto FileRequestData::operator=(const FileRequestData& aRhs) -> FileRequestData&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TFileRequestStringData:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestStringData()) FileRequestStringData;
            }
            (*(ptr_FileRequestStringData())) = (aRhs).get_FileRequestStringData();
            break;
        }
    case TFileRequestBlobData:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestBlobData()) FileRequestBlobData;
            }
            (*(ptr_FileRequestBlobData())) = (aRhs).get_FileRequestBlobData();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileRequestData::operator==(const FileRequestStringData& aRhs) const -> bool
{
    return (get_FileRequestStringData()) == (aRhs);
}

auto FileRequestData::operator==(const FileRequestBlobData& aRhs) const -> bool
{
    return (get_FileRequestBlobData()) == (aRhs);
}

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

    switch (type()) {
    case TFileRequestStringData:
        {
            return (get_FileRequestStringData()) == ((aRhs).get_FileRequestStringData());
        }
    case TFileRequestBlobData:
        {
            return (get_FileRequestBlobData()) == ((aRhs).get_FileRequestBlobData());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto FileRequestData::get(FileRequestStringData* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestStringData();
}

auto FileRequestData::get(FileRequestBlobData* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestBlobData();
}

} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileRequestWriteParams|
//
namespace mozilla {
namespace dom {
MOZ_IMPLICIT FileRequestWriteParams::FileRequestWriteParams() :
    offset_(),
    dataLength_()
{
    Init();
}

FileRequestWriteParams::~FileRequestWriteParams()
{
}

auto FileRequestWriteParams::operator==(const FileRequestWriteParams& _o) const -> bool
{
    if ((!((offset()) == ((_o).offset())))) {
        return false;
    }
    if ((!((data()) == ((_o).data())))) {
        return false;
    }
    if ((!((dataLength()) == ((_o).dataLength())))) {
        return false;
    }
    return true;
}

auto FileRequestWriteParams::Init() -> void
{
}

auto FileRequestWriteParams::Assign(
        const uint64_t& _offset,
        const FileRequestData& _data,
        const uint64_t& _dataLength) -> void
{
    offset_ = _offset;
    data_ = _data;
    dataLength_ = _dataLength;
}

} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileRequestTruncateParams|
//
namespace mozilla {
namespace dom {
MOZ_IMPLICIT FileRequestTruncateParams::FileRequestTruncateParams() :
    offset_()
{
    Init();
}

FileRequestTruncateParams::~FileRequestTruncateParams()
{
}

auto FileRequestTruncateParams::operator==(const FileRequestTruncateParams& _o) const -> bool
{
    if ((!((offset()) == ((_o).offset())))) {
        return false;
    }
    return true;
}

auto FileRequestTruncateParams::Init() -> void
{
}

auto FileRequestTruncateParams::Assign(const uint64_t& _offset) -> void
{
    offset_ = _offset;
}

} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileRequestFlushParams|
//
namespace mozilla {
namespace dom {
FileRequestFlushParams::~FileRequestFlushParams()
{
}

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

auto FileRequestFlushParams::Init() -> void
{
}

auto FileRequestFlushParams::Assign() -> void
{
}

} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileRequestGetFileParams|
//
namespace mozilla {
namespace dom {
FileRequestGetFileParams::~FileRequestGetFileParams()
{
}

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

auto FileRequestGetFileParams::Init() -> void
{
}

auto FileRequestGetFileParams::Assign() -> void
{
}

} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileRequestParams|
//
namespace mozilla {
namespace dom {
auto FileRequestParams::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TFileRequestGetMetadataParams:
        {
            (ptr_FileRequestGetMetadataParams())->~FileRequestGetMetadataParams__tdef();
            break;
        }
    case TFileRequestReadParams:
        {
            (ptr_FileRequestReadParams())->~FileRequestReadParams__tdef();
            break;
        }
    case TFileRequestWriteParams:
        {
            (ptr_FileRequestWriteParams())->~FileRequestWriteParams__tdef();
            break;
        }
    case TFileRequestTruncateParams:
        {
            (ptr_FileRequestTruncateParams())->~FileRequestTruncateParams__tdef();
            break;
        }
    case TFileRequestFlushParams:
        {
            (ptr_FileRequestFlushParams())->~FileRequestFlushParams__tdef();
            break;
        }
    case TFileRequestGetFileParams:
        {
            (ptr_FileRequestGetFileParams())->~FileRequestGetFileParams__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestGetMetadataParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataParams()) FileRequestGetMetadataParams(aOther);
    mType = TFileRequestGetMetadataParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestReadParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestReadParams()) FileRequestReadParams(aOther);
    mType = TFileRequestReadParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestWriteParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestWriteParams()) FileRequestWriteParams(aOther);
    mType = TFileRequestWriteParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestTruncateParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestTruncateParams()) FileRequestTruncateParams(aOther);
    mType = TFileRequestTruncateParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestFlushParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestFlushParams()) FileRequestFlushParams(aOther);
    mType = TFileRequestFlushParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestGetFileParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestGetFileParams()) FileRequestGetFileParams(aOther);
    mType = TFileRequestGetFileParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestParams& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TFileRequestGetMetadataParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataParams()) FileRequestGetMetadataParams((aOther).get_FileRequestGetMetadataParams());
            break;
        }
    case TFileRequestReadParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestReadParams()) FileRequestReadParams((aOther).get_FileRequestReadParams());
            break;
        }
    case TFileRequestWriteParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestWriteParams()) FileRequestWriteParams((aOther).get_FileRequestWriteParams());
            break;
        }
    case TFileRequestTruncateParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestTruncateParams()) FileRequestTruncateParams((aOther).get_FileRequestTruncateParams());
            break;
        }
    case TFileRequestFlushParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestFlushParams()) FileRequestFlushParams((aOther).get_FileRequestFlushParams());
            break;
        }
    case TFileRequestGetFileParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestGetFileParams()) FileRequestGetFileParams((aOther).get_FileRequestGetFileParams());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

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

auto FileRequestParams::operator=(const FileRequestGetMetadataParams& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestGetMetadataParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataParams()) FileRequestGetMetadataParams;
    }
    (*(ptr_FileRequestGetMetadataParams())) = aRhs;
    mType = TFileRequestGetMetadataParams;
    return (*(this));
}

auto FileRequestParams::operator=(const FileRequestReadParams& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestReadParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestReadParams()) FileRequestReadParams;
    }
    (*(ptr_FileRequestReadParams())) = aRhs;
    mType = TFileRequestReadParams;
    return (*(this));
}

auto FileRequestParams::operator=(const FileRequestWriteParams& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestWriteParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestWriteParams()) FileRequestWriteParams;
    }
    (*(ptr_FileRequestWriteParams())) = aRhs;
    mType = TFileRequestWriteParams;
    return (*(this));
}

auto FileRequestParams::operator=(const FileRequestTruncateParams& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestTruncateParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestTruncateParams()) FileRequestTruncateParams;
    }
    (*(ptr_FileRequestTruncateParams())) = aRhs;
    mType = TFileRequestTruncateParams;
    return (*(this));
}

auto FileRequestParams::operator=(const FileRequestFlushParams& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestFlushParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestFlushParams()) FileRequestFlushParams;
    }
    (*(ptr_FileRequestFlushParams())) = aRhs;
    mType = TFileRequestFlushParams;
    return (*(this));
}

auto FileRequestParams::operator=(const FileRequestGetFileParams& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestGetFileParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestGetFileParams()) FileRequestGetFileParams;
    }
    (*(ptr_FileRequestGetFileParams())) = aRhs;
    mType = TFileRequestGetFileParams;
    return (*(this));
}

auto FileRequestParams::operator=(const FileRequestParams& aRhs) -> FileRequestParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TFileRequestGetMetadataParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataParams()) FileRequestGetMetadataParams;
            }
            (*(ptr_FileRequestGetMetadataParams())) = (aRhs).get_FileRequestGetMetadataParams();
            break;
        }
    case TFileRequestReadParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestReadParams()) FileRequestReadParams;
            }
            (*(ptr_FileRequestReadParams())) = (aRhs).get_FileRequestReadParams();
            break;
        }
    case TFileRequestWriteParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestWriteParams()) FileRequestWriteParams;
            }
            (*(ptr_FileRequestWriteParams())) = (aRhs).get_FileRequestWriteParams();
            break;
        }
    case TFileRequestTruncateParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestTruncateParams()) FileRequestTruncateParams;
            }
            (*(ptr_FileRequestTruncateParams())) = (aRhs).get_FileRequestTruncateParams();
            break;
        }
    case TFileRequestFlushParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestFlushParams()) FileRequestFlushParams;
            }
            (*(ptr_FileRequestFlushParams())) = (aRhs).get_FileRequestFlushParams();
            break;
        }
    case TFileRequestGetFileParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestGetFileParams()) FileRequestGetFileParams;
            }
            (*(ptr_FileRequestGetFileParams())) = (aRhs).get_FileRequestGetFileParams();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileRequestParams::operator==(const FileRequestGetMetadataParams& aRhs) const -> bool
{
    return (get_FileRequestGetMetadataParams()) == (aRhs);
}

auto FileRequestParams::operator==(const FileRequestReadParams& aRhs) const -> bool
{
    return (get_FileRequestReadParams()) == (aRhs);
}

auto FileRequestParams::operator==(const FileRequestWriteParams& aRhs) const -> bool
{
    return (get_FileRequestWriteParams()) == (aRhs);
}

auto FileRequestParams::operator==(const FileRequestTruncateParams& aRhs) const -> bool
{
    return (get_FileRequestTruncateParams()) == (aRhs);
}

auto FileRequestParams::operator==(const FileRequestFlushParams& aRhs) const -> bool
{
    return (get_FileRequestFlushParams()) == (aRhs);
}

auto FileRequestParams::operator==(const FileRequestGetFileParams& aRhs) const -> bool
{
    return (get_FileRequestGetFileParams()) == (aRhs);
}

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

    switch (type()) {
    case TFileRequestGetMetadataParams:
        {
            return (get_FileRequestGetMetadataParams()) == ((aRhs).get_FileRequestGetMetadataParams());
        }
    case TFileRequestReadParams:
        {
            return (get_FileRequestReadParams()) == ((aRhs).get_FileRequestReadParams());
        }
    case TFileRequestWriteParams:
        {
            return (get_FileRequestWriteParams()) == ((aRhs).get_FileRequestWriteParams());
        }
    case TFileRequestTruncateParams:
        {
            return (get_FileRequestTruncateParams()) == ((aRhs).get_FileRequestTruncateParams());
        }
    case TFileRequestFlushParams:
        {
            return (get_FileRequestFlushParams()) == ((aRhs).get_FileRequestFlushParams());
        }
    case TFileRequestGetFileParams:
        {
            return (get_FileRequestGetFileParams()) == ((aRhs).get_FileRequestGetFileParams());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto FileRequestParams::get(FileRequestGetMetadataParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestGetMetadataParams();
}

auto FileRequestParams::get(FileRequestReadParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestReadParams();
}

auto FileRequestParams::get(FileRequestWriteParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestWriteParams();
}

auto FileRequestParams::get(FileRequestTruncateParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestTruncateParams();
}

auto FileRequestParams::get(FileRequestFlushParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestFlushParams();
}

auto FileRequestParams::get(FileRequestGetFileParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestGetFileParams();
}

} // namespace dom
} // namespace mozilla