/work/obj-fuzz/ipc/ipdl/PBackgroundIDBRequest.cpp

Source (jump to first uncovered line)
//
// Automatically generated by ipdlc.
// Edit at your own risk
//


#include "mozilla/dom/indexedDB/SerializationHelpers.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBTransactionParent.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBTransactionChild.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBVersionChangeTransactionParent.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBVersionChangeTransactionChild.h"
#include "mozilla/dom/PBackgroundMutableFileParent.h"
#include "mozilla/dom/PBackgroundMutableFileChild.h"
#include "mozilla/ipc/PChildToParentStreamParent.h"
#include "mozilla/ipc/PChildToParentStreamChild.h"
#include "mozilla/ipc/PFileDescriptorSetParent.h"
#include "mozilla/ipc/PFileDescriptorSetChild.h"
#include "mozilla/ipc/PIPCBlobInputStreamParent.h"
#include "mozilla/ipc/PIPCBlobInputStreamChild.h"
#include "mozilla/ipc/PParentToChildStreamParent.h"
#include "mozilla/ipc/PParentToChildStreamChild.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBRequest.h"

namespace mozilla {
namespace dom {
namespace indexedDB {
namespace PBackgroundIDBRequest {

nsresult
CreateEndpoints(
        base::ProcessId aParentDestPid,
        base::ProcessId aChildDestPid,
        mozilla::ipc::Endpoint<mozilla::dom::indexedDB::PBackgroundIDBRequestParent>* aParent,
        mozilla::ipc::Endpoint<mozilla::dom::indexedDB::PBackgroundIDBRequestChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(mozilla::ipc::PrivateIPDLInterface(), aParentDestPid, aChildDestPid, aParent, aChild);
}
IPC::Message*
Msg_Continue(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_Continue__ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::NOT_REPLY));
}
IPC::Message*
Msg___delete__(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg___delete____ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::NOT_REPLY));
}
IPC::Message*
Reply___delete__(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply___delete____ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::REPLY));
}
IPC::Message*
Msg_Preprocess(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_Preprocess__ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::NOT_REPLY));
}

} // namespace PBackgroundIDBRequest
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

