Copy as Markdown
Other Tools
//
// 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;
union Value {
mozilla::AlignedStorage2<FileSystemGetDirectoryListingParams> VFileSystemGetDirectoryListingParams;
mozilla::AlignedStorage2<FileSystemGetFilesParams> VFileSystemGetFilesParams;
mozilla::AlignedStorage2<FileSystemGetFileOrDirectoryParams> VFileSystemGetFileOrDirectoryParams;
};
FileSystemGetDirectoryListingParams*
ptr_FileSystemGetDirectoryListingParams()
{
return ((mValue).VFileSystemGetDirectoryListingParams).addr();
}
const FileSystemGetDirectoryListingParams*
constptr_FileSystemGetDirectoryListingParams() const
{
return ((mValue).VFileSystemGetDirectoryListingParams).addr();
}
FileSystemGetFilesParams*
ptr_FileSystemGetFilesParams()
{
return ((mValue).VFileSystemGetFilesParams).addr();
}
const FileSystemGetFilesParams*
constptr_FileSystemGetFilesParams() const
{
return ((mValue).VFileSystemGetFilesParams).addr();
}
FileSystemGetFileOrDirectoryParams*
ptr_FileSystemGetFileOrDirectoryParams()
{
return ((mValue).VFileSystemGetFileOrDirectoryParams).addr();
}
const FileSystemGetFileOrDirectoryParams*
constptr_FileSystemGetFileOrDirectoryParams() const
{
return ((mValue).VFileSystemGetFileOrDirectoryParams).addr();
}
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:
Value mValue;
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