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

#ifndef PFileSystemParams_h
#define PFileSystemParams_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 FileSystemGetDirectoryListingParams|
//
namespace mozilla {
namespace dom {
class FileSystemGetDirectoryListingParams final
{
private:
    typedef ::nsString nsString;

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

    MOZ_IMPLICIT FileSystemGetDirectoryListingParams(
            const nsString& _filesystem,
            const nsString& _realPath,
            const nsString& _domPath,
            const nsString& _filters) :
        filesystem_(_filesystem),
        realPath_(_realPath),
        domPath_(_domPath),
        filters_(_filters)
    {
    }

    MOZ_IMPLICIT FileSystemGetDirectoryListingParams(
            nsString&& _filesystem,
            nsString&& _realPath,
            nsString&& _domPath,
            nsString&& _filters) :
        filesystem_(std::move(_filesystem)),
        realPath_(std::move(_realPath)),
        domPath_(std::move(_domPath)),
        filters_(std::move(_filters))
    {
    }

    nsString&
    filesystem()
    {
        return filesystem_;
    }
    const nsString&
    filesystem() const
    {
        return filesystem_;
    }

    nsString&
    realPath()
    {
        return realPath_;
    }
    const nsString&
    realPath() const
    {
        return realPath_;
    }

    nsString&
    domPath()
    {
        return domPath_;
    }
    const nsString&
    domPath() const
    {
        return domPath_;
    }

    nsString&
    filters()
    {
        return filters_;
    }
    const nsString&
    filters() const
    {
        return filters_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> filesystem_;
    ::mozilla::ipc::IPDLStructMember<nsString> realPath_;
    ::mozilla::ipc::IPDLStructMember<nsString> domPath_;
    ::mozilla::ipc::IPDLStructMember<nsString> filters_;
};
} // namespace dom
} // namespace mozilla

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

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

    MOZ_IMPLICIT FileSystemGetFilesParams(
            const nsString& _filesystem,
            const nsString& _realPath,
            const nsString& _domPath,
            const bool& _recursiveFlag) :
        filesystem_(_filesystem),
        realPath_(_realPath),
        domPath_(_domPath),
        recursiveFlag_(_recursiveFlag)
    {
    }

    MOZ_IMPLICIT FileSystemGetFilesParams(
            nsString&& _filesystem,
            nsString&& _realPath,
            nsString&& _domPath,
            bool&& _recursiveFlag) :
        filesystem_(std::move(_filesystem)),
        realPath_(std::move(_realPath)),
        domPath_(std::move(_domPath)),
        recursiveFlag_(std::move(_recursiveFlag))
    {
    }

    nsString&
    filesystem()
    {
        return filesystem_;
    }
    const nsString&
    filesystem() const
    {
        return filesystem_;
    }

    nsString&
    realPath()
    {
        return realPath_;
    }
    const nsString&
    realPath() const
    {
        return realPath_;
    }

    nsString&
    domPath()
    {
        return domPath_;
    }
    const nsString&
    domPath() const
    {
        return domPath_;
    }