auto IPDLParamTraits<mozilla::dom::indexedDB::ObjectStoreGetAllResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->cloneInfos())))))) {
        (aActor)->FatalError("Error deserializing 'cloneInfos' (SerializedStructuredCloneReadInfo[]) member of 'ObjectStoreGetAllResponse'");
        return false;
    }
    // Sentinel = 'cloneInfos'
    if ((!((aMsg)->ReadSentinel(aIter, 1304267668)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cloneInfos' (SerializedStructuredCloneReadInfo[]) member of 'ObjectStoreGetAllResponse'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

auto IPDLParamTraits<mozilla::dom::indexedDB::ObjectStoreGetAllKeysResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->keys())))))) {
        (aActor)->FatalError("Error deserializing 'keys' (Key[]) member of 'ObjectStoreGetAllKeysResponse'");
        return false;
    }
    // Sentinel = 'keys'
    if ((!((aMsg)->ReadSentinel(aIter, 1552012744)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keys' (Key[]) member of 'ObjectStoreGetAllKeysResponse'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreDeleteResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto ObjectStoreDeleteResponse::operator==(const ObjectStoreDeleteResponse& _o) const -> bool
{
    return true;
}

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::indexedDB::ObjectStoreDeleteResponse>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
}

auto IPDLParamTraits<mozilla::dom::indexedDB::ObjectStoreDeleteResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreClearResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto ObjectStoreClearResponse::operator==(const ObjectStoreClearResponse& _o) const -> bool
{
    return true;
}

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::indexedDB::ObjectStoreClearResponse>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
}

auto IPDLParamTraits<mozilla::dom::indexedDB::ObjectStoreClearResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

auto IPDLParamTraits<mozilla::dom::indexedDB::IndexGetAllResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->cloneInfos())))))) {
        (aActor)->FatalError("Error deserializing 'cloneInfos' (SerializedStructuredCloneReadInfo[]) member of 'IndexGetAllResponse'");
        return false;
    }
    // Sentinel = 'cloneInfos'
    if ((!((aMsg)->ReadSentinel(aIter, 1304267668)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cloneInfos' (SerializedStructuredCloneReadInfo[]) member of 'IndexGetAllResponse'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

auto IPDLParamTraits<mozilla::dom::indexedDB::IndexGetAllKeysResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->keys())))))) {
        (aActor)->FatalError("Error deserializing 'keys' (Key[]) member of 'IndexGetAllKeysResponse'");
        return false;
    }
    // Sentinel = 'keys'
    if ((!((aMsg)->ReadSentinel(aIter, 1552012744)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keys' (Key[]) member of 'IndexGetAllKeysResponse'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union RequestResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto RequestResponse::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TObjectStoreGetResponse:
        {
            (ptr_ObjectStoreGetResponse())->~ObjectStoreGetResponse__tdef();
            break;
        }
    case TObjectStoreGetKeyResponse:
        {
            (ptr_ObjectStoreGetKeyResponse())->~ObjectStoreGetKeyResponse__tdef();
            break;
        }
    case TObjectStoreAddResponse:
        {
            (ptr_ObjectStoreAddResponse())->~ObjectStoreAddResponse__tdef();
            break;
        }
    case TObjectStorePutResponse:
        {
            (ptr_ObjectStorePutResponse())->~ObjectStorePutResponse__tdef();
            break;
        }
    case TObjectStoreDeleteResponse:
        {
            (ptr_ObjectStoreDeleteResponse())->~ObjectStoreDeleteResponse__tdef();
            break;
        }
    case TObjectStoreClearResponse:
        {
            (ptr_ObjectStoreClearResponse())->~ObjectStoreClearResponse__tdef();
            break;
        }
    case TObjectStoreCountResponse:
        {
            (ptr_ObjectStoreCountResponse())->~ObjectStoreCountResponse__tdef();
            break;
        }
    case TObjectStoreGetAllResponse:
        {
            (ptr_ObjectStoreGetAllResponse())->~ObjectStoreGetAllResponse__tdef();
            break;
        }
    case TObjectStoreGetAllKeysResponse:
        {
            (ptr_ObjectStoreGetAllKeysResponse())->~ObjectStoreGetAllKeysResponse__tdef();
            break;
        }
    case TIndexGetResponse:
        {
            (ptr_IndexGetResponse())->~IndexGetResponse__tdef();
            break;
        }
    case TIndexGetKeyResponse:
        {
            (ptr_IndexGetKeyResponse())->~IndexGetKeyResponse__tdef();
            break;
        }
    case TIndexGetAllResponse:
        {
            (ptr_IndexGetAllResponse())->~IndexGetAllResponse__tdef();
            break;
        }
    case TIndexGetAllKeysResponse:
        {
            (ptr_IndexGetAllKeysResponse())->~IndexGetAllKeysResponse__tdef();
            break;
        }
    case TIndexCountResponse:
        {
            (ptr_IndexCountResponse())->~IndexCountResponse__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const nsresult& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
    mType = Tnsresult;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(nsresult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
    mType = Tnsresult;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreGetResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetResponse()) ObjectStoreGetResponse(aOther);
    mType = TObjectStoreGetResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreGetResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetResponse()) ObjectStoreGetResponse(std::move(aOther));
    mType = TObjectStoreGetResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreGetKeyResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse(aOther);
    mType = TObjectStoreGetKeyResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreGetKeyResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse(std::move(aOther));
    mType = TObjectStoreGetKeyResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreAddResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse(aOther);
    mType = TObjectStoreAddResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreAddResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse(std::move(aOther));
    mType = TObjectStoreAddResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStorePutResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse(aOther);
    mType = TObjectStorePutResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStorePutResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse(std::move(aOther));
    mType = TObjectStorePutResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreDeleteResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse(aOther);
    mType = TObjectStoreDeleteResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreDeleteResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse(std::move(aOther));
    mType = TObjectStoreDeleteResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreClearResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse(aOther);
    mType = TObjectStoreClearResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreClearResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse(std::move(aOther));
    mType = TObjectStoreClearResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreCountResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse(aOther);
    mType = TObjectStoreCountResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreCountResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse(std::move(aOther));
    mType = TObjectStoreCountResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreGetAllResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllResponse()) ObjectStoreGetAllResponse(aOther);
    mType = TObjectStoreGetAllResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreGetAllResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllResponse()) ObjectStoreGetAllResponse(std::move(aOther));
    mType = TObjectStoreGetAllResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreGetAllKeysResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse(aOther);
    mType = TObjectStoreGetAllKeysResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreGetAllKeysResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse(std::move(aOther));
    mType = TObjectStoreGetAllKeysResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const IndexGetResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetResponse()) IndexGetResponse(aOther);
    mType = TIndexGetResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(IndexGetResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetResponse()) IndexGetResponse(std::move(aOther));
    mType = TIndexGetResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const IndexGetKeyResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse(aOther);
    mType = TIndexGetKeyResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(IndexGetKeyResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse(std::move(aOther));
    mType = TIndexGetKeyResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const IndexGetAllResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetAllResponse()) IndexGetAllResponse(aOther);
    mType = TIndexGetAllResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(IndexGetAllResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetAllResponse()) IndexGetAllResponse(std::move(aOther));
    mType = TIndexGetAllResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const IndexGetAllKeysResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse(aOther);
    mType = TIndexGetAllKeysResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(IndexGetAllKeysResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse(std::move(aOther));
    mType = TIndexGetAllKeysResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const IndexCountResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse(aOther);
    mType = TIndexCountResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(IndexCountResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse(std::move(aOther));
    mType = TIndexCountResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const RequestResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TObjectStoreGetResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetResponse()) ObjectStoreGetResponse((aOther).get_ObjectStoreGetResponse());
            break;
        }
    case TObjectStoreGetKeyResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse((aOther).get_ObjectStoreGetKeyResponse());
            break;
        }
    case TObjectStoreAddResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse((aOther).get_ObjectStoreAddResponse());
            break;
        }
    case TObjectStorePutResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse((aOther).get_ObjectStorePutResponse());
            break;
        }
    case TObjectStoreDeleteResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse((aOther).get_ObjectStoreDeleteResponse());
            break;
        }
    case TObjectStoreClearResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse((aOther).get_ObjectStoreClearResponse());
            break;
        }
    case TObjectStoreCountResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse((aOther).get_ObjectStoreCountResponse());
            break;
        }
    case TObjectStoreGetAllResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllResponse()) ObjectStoreGetAllResponse((aOther).get_ObjectStoreGetAllResponse());
            break;
        }
    case TObjectStoreGetAllKeysResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse((aOther).get_ObjectStoreGetAllKeysResponse());
            break;
        }
    case TIndexGetResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetResponse()) IndexGetResponse((aOther).get_IndexGetResponse());
            break;
        }
    case TIndexGetKeyResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse((aOther).get_IndexGetKeyResponse());
            break;
        }
    case TIndexGetAllResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetAllResponse()) IndexGetAllResponse((aOther).get_IndexGetAllResponse());
            break;
        }
    case TIndexGetAllKeysResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse((aOther).get_IndexGetAllKeysResponse());
            break;
        }
    case TIndexCountResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse((aOther).get_IndexCountResponse());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT RequestResponse::RequestResponse(RequestResponse&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetResponse()) ObjectStoreGetResponse(std::move((aOther).get_ObjectStoreGetResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetKeyResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse(std::move((aOther).get_ObjectStoreGetKeyResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreAddResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse(std::move((aOther).get_ObjectStoreAddResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TObjectStorePutResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse(std::move((aOther).get_ObjectStorePutResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreDeleteResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse(std::move((aOther).get_ObjectStoreDeleteResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreClearResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse(std::move((aOther).get_ObjectStoreClearResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreCountResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse(std::move((aOther).get_ObjectStoreCountResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetAllResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllResponse()) ObjectStoreGetAllResponse(std::move((aOther).get_ObjectStoreGetAllResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetAllKeysResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse(std::move((aOther).get_ObjectStoreGetAllKeysResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TIndexGetResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetResponse()) IndexGetResponse(std::move((aOther).get_IndexGetResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TIndexGetKeyResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse(std::move((aOther).get_IndexGetKeyResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TIndexGetAllResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetAllResponse()) IndexGetAllResponse(std::move((aOther).get_IndexGetAllResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TIndexGetAllKeysResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse(std::move((aOther).get_IndexGetAllKeysResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TIndexCountResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse(std::move((aOther).get_IndexCountResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto RequestResponse::operator=(const nsresult& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(Tnsresult)) {
        new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
    }
    (*(ptr_nsresult())) = aRhs;
    mType = Tnsresult;
    return (*(this));
}

auto RequestResponse::operator=(nsresult&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(Tnsresult)) {
        new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
    }
    (*(ptr_nsresult())) = std::move(aRhs);
    mType = Tnsresult;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreGetResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreGetResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetResponse()) ObjectStoreGetResponse;
    }
    (*(ptr_ObjectStoreGetResponse())) = aRhs;
    mType = TObjectStoreGetResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreGetResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreGetResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetResponse()) ObjectStoreGetResponse;
    }
    (*(ptr_ObjectStoreGetResponse())) = std::move(aRhs);
    mType = TObjectStoreGetResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreGetKeyResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreGetKeyResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse;
    }
    (*(ptr_ObjectStoreGetKeyResponse())) = aRhs;
    mType = TObjectStoreGetKeyResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreGetKeyResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreGetKeyResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse;
    }
    (*(ptr_ObjectStoreGetKeyResponse())) = std::move(aRhs);
    mType = TObjectStoreGetKeyResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreAddResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreAddResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse;
    }
    (*(ptr_ObjectStoreAddResponse())) = aRhs;
    mType = TObjectStoreAddResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreAddResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreAddResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse;
    }
    (*(ptr_ObjectStoreAddResponse())) = std::move(aRhs);
    mType = TObjectStoreAddResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStorePutResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStorePutResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse;
    }
    (*(ptr_ObjectStorePutResponse())) = aRhs;
    mType = TObjectStorePutResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStorePutResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStorePutResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse;
    }
    (*(ptr_ObjectStorePutResponse())) = std::move(aRhs);
    mType = TObjectStorePutResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreDeleteResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreDeleteResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse;
    }
    (*(ptr_ObjectStoreDeleteResponse())) = aRhs;
    mType = TObjectStoreDeleteResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreDeleteResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreDeleteResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse;
    }
    (*(ptr_ObjectStoreDeleteResponse())) = std::move(aRhs);
    mType = TObjectStoreDeleteResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreClearResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreClearResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse;
    }
    (*(ptr_ObjectStoreClearResponse())) = aRhs;
    mType = TObjectStoreClearResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreClearResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreClearResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse;
    }
    (*(ptr_ObjectStoreClearResponse())) = std::move(aRhs);
    mType = TObjectStoreClearResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreCountResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreCountResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse;
    }
    (*(ptr_ObjectStoreCountResponse())) = aRhs;
    mType = TObjectStoreCountResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreCountResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreCountResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse;
    }
    (*(ptr_ObjectStoreCountResponse())) = std::move(aRhs);
    mType = TObjectStoreCountResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreGetAllResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreGetAllResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllResponse()) ObjectStoreGetAllResponse;
    }
    (*(ptr_ObjectStoreGetAllResponse())) = aRhs;
    mType = TObjectStoreGetAllResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreGetAllResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreGetAllResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllResponse()) ObjectStoreGetAllResponse;
    }
    (*(ptr_ObjectStoreGetAllResponse())) = std::move(aRhs);
    mType = TObjectStoreGetAllResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreGetAllKeysResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreGetAllKeysResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse;
    }
    (*(ptr_ObjectStoreGetAllKeysResponse())) = aRhs;
    mType = TObjectStoreGetAllKeysResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreGetAllKeysResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TObjectStoreGetAllKeysResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse;
    }
    (*(ptr_ObjectStoreGetAllKeysResponse())) = std::move(aRhs);
    mType = TObjectStoreGetAllKeysResponse;
    return (*(this));
}

auto RequestResponse::operator=(const IndexGetResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TIndexGetResponse)) {
        new (mozilla::KnownNotNull, ptr_IndexGetResponse()) IndexGetResponse;
    }
    (*(ptr_IndexGetResponse())) = aRhs;
    mType = TIndexGetResponse;
    return (*(this));
}

