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

#ifndef IPCBlob_h
#define IPCBlob_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/RemoteLazyInputStream.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/ipc/IPCStream.h"
#include "mozilla/ipc/ProtocolTypes.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union RemoteLazyStream|
//
namespace mozilla {
class RemoteLazyStream final
{
public:
    enum Type {
        T__None,
        TRemoteLazyInputStream = 1,
        TIPCStream,
        T__Last = TIPCStream
    };

private:
    typedef ::mozilla::RemoteLazyInputStream RemoteLazyInputStream;
    typedef ::mozilla::ipc::IPCStream IPCStream;
    typedef RefPtr<RemoteLazyInputStream> RemoteLazyInputStream__tdef;
    typedef IPCStream IPCStream__tdef;

    RefPtr<RemoteLazyInputStream>*
    ptr_RemoteLazyInputStream()
    {
        return (&(mVRemoteLazyInputStream));
    }
    const RefPtr<RemoteLazyInputStream>*
    constptr_RemoteLazyInputStream() const
    {
        return (&(mVRemoteLazyInputStream));
    }
    IPCStream*
    ptr_IPCStream()
    {
        return (&(mVIPCStream));
    }
    const IPCStream*
    constptr_IPCStream() const
    {
        return (&(mVIPCStream));
    }

    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 RemoteLazyStream() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT RemoteLazyStream(RemoteLazyInputStream* aOther);

    MOZ_IMPLICIT RemoteLazyStream(RefPtr<RemoteLazyInputStream>&& aOther);

    MOZ_IMPLICIT RemoteLazyStream(const IPCStream& aOther);

    MOZ_IMPLICIT RemoteLazyStream(IPCStream&& aOther);

    MOZ_IMPLICIT RemoteLazyStream(const RemoteLazyStream& aOther);

    MOZ_IMPLICIT RemoteLazyStream(RemoteLazyStream&& aOther);

    ~RemoteLazyStream();

    Type
    type() const
    {
        return mType;
    }

    RemoteLazyStream&
    operator=(RemoteLazyInputStream* aRhs);

    RemoteLazyStream&
    operator=(RefPtr<RemoteLazyInputStream>&& aRhs);

    RemoteLazyStream&
    operator=(const IPCStream& aRhs);

    RemoteLazyStream&
    operator=(IPCStream&& aRhs);

    RemoteLazyStream&
    operator=(const RemoteLazyStream& aRhs);

    RemoteLazyStream&
    operator=(RemoteLazyStream&& aRhs);

    RefPtr<RemoteLazyInputStream>&
    get_RemoteLazyInputStream()
    {
        AssertSanity(TRemoteLazyInputStream);
        return (*(ptr_RemoteLazyInputStream()));
    }
    RemoteLazyInputStream*
    get_RemoteLazyInputStream() const
    {
        AssertSanity(TRemoteLazyInputStream);
        return (*(constptr_RemoteLazyInputStream()));
    }
    operator RefPtr<RemoteLazyInputStream>&()
    {
        return get_RemoteLazyInputStream();
    }
    operator RemoteLazyInputStream*() const
    {
        return get_RemoteLazyInputStream();
    }