    bool&
    recursiveFlag()
    {
        return recursiveFlag_;
    }
    const bool&
    recursiveFlag() const
    {
        return recursiveFlag_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> filesystem_;
    ::mozilla::ipc::IPDLStructMember<nsString> realPath_;
    ::mozilla::ipc::IPDLStructMember<nsString> domPath_;
    ::mozilla::ipc::IPDLStructMember<bool> recursiveFlag_;
};
} // namespace dom
} // namespace mozilla

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

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

    MOZ_IMPLICIT FileSystemGetFileOrDirectoryParams(
            const nsString& _filesystem,
            const nsString& _realPath) :
        filesystem_(_filesystem),
        realPath_(_realPath)
    {
    }

    MOZ_IMPLICIT FileSystemGetFileOrDirectoryParams(
            nsString&& _filesystem,
            nsString&& _realPath) :
        filesystem_(std::move(_filesystem)),
        realPath_(std::move(_realPath))
    {
    }

    nsString&
    filesystem()
    {
        return filesystem_;
    }
    const nsString&
    filesystem() const
    {
        return filesystem_;
    }

    nsString&
    realPath()
    {
        return realPath_;
    }
    const nsString&
    realPath() const
    {
        return realPath_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> filesystem_;
    ::mozilla::ipc::IPDLStructMember<nsString> realPath_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::FileSystemGetFileOrDirectoryParams>
{
    typedef ::mozilla::dom::FileSystemGetFileOrDirectoryParams 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 FileSystemParams|
//
namespace mozilla {
namespace dom {
class FileSystemParams final
{
public:
    enum Type {
        T__None,
        TFileSystemGetDirectoryListingParams = 1,
        TFileSystemGetFilesParams,
        TFileSystemGetFileOrDirectoryParams,
        T__Last = TFileSystemGetFileOrDirectoryParams
    };

private:
    typedef ::mozilla::dom::FileSystemGetDirectoryListingParams FileSystemGetDirectoryListingParams;
    typedef ::mozilla::dom::FileSystemGetFilesParams FileSystemGetFilesParams;
    typedef ::mozilla::dom::FileSystemGetFileOrDirectoryParams FileSystemGetFileOrDirectoryParams;
    typedef FileSystemGetDirectoryListingParams FileSystemGetDirectoryListingParams__tdef;
    typedef FileSystemGetFilesParams FileSystemGetFilesParams__tdef;
    typedef FileSystemGetFileOrDirectoryParams FileSystemGetFileOrDirectoryParams__tdef;

    FileSystemGetDirectoryListingParams*
    ptr_FileSystemGetDirectoryListingParams()
    {
        return (&(mVFileSystemGetDirectoryListingParams));
    }
    const FileSystemGetDirectoryListingParams*
    constptr_FileSystemGetDirectoryListingParams() const
    {
        return (&(mVFileSystemGetDirectoryListingParams));
    }
    FileSystemGetFilesParams*
    ptr_FileSystemGetFilesParams()
    {
        return (&(mVFileSystemGetFilesParams));
    }
    const FileSystemGetFilesParams*
    constptr_FileSystemGetFilesParams() const
    {
        return (&(mVFileSystemGetFilesParams));
    }
    FileSystemGetFileOrDirectoryParams*
    ptr_FileSystemGetFileOrDirectoryParams()
    {
        return (&(mVFileSystemGetFileOrDirectoryParams));
    }
    const FileSystemGetFileOrDirectoryParams*
    constptr_FileSystemGetFileOrDirectoryParams() const
    {
        return (&(mVFileSystemGetFileOrDirectoryParams));
    }

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

    MOZ_IMPLICIT FileSystemParams(const FileSystemGetDirectoryListingParams& aOther);

    MOZ_IMPLICIT FileSystemParams(FileSystemGetDirectoryListingParams&& aOther);

    MOZ_IMPLICIT FileSystemParams(const FileSystemGetFilesParams& aOther);

    MOZ_IMPLICIT FileSystemParams(FileSystemGetFilesParams&& aOther);

    MOZ_IMPLICIT FileSystemParams(const FileSystemGetFileOrDirectoryParams& aOther);

    MOZ_IMPLICIT FileSystemParams(FileSystemGetFileOrDirectoryParams&& aOther);

    MOZ_IMPLICIT FileSystemParams(const FileSystemParams& aOther);

    MOZ_IMPLICIT FileSystemParams(FileSystemParams&& aOther);

    ~FileSystemParams();

    Type
    type() const
    {
        return mType;
    }

    FileSystemParams&
    operator=(const FileSystemGetDirectoryListingParams& aRhs);

    FileSystemParams&
    operator=(FileSystemGetDirectoryListingParams&& aRhs);

    FileSystemParams&
    operator=(const FileSystemGetFilesParams& aRhs);

    FileSystemParams&
    operator=(FileSystemGetFilesParams&& aRhs);

    FileSystemParams&
    operator=(const FileSystemGetFileOrDirectoryParams& aRhs);

    FileSystemParams&
    operator=(FileSystemGetFileOrDirectoryParams&& aRhs);

    FileSystemParams&
    operator=(const FileSystemParams& aRhs);

    FileSystemParams&
    operator=(FileSystemParams&& aRhs);

    FileSystemGetDirectoryListingParams&
    get_FileSystemGetDirectoryListingParams()
    {
        AssertSanity(TFileSystemGetDirectoryListingParams);
        return (*(ptr_FileSystemGetDirectoryListingParams()));
    }
    const FileSystemGetDirectoryListingParams&
    get_FileSystemGetDirectoryListingParams() const
    {
        AssertSanity(TFileSystemGetDirectoryListingParams);
        return (*(constptr_FileSystemGetDirectoryListingParams()));
    }
    operator FileSystemGetDirectoryListingParams&()
    {
        return get_FileSystemGetDirectoryListingParams();
    }
    operator const FileSystemGetDirectoryListingParams&() const
    {
        return get_FileSystemGetDirectoryListingParams();
    }

    FileSystemGetFilesParams&
    get_FileSystemGetFilesParams()
    {
        AssertSanity(TFileSystemGetFilesParams);
        return (*(ptr_FileSystemGetFilesParams()));
    }
    const FileSystemGetFilesParams&
    get_FileSystemGetFilesParams() const
    {
        AssertSanity(TFileSystemGetFilesParams);
        return (*(constptr_FileSystemGetFilesParams()));
    }
    operator FileSystemGetFilesParams&()
    {
        return get_FileSystemGetFilesParams();
    }
    operator const FileSystemGetFilesParams&() const
    {
        return get_FileSystemGetFilesParams();
    }

    FileSystemGetFileOrDirectoryParams&
    get_FileSystemGetFileOrDirectoryParams()
    {
        AssertSanity(TFileSystemGetFileOrDirectoryParams);
        return (*(ptr_FileSystemGetFileOrDirectoryParams()));
    }
    const FileSystemGetFileOrDirectoryParams&
    get_FileSystemGetFileOrDirectoryParams() const
    {
        AssertSanity(TFileSystemGetFileOrDirectoryParams);
        return (*(constptr_FileSystemGetFileOrDirectoryParams()));
    }
    operator FileSystemGetFileOrDirectoryParams&()
    {
        return get_FileSystemGetFileOrDirectoryParams();
    }
    operator const FileSystemGetFileOrDirectoryParams&() const
    {
        return get_FileSystemGetFileOrDirectoryParams();
    }

private:
    union {
        FileSystemGetDirectoryListingParams mVFileSystemGetDirectoryListingParams;
        FileSystemGetFilesParams mVFileSystemGetFilesParams;
        FileSystemGetFileOrDirectoryParams mVFileSystemGetFileOrDirectoryParams;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

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

#endif // ifndef PFileSystemParams_h