auto RequestResponse::operator=(IndexGetResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TIndexGetResponse)) {
        new (mozilla::KnownNotNull, ptr_IndexGetResponse()) IndexGetResponse;
    }
    (*(ptr_IndexGetResponse())) = std::move(aRhs);
    mType = TIndexGetResponse;
    return (*(this));
}

auto RequestResponse::operator=(const IndexGetKeyResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TIndexGetKeyResponse)) {
        new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse;
    }
    (*(ptr_IndexGetKeyResponse())) = aRhs;
    mType = TIndexGetKeyResponse;
    return (*(this));
}

auto RequestResponse::operator=(IndexGetKeyResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TIndexGetKeyResponse)) {
        new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse;
    }
    (*(ptr_IndexGetKeyResponse())) = std::move(aRhs);
    mType = TIndexGetKeyResponse;
    return (*(this));
}

auto RequestResponse::operator=(const IndexGetAllResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TIndexGetAllResponse)) {
        new (mozilla::KnownNotNull, ptr_IndexGetAllResponse()) IndexGetAllResponse;
    }
    (*(ptr_IndexGetAllResponse())) = aRhs;
    mType = TIndexGetAllResponse;
    return (*(this));
}

auto RequestResponse::operator=(IndexGetAllResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TIndexGetAllResponse)) {
        new (mozilla::KnownNotNull, ptr_IndexGetAllResponse()) IndexGetAllResponse;
    }
    (*(ptr_IndexGetAllResponse())) = std::move(aRhs);
    mType = TIndexGetAllResponse;
    return (*(this));
}

auto RequestResponse::operator=(const IndexGetAllKeysResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TIndexGetAllKeysResponse)) {
        new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse;
    }
    (*(ptr_IndexGetAllKeysResponse())) = aRhs;
    mType = TIndexGetAllKeysResponse;
    return (*(this));
}

auto RequestResponse::operator=(IndexGetAllKeysResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TIndexGetAllKeysResponse)) {
        new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse;
    }
    (*(ptr_IndexGetAllKeysResponse())) = std::move(aRhs);
    mType = TIndexGetAllKeysResponse;
    return (*(this));
}

auto RequestResponse::operator=(const IndexCountResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TIndexCountResponse)) {
        new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse;
    }
    (*(ptr_IndexCountResponse())) = aRhs;
    mType = TIndexCountResponse;
    return (*(this));
}

auto RequestResponse::operator=(IndexCountResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TIndexCountResponse)) {
        new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse;
    }
    (*(ptr_IndexCountResponse())) = std::move(aRhs);
    mType = TIndexCountResponse;
    return (*(this));
}