    IPCStream&
    get_IPCStream()
    {
        AssertSanity(TIPCStream);
        return (*(ptr_IPCStream()));
    }
    const IPCStream&
    get_IPCStream() const
    {
        AssertSanity(TIPCStream);
        return (*(constptr_IPCStream()));
    }
    operator IPCStream&()
    {
        return get_IPCStream();
    }
    operator const IPCStream&() const
    {
        return get_IPCStream();
    }

private:
    union {
        RefPtr<RemoteLazyInputStream> mVRemoteLazyInputStream;
        IPCStream mVIPCStream;
    };
    Type mType;
};
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::RemoteLazyStream>
{
    typedef ::mozilla::RemoteLazyStream 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 IPCFile|
//
namespace mozilla {
namespace dom {
class IPCFile final
{
private:
    typedef ::nsString nsString;
    typedef ::int64_t int64_t;

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

    MOZ_IMPLICIT IPCFile(
            const nsString& _name,
            const int64_t& _lastModified,
            const nsString& _DOMPath,
            const nsString& _fullPath,
            const bool& _isDirectory) :
        name_(_name),
        DOMPath_(_DOMPath),
        fullPath_(_fullPath),
        isDirectory_(_isDirectory),
        lastModified_(_lastModified)
    {
    }

    MOZ_IMPLICIT IPCFile(
            nsString&& _name,
            int64_t&& _lastModified,
            nsString&& _DOMPath,
            nsString&& _fullPath,
            bool&& _isDirectory) :
        name_(std::move(_name)),
        DOMPath_(std::move(_DOMPath)),
        fullPath_(std::move(_fullPath)),
        isDirectory_(std::move(_isDirectory)),
        lastModified_(std::move(_lastModified))
    {
    }

    nsString&
    name()
    {
        return name_;
    }
    const nsString&
    name() const
    {
        return name_;
    }

    int64_t&
    lastModified()
    {
        return lastModified_;
    }
    const int64_t&
    lastModified() const
    {
        return lastModified_;
    }

    nsString&
    DOMPath()
    {
        return DOMPath_;
    }
    const nsString&
    DOMPath() const
    {
        return DOMPath_;
    }

    nsString&
    fullPath()
    {
        return fullPath_;
    }
    const nsString&
    fullPath() const
    {
        return fullPath_;
    }

    bool&
    isDirectory()
    {
        return isDirectory_;
    }
    const bool&
    isDirectory() const
    {
        return isDirectory_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> name_;
    ::mozilla::ipc::IPDLStructMember<nsString> DOMPath_;
    ::mozilla::ipc::IPDLStructMember<nsString> fullPath_;
    ::mozilla::ipc::IPDLStructMember<bool> isDirectory_;
    ::mozilla::ipc::IPDLStructMember<int64_t> lastModified_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCFile>
{
    typedef ::mozilla::dom::IPCFile 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 IPCBlob|
//
namespace mozilla {
namespace dom {
class IPCBlob final
{
private:
    typedef ::nsString nsString;
    typedef ::uint64_t uint64_t;
    typedef ::mozilla::RemoteLazyStream RemoteLazyStream;
    typedef ::mozilla::dom::IPCFile IPCFile;
    typedef ::int64_t int64_t;

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

    MOZ_IMPLICIT IPCBlob(
            const nsString& _type,
            const uint64_t& _size,
            const nsString& _blobImplType,
            const RemoteLazyStream& _inputStream,
            const mozilla::Maybe<IPCFile>& _file,
            const int64_t& _fileId) :
        type_(_type),
        blobImplType_(_blobImplType),
        inputStream_(_inputStream),
        file_(_file),
        size_(_size),
        fileId_(_fileId)
    {
    }

    MOZ_IMPLICIT IPCBlob(
            nsString&& _type,
            uint64_t&& _size,
            nsString&& _blobImplType,
            RemoteLazyStream&& _inputStream,
            mozilla::Maybe<IPCFile>&& _file,
            int64_t&& _fileId) :
        type_(std::move(_type)),
        blobImplType_(std::move(_blobImplType)),
        inputStream_(std::move(_inputStream)),
        file_(std::move(_file)),
        size_(std::move(_size)),
        fileId_(std::move(_fileId))
    {
    }

    nsString&
    type()
    {
        return type_;
    }
    const nsString&
    type() const
    {
        return type_;
    }

    uint64_t&
    size()
    {
        return size_;
    }
    const uint64_t&
    size() const
    {
        return size_;
    }

    nsString&
    blobImplType()
    {
        return blobImplType_;
    }
    const nsString&
    blobImplType() const
    {
        return blobImplType_;
    }

    RemoteLazyStream&
    inputStream()
    {
        return inputStream_;
    }
    const RemoteLazyStream&
    inputStream() const
    {
        return inputStream_;
    }

    mozilla::Maybe<IPCFile>&
    file()
    {
        return file_;
    }
    const mozilla::Maybe<IPCFile>&
    file() const
    {
        return file_;
    }

    int64_t&
    fileId()
    {
        return fileId_;
    }
    const int64_t&
    fileId() const
    {
        return fileId_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<nsString> type_;
    ::mozilla::ipc::IPDLStructMember<nsString> blobImplType_;
    ::mozilla::ipc::IPDLStructMember<RemoteLazyStream> inputStream_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCFile>> file_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> size_;
    ::mozilla::ipc::IPDLStructMember<int64_t> fileId_;
};
} // namespace dom
} // namespace mozilla

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

#endif // ifndef IPCBlob_h
