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

#ifndef RandomAccessStreamParams_h
#define RandomAccessStreamParams_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"
#include "mozilla/dom/quota/IPCQuotaObject.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct FileRandomAccessStreamParams|
//
namespace mozilla {
namespace ipc {
class FileRandomAccessStreamParams final
{
private:
    typedef ::mozilla::ipc::FileDescriptor FileDescriptor;
    typedef ::int32_t int32_t;

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

    MOZ_IMPLICIT FileRandomAccessStreamParams(
            const FileDescriptor& _fileDescriptor,
            const int32_t& _behaviorFlags) :
        fileDescriptor_(_fileDescriptor),
        behaviorFlags_(_behaviorFlags)
    {
    }

    MOZ_IMPLICIT FileRandomAccessStreamParams(
            FileDescriptor&& _fileDescriptor,
            int32_t&& _behaviorFlags) :
        fileDescriptor_(std::move(_fileDescriptor)),
        behaviorFlags_(std::move(_behaviorFlags))
    {
    }

    FileDescriptor&
    fileDescriptor()
    {
        return fileDescriptor_;
    }
    const FileDescriptor&
    fileDescriptor() const
    {
        return fileDescriptor_;
    }

    int32_t&
    behaviorFlags()
    {
        return behaviorFlags_;
    }
    const int32_t&
    behaviorFlags() const
    {
        return behaviorFlags_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<FileDescriptor> fileDescriptor_;
    ::mozilla::ipc::IPDLStructMember<int32_t> behaviorFlags_;
};
} // namespace ipc
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::FileRandomAccessStreamParams>
{
    typedef ::mozilla::ipc::FileRandomAccessStreamParams 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 LimitingFileRandomAccessStreamParams|
//
namespace mozilla {
namespace ipc {
class LimitingFileRandomAccessStreamParams final
{
private:
    typedef ::mozilla::ipc::FileRandomAccessStreamParams FileRandomAccessStreamParams;
    typedef ::mozilla::dom::quota::IPCQuotaObject IPCQuotaObject;

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

    MOZ_IMPLICIT LimitingFileRandomAccessStreamParams(
            const FileRandomAccessStreamParams& _fileRandomAccessStreamParams,
            IPCQuotaObject&& _quotaObject) :
        fileRandomAccessStreamParams_(_fileRandomAccessStreamParams),
        quotaObject_(std::move(_quotaObject))
    {
    }

    MOZ_IMPLICIT LimitingFileRandomAccessStreamParams(
            FileRandomAccessStreamParams&& _fileRandomAccessStreamParams,
            IPCQuotaObject&& _quotaObject) :
        fileRandomAccessStreamParams_(std::move(_fileRandomAccessStreamParams)),
        quotaObject_(std::move(_quotaObject))
    {
    }

    FileRandomAccessStreamParams&
    fileRandomAccessStreamParams()
    {
        return fileRandomAccessStreamParams_;
    }
    const FileRandomAccessStreamParams&
    fileRandomAccessStreamParams() const
    {
        return fileRandomAccessStreamParams_;
    }

    IPCQuotaObject&
    quotaObject()
    {
        return quotaObject_;
    }
    const IPCQuotaObject&
    quotaObject() const
    {
        return quotaObject_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<FileRandomAccessStreamParams> fileRandomAccessStreamParams_;
    ::mozilla::ipc::IPDLStructMember<IPCQuotaObject> quotaObject_;
};
} // namespace ipc
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union RandomAccessStreamParams|
//
namespace mozilla {
namespace ipc {
class RandomAccessStreamParams final
{
public:
    enum Type {
        T__None,
        TFileRandomAccessStreamParams = 1,
        TLimitingFileRandomAccessStreamParams,
        T__Last = TLimitingFileRandomAccessStreamParams
    };

private:
    typedef ::mozilla::ipc::FileRandomAccessStreamParams FileRandomAccessStreamParams;
    typedef ::mozilla::ipc::LimitingFileRandomAccessStreamParams LimitingFileRandomAccessStreamParams;
    typedef FileRandomAccessStreamParams FileRandomAccessStreamParams__tdef;
    typedef LimitingFileRandomAccessStreamParams LimitingFileRandomAccessStreamParams__tdef;

    FileRandomAccessStreamParams*
    ptr_FileRandomAccessStreamParams()
    {
        return (&(mVFileRandomAccessStreamParams));
    }
    const FileRandomAccessStreamParams*
    constptr_FileRandomAccessStreamParams() const
    {
        return (&(mVFileRandomAccessStreamParams));
    }
    LimitingFileRandomAccessStreamParams*
    ptr_LimitingFileRandomAccessStreamParams()
    {
        return (&(mVLimitingFileRandomAccessStreamParams));
    }
    const LimitingFileRandomAccessStreamParams*
    constptr_LimitingFileRandomAccessStreamParams() const
    {
        return (&(mVLimitingFileRandomAccessStreamParams));
    }

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

    MOZ_IMPLICIT RandomAccessStreamParams(const FileRandomAccessStreamParams& aOther);

    MOZ_IMPLICIT RandomAccessStreamParams(FileRandomAccessStreamParams&& aOther);

    MOZ_IMPLICIT RandomAccessStreamParams(LimitingFileRandomAccessStreamParams&& aOther);

    MOZ_IMPLICIT RandomAccessStreamParams(RandomAccessStreamParams&& aOther);

    ~RandomAccessStreamParams();

    Type
    type() const
    {
        return mType;
    }

    RandomAccessStreamParams&
    operator=(const FileRandomAccessStreamParams& aRhs);

    RandomAccessStreamParams&
    operator=(FileRandomAccessStreamParams&& aRhs);

    RandomAccessStreamParams&
    operator=(LimitingFileRandomAccessStreamParams&& aRhs);

    RandomAccessStreamParams&
    operator=(RandomAccessStreamParams&& aRhs);

    FileRandomAccessStreamParams&
    get_FileRandomAccessStreamParams()
    {
        AssertSanity(TFileRandomAccessStreamParams);
        return (*(ptr_FileRandomAccessStreamParams()));
    }
    const FileRandomAccessStreamParams&
    get_FileRandomAccessStreamParams() const
    {
        AssertSanity(TFileRandomAccessStreamParams);
        return (*(constptr_FileRandomAccessStreamParams()));
    }
    operator FileRandomAccessStreamParams&()
    {
        return get_FileRandomAccessStreamParams();
    }
    operator const FileRandomAccessStreamParams&() const
    {
        return get_FileRandomAccessStreamParams();
    }

    LimitingFileRandomAccessStreamParams&
    get_LimitingFileRandomAccessStreamParams()
    {
        AssertSanity(TLimitingFileRandomAccessStreamParams);
        return (*(ptr_LimitingFileRandomAccessStreamParams()));
    }
    const LimitingFileRandomAccessStreamParams&
    get_LimitingFileRandomAccessStreamParams() const
    {
        AssertSanity(TLimitingFileRandomAccessStreamParams);
        return (*(constptr_LimitingFileRandomAccessStreamParams()));
    }
    operator LimitingFileRandomAccessStreamParams&()
    {
        return get_LimitingFileRandomAccessStreamParams();
    }
    operator const LimitingFileRandomAccessStreamParams&() const
    {
        return get_LimitingFileRandomAccessStreamParams();
    }

private:
    union {
        FileRandomAccessStreamParams mVFileRandomAccessStreamParams;
        LimitingFileRandomAccessStreamParams mVLimitingFileRandomAccessStreamParams;
    };
    Type mType;
};
} // namespace ipc
} // namespace mozilla

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

#endif // ifndef RandomAccessStreamParams_h