auto RequestResponse::operator=(const RequestResponse& aRhs) -> RequestResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
            }
            (*(ptr_nsresult())) = (aRhs).get_nsresult();
            break;
        }
    case TObjectStoreGetResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetResponse()) ObjectStoreGetResponse;
            }
            (*(ptr_ObjectStoreGetResponse())) = (aRhs).get_ObjectStoreGetResponse();
            break;
        }
    case TObjectStoreGetKeyResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse;
            }
            (*(ptr_ObjectStoreGetKeyResponse())) = (aRhs).get_ObjectStoreGetKeyResponse();
            break;
        }
    case TObjectStoreAddResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse;
            }
            (*(ptr_ObjectStoreAddResponse())) = (aRhs).get_ObjectStoreAddResponse();
            break;
        }
    case TObjectStorePutResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse;
            }
            (*(ptr_ObjectStorePutResponse())) = (aRhs).get_ObjectStorePutResponse();
            break;
        }
    case TObjectStoreDeleteResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse;
            }
            (*(ptr_ObjectStoreDeleteResponse())) = (aRhs).get_ObjectStoreDeleteResponse();
            break;
        }
    case TObjectStoreClearResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse;
            }
            (*(ptr_ObjectStoreClearResponse())) = (aRhs).get_ObjectStoreClearResponse();
            break;
        }
    case TObjectStoreCountResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse;
            }
            (*(ptr_ObjectStoreCountResponse())) = (aRhs).get_ObjectStoreCountResponse();
            break;
        }
    case TObjectStoreGetAllResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllResponse()) ObjectStoreGetAllResponse;
            }
            (*(ptr_ObjectStoreGetAllResponse())) = (aRhs).get_ObjectStoreGetAllResponse();
            break;
        }
    case TObjectStoreGetAllKeysResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse;
            }
            (*(ptr_ObjectStoreGetAllKeysResponse())) = (aRhs).get_ObjectStoreGetAllKeysResponse();
            break;
        }
    case TIndexGetResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IndexGetResponse()) IndexGetResponse;
            }
            (*(ptr_IndexGetResponse())) = (aRhs).get_IndexGetResponse();
            break;
        }
    case TIndexGetKeyResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse;
            }
            (*(ptr_IndexGetKeyResponse())) = (aRhs).get_IndexGetKeyResponse();
            break;
        }
    case TIndexGetAllResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IndexGetAllResponse()) IndexGetAllResponse;
            }
            (*(ptr_IndexGetAllResponse())) = (aRhs).get_IndexGetAllResponse();
            break;
        }
    case TIndexGetAllKeysResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse;
            }
            (*(ptr_IndexGetAllKeysResponse())) = (aRhs).get_IndexGetAllKeysResponse();
            break;
        }
    case TIndexCountResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse;
            }
            (*(ptr_IndexCountResponse())) = (aRhs).get_IndexCountResponse();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto RequestResponse::operator=(RequestResponse&& aRhs) -> RequestResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
            }
            (*(ptr_nsresult())) = std::move((aRhs).get_nsresult());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetResponse()) ObjectStoreGetResponse;
            }
            (*(ptr_ObjectStoreGetResponse())) = std::move((aRhs).get_ObjectStoreGetResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetKeyResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse;
            }
            (*(ptr_ObjectStoreGetKeyResponse())) = std::move((aRhs).get_ObjectStoreGetKeyResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreAddResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse;
            }
            (*(ptr_ObjectStoreAddResponse())) = std::move((aRhs).get_ObjectStoreAddResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TObjectStorePutResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse;
            }
            (*(ptr_ObjectStorePutResponse())) = std::move((aRhs).get_ObjectStorePutResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreDeleteResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse;
            }
            (*(ptr_ObjectStoreDeleteResponse())) = std::move((aRhs).get_ObjectStoreDeleteResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreClearResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse;
            }
            (*(ptr_ObjectStoreClearResponse())) = std::move((aRhs).get_ObjectStoreClearResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreCountResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse;
            }
            (*(ptr_ObjectStoreCountResponse())) = std::move((aRhs).get_ObjectStoreCountResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetAllResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllResponse()) ObjectStoreGetAllResponse;
            }
            (*(ptr_ObjectStoreGetAllResponse())) = std::move((aRhs).get_ObjectStoreGetAllResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetAllKeysResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse;
            }
            (*(ptr_ObjectStoreGetAllKeysResponse())) = std::move((aRhs).get_ObjectStoreGetAllKeysResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TIndexGetResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IndexGetResponse()) IndexGetResponse;
            }
            (*(ptr_IndexGetResponse())) = std::move((aRhs).get_IndexGetResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TIndexGetKeyResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse;
            }
            (*(ptr_IndexGetKeyResponse())) = std::move((aRhs).get_IndexGetKeyResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TIndexGetAllResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IndexGetAllResponse()) IndexGetAllResponse;
            }
            (*(ptr_IndexGetAllResponse())) = std::move((aRhs).get_IndexGetAllResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TIndexGetAllKeysResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse;
            }
            (*(ptr_IndexGetAllKeysResponse())) = std::move((aRhs).get_IndexGetAllKeysResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TIndexCountResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse;
            }
            (*(ptr_IndexCountResponse())) = std::move((aRhs).get_IndexCountResponse());
            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 RequestResponse::operator==(const nsresult& aRhs) const -> bool
{
    return (get_nsresult()) == (aRhs);
}

auto RequestResponse::operator==(const ObjectStoreGetResponse& aRhs) const -> bool
{
    return (get_ObjectStoreGetResponse()) == (aRhs);
}

auto RequestResponse::operator==(const ObjectStoreGetKeyResponse& aRhs) const -> bool
{
    return (get_ObjectStoreGetKeyResponse()) == (aRhs);
}

auto RequestResponse::operator==(const ObjectStoreAddResponse& aRhs) const -> bool
{
    return (get_ObjectStoreAddResponse()) == (aRhs);
}

auto RequestResponse::operator==(const ObjectStorePutResponse& aRhs) const -> bool
{
    return (get_ObjectStorePutResponse()) == (aRhs);
}

auto RequestResponse::operator==(const ObjectStoreDeleteResponse& aRhs) const -> bool
{
    return (get_ObjectStoreDeleteResponse()) == (aRhs);
}

auto RequestResponse::operator==(const ObjectStoreClearResponse& aRhs) const -> bool
{
    return (get_ObjectStoreClearResponse()) == (aRhs);
}

auto RequestResponse::operator==(const ObjectStoreCountResponse& aRhs) const -> bool
{
    return (get_ObjectStoreCountResponse()) == (aRhs);
}

auto RequestResponse::operator==(const ObjectStoreGetAllResponse& aRhs) const -> bool
{
    return (get_ObjectStoreGetAllResponse()) == (aRhs);
}

auto RequestResponse::operator==(const ObjectStoreGetAllKeysResponse& aRhs) const -> bool
{
    return (get_ObjectStoreGetAllKeysResponse()) == (aRhs);
}

auto RequestResponse::operator==(const IndexGetResponse& aRhs) const -> bool
{
    return (get_IndexGetResponse()) == (aRhs);
}

auto RequestResponse::operator==(const IndexGetKeyResponse& aRhs) const -> bool
{
    return (get_IndexGetKeyResponse()) == (aRhs);
}

auto RequestResponse::operator==(const IndexGetAllResponse& aRhs) const -> bool
{
    return (get_IndexGetAllResponse()) == (aRhs);
}

auto RequestResponse::operator==(const IndexGetAllKeysResponse& aRhs) const -> bool
{
    return (get_IndexGetAllKeysResponse()) == (aRhs);
}

