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

#ifndef PBackgroundSDBRequest_h
#define PBackgroundSDBRequest_h

#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"

// Headers for typedefs
#include "mozilla/ipc/IPDLStructMember.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SDBRequestOpenResponse|
//
namespace mozilla {
namespace dom {
class SDBRequestOpenResponse final
{
private:

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    SDBRequestOpenResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

private:
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::SDBRequestOpenResponse>
{
    typedef ::mozilla::dom::SDBRequestOpenResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SDBRequestSeekResponse|
//
namespace mozilla {
namespace dom {
class SDBRequestSeekResponse final
{
private:

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    SDBRequestSeekResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

private:
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::SDBRequestSeekResponse>
{
    typedef ::mozilla::dom::SDBRequestSeekResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SDBRequestReadResponse|
//
namespace mozilla {
namespace dom {
class SDBRequestReadResponse final
{
private:
    typedef ::nsCString nsCString;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    SDBRequestReadResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT SDBRequestReadResponse(const nsCString& _data) :
        data_(_data)
    {
    }

    MOZ_IMPLICIT SDBRequestReadResponse(nsCString&& _data) :
        data_(std::move(_data))
    {
    }

    nsCString&
    data()
    {
        return data_;
    }
    const nsCString&
    data() const
    {
        return data_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> data_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::SDBRequestReadResponse>
{
    typedef ::mozilla::dom::SDBRequestReadResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SDBRequestWriteResponse|
//
namespace mozilla {
namespace dom {
class SDBRequestWriteResponse final
{
private:

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    SDBRequestWriteResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

private:
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::SDBRequestWriteResponse>
{
    typedef ::mozilla::dom::SDBRequestWriteResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SDBRequestCloseResponse|
//
namespace mozilla {
namespace dom {
class SDBRequestCloseResponse final
{
private:

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    SDBRequestCloseResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

private:
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::SDBRequestCloseResponse>
{
    typedef ::mozilla::dom::SDBRequestCloseResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union SDBRequestResponse|
//
namespace mozilla {
namespace dom {
class SDBRequestResponse final
{
public:
    enum Type {
        T__None,
        Tnsresult = 1,
        TSDBRequestOpenResponse,
        TSDBRequestSeekResponse,
        TSDBRequestReadResponse,
        TSDBRequestWriteResponse,
        TSDBRequestCloseResponse,
        T__Last = TSDBRequestCloseResponse
    };

private:
    typedef ::nsresult nsresult;
    typedef ::mozilla::dom::SDBRequestOpenResponse SDBRequestOpenResponse;
    typedef ::mozilla::dom::SDBRequestSeekResponse SDBRequestSeekResponse;
    typedef ::mozilla::dom::SDBRequestReadResponse SDBRequestReadResponse;
    typedef ::mozilla::dom::SDBRequestWriteResponse SDBRequestWriteResponse;
    typedef ::mozilla::dom::SDBRequestCloseResponse SDBRequestCloseResponse;
    typedef nsresult nsresult__tdef;
    typedef SDBRequestOpenResponse SDBRequestOpenResponse__tdef;
    typedef SDBRequestSeekResponse SDBRequestSeekResponse__tdef;
    typedef SDBRequestReadResponse SDBRequestReadResponse__tdef;
    typedef SDBRequestWriteResponse SDBRequestWriteResponse__tdef;
    typedef SDBRequestCloseResponse SDBRequestCloseResponse__tdef;

    nsresult*
    ptr_nsresult()
    {
        return (&(mVnsresult));
    }
    const nsresult*
    constptr_nsresult() const
    {
        return (&(mVnsresult));
    }
    SDBRequestOpenResponse*
    ptr_SDBRequestOpenResponse()
    {
        return (&(mVSDBRequestOpenResponse));
    }
    const SDBRequestOpenResponse*
    constptr_SDBRequestOpenResponse() const
    {
        return (&(mVSDBRequestOpenResponse));
    }
    SDBRequestSeekResponse*
    ptr_SDBRequestSeekResponse()
    {
        return (&(mVSDBRequestSeekResponse));
    }
    const SDBRequestSeekResponse*
    constptr_SDBRequestSeekResponse() const
    {
        return (&(mVSDBRequestSeekResponse));
    }
    SDBRequestReadResponse*
    ptr_SDBRequestReadResponse()
    {
        return (&(mVSDBRequestReadResponse));
    }
    const SDBRequestReadResponse*
    constptr_SDBRequestReadResponse() const
    {
        return (&(mVSDBRequestReadResponse));
    }
    SDBRequestWriteResponse*
    ptr_SDBRequestWriteResponse()
    {
        return (&(mVSDBRequestWriteResponse));
    }
    const SDBRequestWriteResponse*
    constptr_SDBRequestWriteResponse() const
    {
        return (&(mVSDBRequestWriteResponse));
    }
    SDBRequestCloseResponse*
    ptr_SDBRequestCloseResponse()
    {
        return (&(mVSDBRequestCloseResponse));
    }
    const SDBRequestCloseResponse*
    constptr_SDBRequestCloseResponse() const
    {
        return (&(mVSDBRequestCloseResponse));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT SDBRequestResponse() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT SDBRequestResponse(const nsresult& aOther);

    MOZ_IMPLICIT SDBRequestResponse(nsresult&& aOther);

    MOZ_IMPLICIT SDBRequestResponse(const SDBRequestOpenResponse& aOther);

    MOZ_IMPLICIT SDBRequestResponse(SDBRequestOpenResponse&& aOther);

    MOZ_IMPLICIT SDBRequestResponse(const SDBRequestSeekResponse& aOther);

    MOZ_IMPLICIT SDBRequestResponse(SDBRequestSeekResponse&& aOther);

    MOZ_IMPLICIT SDBRequestResponse(const SDBRequestReadResponse& aOther);

    MOZ_IMPLICIT SDBRequestResponse(SDBRequestReadResponse&& aOther);

    MOZ_IMPLICIT SDBRequestResponse(const SDBRequestWriteResponse& aOther);

    MOZ_IMPLICIT SDBRequestResponse(SDBRequestWriteResponse&& aOther);

    MOZ_IMPLICIT SDBRequestResponse(const SDBRequestCloseResponse& aOther);

    MOZ_IMPLICIT SDBRequestResponse(SDBRequestCloseResponse&& aOther);

    MOZ_IMPLICIT SDBRequestResponse(const SDBRequestResponse& aOther);

    MOZ_IMPLICIT SDBRequestResponse(SDBRequestResponse&& aOther);

    ~SDBRequestResponse();

    Type
    type() const
    {
        return mType;
    }

    SDBRequestResponse&
    operator=(const nsresult& aRhs);

    SDBRequestResponse&
    operator=(nsresult&& aRhs);

    SDBRequestResponse&
    operator=(const SDBRequestOpenResponse& aRhs);

    SDBRequestResponse&
    operator=(SDBRequestOpenResponse&& aRhs);

    SDBRequestResponse&
    operator=(const SDBRequestSeekResponse& aRhs);

    SDBRequestResponse&
    operator=(SDBRequestSeekResponse&& aRhs);

    SDBRequestResponse&
    operator=(const SDBRequestReadResponse& aRhs);

    SDBRequestResponse&
    operator=(SDBRequestReadResponse&& aRhs);

    SDBRequestResponse&
    operator=(const SDBRequestWriteResponse& aRhs);

    SDBRequestResponse&
    operator=(SDBRequestWriteResponse&& aRhs);

    SDBRequestResponse&
    operator=(const SDBRequestCloseResponse& aRhs);

    SDBRequestResponse&
    operator=(SDBRequestCloseResponse&& aRhs);

    SDBRequestResponse&
    operator=(const SDBRequestResponse& aRhs);

    SDBRequestResponse&
    operator=(SDBRequestResponse&& aRhs);

    nsresult&
    get_nsresult()
    {
        AssertSanity(Tnsresult);
        return (*(ptr_nsresult()));
    }
    const nsresult&
    get_nsresult() const
    {
        AssertSanity(Tnsresult);
        return (*(constptr_nsresult()));
    }
    operator nsresult&()
    {
        return get_nsresult();
    }
    operator const nsresult&() const
    {
        return get_nsresult();
    }

    SDBRequestOpenResponse&
    get_SDBRequestOpenResponse()
    {
        AssertSanity(TSDBRequestOpenResponse);
        return (*(ptr_SDBRequestOpenResponse()));
    }
    const SDBRequestOpenResponse&
    get_SDBRequestOpenResponse() const
    {
        AssertSanity(TSDBRequestOpenResponse);
        return (*(constptr_SDBRequestOpenResponse()));
    }
    operator SDBRequestOpenResponse&()
    {
        return get_SDBRequestOpenResponse();
    }
    operator const SDBRequestOpenResponse&() const
    {
        return get_SDBRequestOpenResponse();
    }

    SDBRequestSeekResponse&
    get_SDBRequestSeekResponse()
    {
        AssertSanity(TSDBRequestSeekResponse);
        return (*(ptr_SDBRequestSeekResponse()));
    }
    const SDBRequestSeekResponse&
    get_SDBRequestSeekResponse() const
    {
        AssertSanity(TSDBRequestSeekResponse);
        return (*(constptr_SDBRequestSeekResponse()));
    }
    operator SDBRequestSeekResponse&()
    {
        return get_SDBRequestSeekResponse();
    }
    operator const SDBRequestSeekResponse&() const
    {
        return get_SDBRequestSeekResponse();
    }

    SDBRequestReadResponse&
    get_SDBRequestReadResponse()
    {
        AssertSanity(TSDBRequestReadResponse);
        return (*(ptr_SDBRequestReadResponse()));
    }
    const SDBRequestReadResponse&
    get_SDBRequestReadResponse() const
    {
        AssertSanity(TSDBRequestReadResponse);
        return (*(constptr_SDBRequestReadResponse()));
    }
    operator SDBRequestReadResponse&()
    {
        return get_SDBRequestReadResponse();
    }
    operator const SDBRequestReadResponse&() const
    {
        return get_SDBRequestReadResponse();
    }

    SDBRequestWriteResponse&
    get_SDBRequestWriteResponse()
    {
        AssertSanity(TSDBRequestWriteResponse);
        return (*(ptr_SDBRequestWriteResponse()));
    }
    const SDBRequestWriteResponse&
    get_SDBRequestWriteResponse() const
    {
        AssertSanity(TSDBRequestWriteResponse);
        return (*(constptr_SDBRequestWriteResponse()));
    }
    operator SDBRequestWriteResponse&()
    {
        return get_SDBRequestWriteResponse();
    }
    operator const SDBRequestWriteResponse&() const
    {
        return get_SDBRequestWriteResponse();
    }

    SDBRequestCloseResponse&
    get_SDBRequestCloseResponse()
    {
        AssertSanity(TSDBRequestCloseResponse);
        return (*(ptr_SDBRequestCloseResponse()));
    }
    const SDBRequestCloseResponse&
    get_SDBRequestCloseResponse() const
    {
        AssertSanity(TSDBRequestCloseResponse);
        return (*(constptr_SDBRequestCloseResponse()));
    }
    operator SDBRequestCloseResponse&()
    {
        return get_SDBRequestCloseResponse();
    }
    operator const SDBRequestCloseResponse&() const
    {
        return get_SDBRequestCloseResponse();
    }

private:
    union {
        nsresult mVnsresult;
        SDBRequestOpenResponse mVSDBRequestOpenResponse;
        SDBRequestSeekResponse mVSDBRequestSeekResponse;
        SDBRequestReadResponse mVSDBRequestReadResponse;
        SDBRequestWriteResponse mVSDBRequestWriteResponse;
        SDBRequestCloseResponse mVSDBRequestCloseResponse;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::SDBRequestResponse>
{
    typedef ::mozilla::dom::SDBRequestResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC

namespace mozilla {
namespace dom {
class PBackgroundSDBRequestParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PBackgroundSDBRequestChild;
} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Code common to PBackgroundSDBRequestChild and PBackgroundSDBRequestParent
//
namespace mozilla {
namespace dom {
namespace PBackgroundSDBRequest {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::dom::PBackgroundSDBRequestParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::PBackgroundSDBRequestChild>* aChild);

enum MessageType {
    PBackgroundSDBRequestStart = PBackgroundSDBRequestMsgStart << 16,
    Msg___delete____ID,
    Reply___delete____ID,
    PBackgroundSDBRequestEnd
};

mozilla::UniquePtr<IPC::Message>
Msg___delete__(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(IPC::Message::routeid_t routingId);



} // namespace PBackgroundSDBRequest
} // namespace dom
} // namespace mozilla

#endif // ifndef PBackgroundSDBRequest_h