auto RequestResponse::operator==(const IndexCountResponse& aRhs) const -> bool
{
    return (get_IndexCountResponse()) == (aRhs);
}

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

    switch (type()) {
    case Tnsresult:
        {
            return (get_nsresult()) == ((aRhs).get_nsresult());
        }
    case TObjectStoreGetResponse:
        {
            return (get_ObjectStoreGetResponse()) == ((aRhs).get_ObjectStoreGetResponse());
        }
    case TObjectStoreGetKeyResponse:
        {
            return (get_ObjectStoreGetKeyResponse()) == ((aRhs).get_ObjectStoreGetKeyResponse());
        }
    case TObjectStoreAddResponse:
        {
            return (get_ObjectStoreAddResponse()) == ((aRhs).get_ObjectStoreAddResponse());
        }
    case TObjectStorePutResponse:
        {
            return (get_ObjectStorePutResponse()) == ((aRhs).get_ObjectStorePutResponse());
        }
    case TObjectStoreDeleteResponse:
        {
            return (get_ObjectStoreDeleteResponse()) == ((aRhs).get_ObjectStoreDeleteResponse());
        }
    case TObjectStoreClearResponse:
        {
            return (get_ObjectStoreClearResponse()) == ((aRhs).get_ObjectStoreClearResponse());
        }
    case TObjectStoreCountResponse:
        {
            return (get_ObjectStoreCountResponse()) == ((aRhs).get_ObjectStoreCountResponse());
        }
    case TObjectStoreGetAllResponse:
        {
            return (get_ObjectStoreGetAllResponse()) == ((aRhs).get_ObjectStoreGetAllResponse());
        }
    case TObjectStoreGetAllKeysResponse:
        {
            return (get_ObjectStoreGetAllKeysResponse()) == ((aRhs).get_ObjectStoreGetAllKeysResponse());
        }
    case TIndexGetResponse:
        {
            return (get_IndexGetResponse()) == ((aRhs).get_IndexGetResponse());
        }
    case TIndexGetKeyResponse:
        {
            return (get_IndexGetKeyResponse()) == ((aRhs).get_IndexGetKeyResponse());
        }
    case TIndexGetAllResponse:
        {
            return (get_IndexGetAllResponse()) == ((aRhs).get_IndexGetAllResponse());
        }
    case TIndexGetAllKeysResponse:
        {
            return (get_IndexGetAllKeysResponse()) == ((aRhs).get_IndexGetAllKeysResponse());
        }
    case TIndexCountResponse:
        {
            return (get_IndexCountResponse()) == ((aRhs).get_IndexCountResponse());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto RequestResponse::get(nsresult* aOutValue) const -> void
{
    (*(aOutValue)) = get_nsresult();
}

auto RequestResponse::get(ObjectStoreGetResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStoreGetResponse();
}

auto RequestResponse::get(ObjectStoreGetKeyResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStoreGetKeyResponse();
}

auto RequestResponse::get(ObjectStoreAddResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStoreAddResponse();
}

auto RequestResponse::get(ObjectStorePutResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStorePutResponse();
}

auto RequestResponse::get(ObjectStoreDeleteResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStoreDeleteResponse();
}

auto RequestResponse::get(ObjectStoreClearResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStoreClearResponse();
}

auto RequestResponse::get(ObjectStoreCountResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStoreCountResponse();
}

auto RequestResponse::get(ObjectStoreGetAllResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStoreGetAllResponse();
}

auto RequestResponse::get(ObjectStoreGetAllKeysResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStoreGetAllKeysResponse();
}

auto RequestResponse::get(IndexGetResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_IndexGetResponse();
}

auto RequestResponse::get(IndexGetKeyResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_IndexGetKeyResponse();
}

auto RequestResponse::get(IndexGetAllResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_IndexGetAllResponse();
}

auto RequestResponse::get(IndexGetAllKeysResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_IndexGetAllKeysResponse();
}

auto RequestResponse::get(IndexCountResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_IndexCountResponse();
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tnsresult:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aMsg)->WriteSentinel(2293764539);
            return;
        }
    case union__::TObjectStoreGetResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStoreGetResponse());
            // Sentinel = 'TObjectStoreGetResponse'
            (aMsg)->WriteSentinel(2846778146);
            return;
        }
    case union__::TObjectStoreGetKeyResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStoreGetKeyResponse());
            // Sentinel = 'TObjectStoreGetKeyResponse'
            (aMsg)->WriteSentinel(1512106430);
            return;
        }
    case union__::TObjectStoreAddResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStoreAddResponse());
            // Sentinel = 'TObjectStoreAddResponse'
            (aMsg)->WriteSentinel(1432077971);
            return;
        }
    case union__::TObjectStorePutResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStorePutResponse());
            // Sentinel = 'TObjectStorePutResponse'
            (aMsg)->WriteSentinel(3747668645);
            return;
        }
    case union__::TObjectStoreDeleteResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStoreDeleteResponse());
            // Sentinel = 'TObjectStoreDeleteResponse'
            (aMsg)->WriteSentinel(1382231374);
            return;
        }
    case union__::TObjectStoreClearResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStoreClearResponse());
            // Sentinel = 'TObjectStoreClearResponse'
            (aMsg)->WriteSentinel(2991872479);
            return;
        }
    case union__::TObjectStoreCountResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStoreCountResponse());
            // Sentinel = 'TObjectStoreCountResponse'
            (aMsg)->WriteSentinel(3294069745);
            return;
        }
    case union__::TObjectStoreGetAllResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStoreGetAllResponse());
            // Sentinel = 'TObjectStoreGetAllResponse'
            (aMsg)->WriteSentinel(1539548426);
            return;
        }
    case union__::TObjectStoreGetAllKeysResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStoreGetAllKeysResponse());
            // Sentinel = 'TObjectStoreGetAllKeysResponse'
            (aMsg)->WriteSentinel(1230484214);
            return;
        }
    case union__::TIndexGetResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_IndexGetResponse());
            // Sentinel = 'TIndexGetResponse'
            (aMsg)->WriteSentinel(3158738640);
            return;
        }
    case union__::TIndexGetKeyResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_IndexGetKeyResponse());
            // Sentinel = 'TIndexGetKeyResponse'
            (aMsg)->WriteSentinel(3940154148);
            return;
        }
    case union__::TIndexGetAllResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_IndexGetAllResponse());
            // Sentinel = 'TIndexGetAllResponse'
            (aMsg)->WriteSentinel(805776320);
            return;
        }
    case union__::TIndexGetAllKeysResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_IndexGetAllKeysResponse());
            // Sentinel = 'TIndexGetAllKeysResponse'
            (aMsg)->WriteSentinel(558431772);
            return;
        }
    case union__::TIndexCountResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_IndexCountResponse());
            // Sentinel = 'TIndexCountResponse'
            (aMsg)->WriteSentinel(198309135);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::Tnsresult:
        {
            nsresult tmp = nsresult();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_nsresult())))))) {
                (aActor)->FatalError("Error deserializing variant Tnsresult of union RequestResponse");
                return false;
            }
            // Sentinel = 'Tnsresult'
            if ((!((aMsg)->ReadSentinel(aIter, 2293764539)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TObjectStoreGetResponse:
        {
            mozilla::dom::indexedDB::ObjectStoreGetResponse tmp = mozilla::dom::indexedDB::ObjectStoreGetResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStoreGetResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStoreGetResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TObjectStoreGetResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 2846778146)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TObjectStoreGetKeyResponse:
        {
            mozilla::dom::indexedDB::ObjectStoreGetKeyResponse tmp = mozilla::dom::indexedDB::ObjectStoreGetKeyResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStoreGetKeyResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStoreGetKeyResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TObjectStoreGetKeyResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 1512106430)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetKeyResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TObjectStoreAddResponse:
        {
            mozilla::dom::indexedDB::ObjectStoreAddResponse tmp = mozilla::dom::indexedDB::ObjectStoreAddResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStoreAddResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStoreAddResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TObjectStoreAddResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 1432077971)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreAddResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TObjectStorePutResponse:
        {
            mozilla::dom::indexedDB::ObjectStorePutResponse tmp = mozilla::dom::indexedDB::ObjectStorePutResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStorePutResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStorePutResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TObjectStorePutResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 3747668645)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStorePutResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TObjectStoreDeleteResponse:
        {
            mozilla::dom::indexedDB::ObjectStoreDeleteResponse tmp = mozilla::dom::indexedDB::ObjectStoreDeleteResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStoreDeleteResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStoreDeleteResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TObjectStoreDeleteResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 1382231374)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreDeleteResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TObjectStoreClearResponse:
        {
            mozilla::dom::indexedDB::ObjectStoreClearResponse tmp = mozilla::dom::indexedDB::ObjectStoreClearResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStoreClearResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStoreClearResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TObjectStoreClearResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 2991872479)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreClearResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TObjectStoreCountResponse:
        {
            mozilla::dom::indexedDB::ObjectStoreCountResponse tmp = mozilla::dom::indexedDB::ObjectStoreCountResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStoreCountResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStoreCountResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TObjectStoreCountResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 3294069745)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreCountResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TObjectStoreGetAllResponse:
        {
            mozilla::dom::indexedDB::ObjectStoreGetAllResponse tmp = mozilla::dom::indexedDB::ObjectStoreGetAllResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStoreGetAllResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStoreGetAllResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TObjectStoreGetAllResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 1539548426)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetAllResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TObjectStoreGetAllKeysResponse:
        {
            mozilla::dom::indexedDB::ObjectStoreGetAllKeysResponse tmp = mozilla::dom::indexedDB::ObjectStoreGetAllKeysResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStoreGetAllKeysResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStoreGetAllKeysResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TObjectStoreGetAllKeysResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 1230484214)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetAllKeysResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TIndexGetResponse:
        {
            mozilla::dom::indexedDB::IndexGetResponse tmp = mozilla::dom::indexedDB::IndexGetResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_IndexGetResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TIndexGetResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TIndexGetResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 3158738640)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIndexGetResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TIndexGetKeyResponse:
        {
            mozilla::dom::indexedDB::IndexGetKeyResponse tmp = mozilla::dom::indexedDB::IndexGetKeyResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_IndexGetKeyResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TIndexGetKeyResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TIndexGetKeyResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 3940154148)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIndexGetKeyResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TIndexGetAllResponse:
        {
            mozilla::dom::indexedDB::IndexGetAllResponse tmp = mozilla::dom::indexedDB::IndexGetAllResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_IndexGetAllResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TIndexGetAllResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TIndexGetAllResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 805776320)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIndexGetAllResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TIndexGetAllKeysResponse:
        {
            mozilla::dom::indexedDB::IndexGetAllKeysResponse tmp = mozilla::dom::indexedDB::IndexGetAllKeysResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_IndexGetAllKeysResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TIndexGetAllKeysResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TIndexGetAllKeysResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 558431772)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIndexGetAllKeysResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TIndexCountResponse:
        {
            mozilla::dom::indexedDB::IndexCountResponse tmp = mozilla::dom::indexedDB::IndexCountResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_IndexCountResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TIndexCountResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TIndexCountResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 198309135)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIndexCountResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

auto IPDLParamTraits<mozilla::dom::indexedDB::WasmModulePreprocessInfo>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->files())))))) {
        (aActor)->FatalError("Error deserializing 'files' (SerializedStructuredCloneFile[]) member of 'WasmModulePreprocessInfo'");
        return false;
    }
    // Sentinel = 'files'
    if ((!((aMsg)->ReadSentinel(aIter, 3457906496)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'files' (SerializedStructuredCloneFile[]) member of 'WasmModulePreprocessInfo'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

auto IPDLParamTraits<mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->preprocessInfos())))))) {
        (aActor)->FatalError("Error deserializing 'preprocessInfos' (WasmModulePreprocessInfo[]) member of 'ObjectStoreGetAllPreprocessParams'");
        return false;
    }
    // Sentinel = 'preprocessInfos'
    if ((!((aMsg)->ReadSentinel(aIter, 1668030026)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preprocessInfos' (WasmModulePreprocessInfo[]) member of 'ObjectStoreGetAllPreprocessParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union PreprocessParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto PreprocessParams::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TObjectStoreGetPreprocessParams:
        {
            (ptr_ObjectStoreGetPreprocessParams())->~ObjectStoreGetPreprocessParams__tdef();
            break;
        }
    case TObjectStoreGetAllPreprocessParams:
        {
            (ptr_ObjectStoreGetAllPreprocessParams())->~ObjectStoreGetAllPreprocessParams__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT PreprocessParams::PreprocessParams(const ObjectStoreGetPreprocessParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams(aOther);
    mType = TObjectStoreGetPreprocessParams;
}

MOZ_IMPLICIT PreprocessParams::PreprocessParams(ObjectStoreGetPreprocessParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams(std::move(aOther));
    mType = TObjectStoreGetPreprocessParams;
}

MOZ_IMPLICIT PreprocessParams::PreprocessParams(const ObjectStoreGetAllPreprocessParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams(aOther);
    mType = TObjectStoreGetAllPreprocessParams;
}

MOZ_IMPLICIT PreprocessParams::PreprocessParams(ObjectStoreGetAllPreprocessParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams(std::move(aOther));
    mType = TObjectStoreGetAllPreprocessParams;
}

MOZ_IMPLICIT PreprocessParams::PreprocessParams(const PreprocessParams& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TObjectStoreGetPreprocessParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams((aOther).get_ObjectStoreGetPreprocessParams());
            break;
        }
    case TObjectStoreGetAllPreprocessParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams((aOther).get_ObjectStoreGetAllPreprocessParams());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT PreprocessParams::PreprocessParams(PreprocessParams&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TObjectStoreGetPreprocessParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams(std::move((aOther).get_ObjectStoreGetPreprocessParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetAllPreprocessParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams(std::move((aOther).get_ObjectStoreGetAllPreprocessParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto PreprocessParams::operator=(const ObjectStoreGetPreprocessParams& aRhs) -> PreprocessParams&
{
    if (MaybeDestroy(TObjectStoreGetPreprocessParams)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams;
    }
    (*(ptr_ObjectStoreGetPreprocessParams())) = aRhs;
    mType = TObjectStoreGetPreprocessParams;
    return (*(this));
}

auto PreprocessParams::operator=(ObjectStoreGetPreprocessParams&& aRhs) -> PreprocessParams&
{
    if (MaybeDestroy(TObjectStoreGetPreprocessParams)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams;
    }
    (*(ptr_ObjectStoreGetPreprocessParams())) = std::move(aRhs);
    mType = TObjectStoreGetPreprocessParams;
    return (*(this));
}

auto PreprocessParams::operator=(const ObjectStoreGetAllPreprocessParams& aRhs) -> PreprocessParams&
{
    if (MaybeDestroy(TObjectStoreGetAllPreprocessParams)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams;
    }
    (*(ptr_ObjectStoreGetAllPreprocessParams())) = aRhs;
    mType = TObjectStoreGetAllPreprocessParams;
    return (*(this));
}

auto PreprocessParams::operator=(ObjectStoreGetAllPreprocessParams&& aRhs) -> PreprocessParams&
{
    if (MaybeDestroy(TObjectStoreGetAllPreprocessParams)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams;
    }
    (*(ptr_ObjectStoreGetAllPreprocessParams())) = std::move(aRhs);
    mType = TObjectStoreGetAllPreprocessParams;
    return (*(this));
}

auto PreprocessParams::operator=(const PreprocessParams& aRhs) -> PreprocessParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TObjectStoreGetPreprocessParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams;
            }
            (*(ptr_ObjectStoreGetPreprocessParams())) = (aRhs).get_ObjectStoreGetPreprocessParams();
            break;
        }
    case TObjectStoreGetAllPreprocessParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams;
            }
            (*(ptr_ObjectStoreGetAllPreprocessParams())) = (aRhs).get_ObjectStoreGetAllPreprocessParams();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto PreprocessParams::operator=(PreprocessParams&& aRhs) -> PreprocessParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TObjectStoreGetPreprocessParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams;
            }
            (*(ptr_ObjectStoreGetPreprocessParams())) = std::move((aRhs).get_ObjectStoreGetPreprocessParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetAllPreprocessParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams;
            }
            (*(ptr_ObjectStoreGetAllPreprocessParams())) = std::move((aRhs).get_ObjectStoreGetAllPreprocessParams());
            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 PreprocessParams::operator==(const ObjectStoreGetPreprocessParams& aRhs) const -> bool
{
    return (get_ObjectStoreGetPreprocessParams()) == (aRhs);
}

auto PreprocessParams::operator==(const ObjectStoreGetAllPreprocessParams& aRhs) const -> bool
{
    return (get_ObjectStoreGetAllPreprocessParams()) == (aRhs);
}

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

    switch (type()) {
    case TObjectStoreGetPreprocessParams:
        {
            return (get_ObjectStoreGetPreprocessParams()) == ((aRhs).get_ObjectStoreGetPreprocessParams());
        }
    case TObjectStoreGetAllPreprocessParams:
        {
            return (get_ObjectStoreGetAllPreprocessParams()) == ((aRhs).get_ObjectStoreGetAllPreprocessParams());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto PreprocessParams::get(ObjectStoreGetPreprocessParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStoreGetPreprocessParams();
}

auto PreprocessParams::get(ObjectStoreGetAllPreprocessParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStoreGetAllPreprocessParams();
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TObjectStoreGetPreprocessParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStoreGetPreprocessParams());
            // Sentinel = 'TObjectStoreGetPreprocessParams'
            (aMsg)->WriteSentinel(3967868331);
            return;
        }
    case union__::TObjectStoreGetAllPreprocessParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStoreGetAllPreprocessParams());
            // Sentinel = 'TObjectStoreGetAllPreprocessParams'
            (aMsg)->WriteSentinel(1107511519);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TObjectStoreGetPreprocessParams:
        {
            mozilla::dom::indexedDB::ObjectStoreGetPreprocessParams tmp = mozilla::dom::indexedDB::ObjectStoreGetPreprocessParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStoreGetPreprocessParams())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStoreGetPreprocessParams of union PreprocessParams");
                return false;
            }
            // Sentinel = 'TObjectStoreGetPreprocessParams'
            if ((!((aMsg)->ReadSentinel(aIter, 3967868331)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetPreprocessParams of union PreprocessParams");
                return false;
            }
            return true;
        }
    case union__::TObjectStoreGetAllPreprocessParams:
        {
            mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessParams tmp = mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStoreGetAllPreprocessParams())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStoreGetAllPreprocessParams of union PreprocessParams");
                return false;
            }
            // Sentinel = 'TObjectStoreGetAllPreprocessParams'
            if ((!((aMsg)->ReadSentinel(aIter, 1107511519)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetAllPreprocessParams of union PreprocessParams");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreGetPreprocessResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto ObjectStoreGetPreprocessResponse::operator==(const ObjectStoreGetPreprocessResponse& _o) const -> bool
{
    return true;
}

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::indexedDB::ObjectStoreGetPreprocessResponse>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
}

auto IPDLParamTraits<mozilla::dom::indexedDB::ObjectStoreGetPreprocessResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreGetAllPreprocessResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto ObjectStoreGetAllPreprocessResponse::operator==(const ObjectStoreGetAllPreprocessResponse& _o) const -> bool
{
    return true;
}

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

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessResponse>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
}

auto IPDLParamTraits<mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union PreprocessResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto PreprocessResponse::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TObjectStoreGetPreprocessResponse:
        {
            (ptr_ObjectStoreGetPreprocessResponse())->~ObjectStoreGetPreprocessResponse__tdef();
            break;
        }
    case TObjectStoreGetAllPreprocessResponse:
        {
            (ptr_ObjectStoreGetAllPreprocessResponse())->~ObjectStoreGetAllPreprocessResponse__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(const nsresult& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
    mType = Tnsresult;
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(nsresult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
    mType = Tnsresult;
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(const ObjectStoreGetPreprocessResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse(aOther);
    mType = TObjectStoreGetPreprocessResponse;
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(ObjectStoreGetPreprocessResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse(std::move(aOther));
    mType = TObjectStoreGetPreprocessResponse;
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(const ObjectStoreGetAllPreprocessResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse(aOther);
    mType = TObjectStoreGetAllPreprocessResponse;
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(ObjectStoreGetAllPreprocessResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse(std::move(aOther));
    mType = TObjectStoreGetAllPreprocessResponse;
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(const PreprocessResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TObjectStoreGetPreprocessResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse((aOther).get_ObjectStoreGetPreprocessResponse());
            break;
        }
    case TObjectStoreGetAllPreprocessResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse((aOther).get_ObjectStoreGetAllPreprocessResponse());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(PreprocessResponse&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetPreprocessResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse(std::move((aOther).get_ObjectStoreGetPreprocessResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetAllPreprocessResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse(std::move((aOther).get_ObjectStoreGetAllPreprocessResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto PreprocessResponse::operator=(const nsresult& aRhs) -> PreprocessResponse&
{
    if (MaybeDestroy(Tnsresult)) {
        new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
    }
    (*(ptr_nsresult())) = aRhs;
    mType = Tnsresult;
    return (*(this));
}

auto PreprocessResponse::operator=(nsresult&& aRhs) -> PreprocessResponse&
{
    if (MaybeDestroy(Tnsresult)) {
        new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
    }
    (*(ptr_nsresult())) = std::move(aRhs);
    mType = Tnsresult;
    return (*(this));
}

auto PreprocessResponse::operator=(const ObjectStoreGetPreprocessResponse& aRhs) -> PreprocessResponse&
{
    if (MaybeDestroy(TObjectStoreGetPreprocessResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse;
    }
    (*(ptr_ObjectStoreGetPreprocessResponse())) = aRhs;
    mType = TObjectStoreGetPreprocessResponse;
    return (*(this));
}

auto PreprocessResponse::operator=(ObjectStoreGetPreprocessResponse&& aRhs) -> PreprocessResponse&
{
    if (MaybeDestroy(TObjectStoreGetPreprocessResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse;
    }
    (*(ptr_ObjectStoreGetPreprocessResponse())) = std::move(aRhs);
    mType = TObjectStoreGetPreprocessResponse;
    return (*(this));
}

auto PreprocessResponse::operator=(const ObjectStoreGetAllPreprocessResponse& aRhs) -> PreprocessResponse&
{
    if (MaybeDestroy(TObjectStoreGetAllPreprocessResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse;
    }
    (*(ptr_ObjectStoreGetAllPreprocessResponse())) = aRhs;
    mType = TObjectStoreGetAllPreprocessResponse;
    return (*(this));
}

auto PreprocessResponse::operator=(ObjectStoreGetAllPreprocessResponse&& aRhs) -> PreprocessResponse&
{
    if (MaybeDestroy(TObjectStoreGetAllPreprocessResponse)) {
        new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse;
    }
    (*(ptr_ObjectStoreGetAllPreprocessResponse())) = std::move(aRhs);
    mType = TObjectStoreGetAllPreprocessResponse;
    return (*(this));
}

auto PreprocessResponse::operator=(const PreprocessResponse& aRhs) -> PreprocessResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
            }
            (*(ptr_nsresult())) = (aRhs).get_nsresult();
            break;
        }
    case TObjectStoreGetPreprocessResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse;
            }
            (*(ptr_ObjectStoreGetPreprocessResponse())) = (aRhs).get_ObjectStoreGetPreprocessResponse();
            break;
        }
    case TObjectStoreGetAllPreprocessResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse;
            }
            (*(ptr_ObjectStoreGetAllPreprocessResponse())) = (aRhs).get_ObjectStoreGetAllPreprocessResponse();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto PreprocessResponse::operator=(PreprocessResponse&& aRhs) -> PreprocessResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
            }
            (*(ptr_nsresult())) = std::move((aRhs).get_nsresult());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetPreprocessResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse;
            }
            (*(ptr_ObjectStoreGetPreprocessResponse())) = std::move((aRhs).get_ObjectStoreGetPreprocessResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TObjectStoreGetAllPreprocessResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse;
            }
            (*(ptr_ObjectStoreGetAllPreprocessResponse())) = std::move((aRhs).get_ObjectStoreGetAllPreprocessResponse());
            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 PreprocessResponse::operator==(const nsresult& aRhs) const -> bool
{
    return (get_nsresult()) == (aRhs);
}

auto PreprocessResponse::operator==(const ObjectStoreGetPreprocessResponse& aRhs) const -> bool
{
    return (get_ObjectStoreGetPreprocessResponse()) == (aRhs);
}

auto PreprocessResponse::operator==(const ObjectStoreGetAllPreprocessResponse& aRhs) const -> bool
{
    return (get_ObjectStoreGetAllPreprocessResponse()) == (aRhs);
}

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

    switch (type()) {
    case Tnsresult:
        {
            return (get_nsresult()) == ((aRhs).get_nsresult());
        }
    case TObjectStoreGetPreprocessResponse:
        {
            return (get_ObjectStoreGetPreprocessResponse()) == ((aRhs).get_ObjectStoreGetPreprocessResponse());
        }
    case TObjectStoreGetAllPreprocessResponse:
        {
            return (get_ObjectStoreGetAllPreprocessResponse()) == ((aRhs).get_ObjectStoreGetAllPreprocessResponse());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto PreprocessResponse::get(nsresult* aOutValue) const -> void
{
    (*(aOutValue)) = get_nsresult();
}

auto PreprocessResponse::get(ObjectStoreGetPreprocessResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStoreGetPreprocessResponse();
}

auto PreprocessResponse::get(ObjectStoreGetAllPreprocessResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ObjectStoreGetAllPreprocessResponse();
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tnsresult:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aMsg)->WriteSentinel(2293764539);
            return;
        }
    case union__::TObjectStoreGetPreprocessResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStoreGetPreprocessResponse());
            // Sentinel = 'TObjectStoreGetPreprocessResponse'
            (aMsg)->WriteSentinel(1639037426);
            return;
        }
    case union__::TObjectStoreGetAllPreprocessResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ObjectStoreGetAllPreprocessResponse());
            // Sentinel = 'TObjectStoreGetAllPreprocessResponse'
            (aMsg)->WriteSentinel(3240591322);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::Tnsresult:
        {
            nsresult tmp = nsresult();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_nsresult())))))) {
                (aActor)->FatalError("Error deserializing variant Tnsresult of union PreprocessResponse");
                return false;
            }
            // Sentinel = 'Tnsresult'
            if ((!((aMsg)->ReadSentinel(aIter, 2293764539)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union PreprocessResponse");
                return false;
            }
            return true;
        }
    case union__::TObjectStoreGetPreprocessResponse:
        {
            mozilla::dom::indexedDB::ObjectStoreGetPreprocessResponse tmp = mozilla::dom::indexedDB::ObjectStoreGetPreprocessResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStoreGetPreprocessResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStoreGetPreprocessResponse of union PreprocessResponse");
                return false;
            }
            // Sentinel = 'TObjectStoreGetPreprocessResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 1639037426)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetPreprocessResponse of union PreprocessResponse");
                return false;
            }
            return true;
        }
    case union__::TObjectStoreGetAllPreprocessResponse:
        {
            mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessResponse tmp = mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ObjectStoreGetAllPreprocessResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TObjectStoreGetAllPreprocessResponse of union PreprocessResponse");
                return false;
            }
            // Sentinel = 'TObjectStoreGetAllPreprocessResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 3240591322)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetAllPreprocessResponse of union PreprocessResponse");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53