Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef URIParams_h
#define URIParams_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/ipc/PBackgroundSharedTypes.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SimpleURIParams|
//
namespace mozilla {
namespace ipc {
class SimpleURIParams 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
SimpleURIParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT SimpleURIParams(
const nsCString& _scheme,
const nsCString& _path,
const nsCString& _ref,
const nsCString& _query) :
scheme_(_scheme),
path_(_path),
ref_(_ref),
query_(_query)
{
}
MOZ_IMPLICIT SimpleURIParams(
nsCString&& _scheme,
nsCString&& _path,
nsCString&& _ref,
nsCString&& _query) :
scheme_(std::move(_scheme)),
path_(std::move(_path)),
ref_(std::move(_ref)),
query_(std::move(_query))
{
}
nsCString&
scheme()
{
return scheme_;
}
const nsCString&
scheme() const
{
return scheme_;
}
nsCString&
path()
{
return path_;
}
const nsCString&
path() const
{
return path_;
}
nsCString&
ref()
{
return ref_;
}
const nsCString&
ref() const
{
return ref_;
}
nsCString&
query()
{
return query_;
}
const nsCString&
query() const
{
return query_;
}
private:
::mozilla::ipc::IPDLStructMember<nsCString> scheme_;
::mozilla::ipc::IPDLStructMember<nsCString> path_;
::mozilla::ipc::IPDLStructMember<nsCString> ref_;
::mozilla::ipc::IPDLStructMember<nsCString> query_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::SimpleURIParams>
{
typedef ::mozilla::ipc::SimpleURIParams 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 DefaultURIParams|
//
namespace mozilla {
namespace ipc {
class DefaultURIParams 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
DefaultURIParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT DefaultURIParams(const nsCString& _spec) :
spec_(_spec)
{
}
MOZ_IMPLICIT DefaultURIParams(nsCString&& _spec) :
spec_(std::move(_spec))
{
}
nsCString&
spec()
{
return spec_;
}
const nsCString&
spec() const
{
return spec_;
}
private:
::mozilla::ipc::IPDLStructMember<nsCString> spec_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::DefaultURIParams>
{
typedef ::mozilla::ipc::DefaultURIParams 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 StandardURLSegment|
//
namespace mozilla {
namespace ipc {
class StandardURLSegment final
{
private:
typedef ::uint32_t uint32_t;
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
StandardURLSegment() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT StandardURLSegment(
const uint32_t& _position,
const int32_t& _length) :
position_(_position),
length_(_length)
{
}
MOZ_IMPLICIT StandardURLSegment(
uint32_t&& _position,
int32_t&& _length) :
position_(std::move(_position)),
length_(std::move(_length))
{
}
uint32_t&
position()
{
return position_;
}
const uint32_t&
position() const
{
return position_;
}
int32_t&
length()
{
return length_;
}
const int32_t&
length() const
{
return length_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<uint32_t> position_;
::mozilla::ipc::IPDLStructMember<int32_t> length_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::StandardURLSegment>
{
typedef ::mozilla::ipc::StandardURLSegment 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 StandardURLParams|
//
namespace mozilla {
namespace ipc {
class StandardURLParams final
{
private:
typedef ::uint32_t uint32_t;
typedef ::int32_t int32_t;
typedef ::nsCString nsCString;
typedef ::mozilla::ipc::StandardURLSegment StandardURLSegment;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
StandardURLParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT StandardURLParams(
const uint32_t& _urlType,
const int32_t& _port,
const int32_t& _defaultPort,
const nsCString& _spec,
const StandardURLSegment& _scheme,
const StandardURLSegment& _authority,
const StandardURLSegment& _username,
const StandardURLSegment& _password,
const StandardURLSegment& _host,
const StandardURLSegment& _path,
const StandardURLSegment& _filePath,
const StandardURLSegment& _directory,
const StandardURLSegment& _baseName,
const StandardURLSegment& _extension,
const StandardURLSegment& _query,
const StandardURLSegment& _ref,
const bool& _supportsFileURL,
const bool& _isSubstituting) :
spec_(_spec),
scheme_(_scheme),
authority_(_authority),
username_(_username),
password_(_password),
host_(_host),
path_(_path),
filePath_(_filePath),
directory_(_directory),
baseName_(_baseName),
extension_(_extension),
query_(_query),
ref_(_ref),
supportsFileURL_(_supportsFileURL),
isSubstituting_(_isSubstituting),
urlType_(_urlType),
port_(_port),
defaultPort_(_defaultPort)
{
}
MOZ_IMPLICIT StandardURLParams(
uint32_t&& _urlType,
int32_t&& _port,
int32_t&& _defaultPort,
nsCString&& _spec,
StandardURLSegment&& _scheme,
StandardURLSegment&& _authority,
StandardURLSegment&& _username,
StandardURLSegment&& _password,
StandardURLSegment&& _host,
StandardURLSegment&& _path,
StandardURLSegment&& _filePath,
StandardURLSegment&& _directory,
StandardURLSegment&& _baseName,
StandardURLSegment&& _extension,
StandardURLSegment&& _query,
StandardURLSegment&& _ref,
bool&& _supportsFileURL,
bool&& _isSubstituting) :
spec_(std::move(_spec)),
scheme_(std::move(_scheme)),
authority_(std::move(_authority)),
username_(std::move(_username)),
password_(std::move(_password)),
host_(std::move(_host)),
path_(std::move(_path)),
filePath_(std::move(_filePath)),
directory_(std::move(_directory)),
baseName_(std::move(_baseName)),
extension_(std::move(_extension)),
query_(std::move(_query)),
ref_(std::move(_ref)),
supportsFileURL_(std::move(_supportsFileURL)),
isSubstituting_(std::move(_isSubstituting)),
urlType_(std::move(_urlType)),
port_(std::move(_port)),
defaultPort_(std::move(_defaultPort))
{
}
uint32_t&
urlType()
{
return urlType_;
}
const uint32_t&
urlType() const
{
return urlType_;
}
int32_t&
port()
{
return port_;
}
const int32_t&
port() const
{
return port_;
}
int32_t&
defaultPort()
{
return defaultPort_;
}
const int32_t&
defaultPort() const
{
return defaultPort_;
}
nsCString&
spec()
{
return spec_;
}
const nsCString&
spec() const
{
return spec_;
}
StandardURLSegment&
scheme()
{
return scheme_;
}
const StandardURLSegment&
scheme() const
{
return scheme_;
}
StandardURLSegment&
authority()
{
return authority_;
}
const StandardURLSegment&
authority() const
{
return authority_;
}
StandardURLSegment&
username()
{
return username_;
}
const StandardURLSegment&
username() const
{
return username_;
}
StandardURLSegment&
password()
{
return password_;
}
const StandardURLSegment&
password() const
{
return password_;
}
StandardURLSegment&
host()
{
return host_;
}
const StandardURLSegment&
host() const
{
return host_;
}
StandardURLSegment&
path()
{
return path_;
}
const StandardURLSegment&
path() const
{
return path_;
}
StandardURLSegment&
filePath()
{
return filePath_;
}
const StandardURLSegment&
filePath() const
{
return filePath_;
}
StandardURLSegment&
directory()
{
return directory_;
}
const StandardURLSegment&
directory() const
{
return directory_;
}
StandardURLSegment&
baseName()
{
return baseName_;
}
const StandardURLSegment&
baseName() const
{
return baseName_;
}
StandardURLSegment&
extension()
{
return extension_;
}
const StandardURLSegment&
extension() const
{
return extension_;
}
StandardURLSegment&
query()
{
return query_;
}
const StandardURLSegment&
query() const
{
return query_;
}
StandardURLSegment&
ref()
{
return ref_;
}
const StandardURLSegment&
ref() const
{
return ref_;
}
bool&
supportsFileURL()
{
return supportsFileURL_;
}
const bool&
supportsFileURL() const
{
return supportsFileURL_;
}
bool&
isSubstituting()
{
return isSubstituting_;
}
const bool&
isSubstituting() const
{
return isSubstituting_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<nsCString> spec_;
::mozilla::ipc::IPDLStructMember<StandardURLSegment> scheme_;
::mozilla::ipc::IPDLStructMember<StandardURLSegment> authority_;
::mozilla::ipc::IPDLStructMember<StandardURLSegment> username_;
::mozilla::ipc::IPDLStructMember<StandardURLSegment> password_;
::mozilla::ipc::IPDLStructMember<StandardURLSegment> host_;
::mozilla::ipc::IPDLStructMember<StandardURLSegment> path_;
::mozilla::ipc::IPDLStructMember<StandardURLSegment> filePath_;
::mozilla::ipc::IPDLStructMember<StandardURLSegment> directory_;
::mozilla::ipc::IPDLStructMember<StandardURLSegment> baseName_;
::mozilla::ipc::IPDLStructMember<StandardURLSegment> extension_;
::mozilla::ipc::IPDLStructMember<StandardURLSegment> query_;
::mozilla::ipc::IPDLStructMember<StandardURLSegment> ref_;
::mozilla::ipc::IPDLStructMember<bool> supportsFileURL_;
::mozilla::ipc::IPDLStructMember<bool> isSubstituting_;
::mozilla::ipc::IPDLStructMember<uint32_t> urlType_;
::mozilla::ipc::IPDLStructMember<int32_t> port_;
::mozilla::ipc::IPDLStructMember<int32_t> defaultPort_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::StandardURLParams>
{
typedef ::mozilla::ipc::StandardURLParams 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 HostObjectURIParams|
//
namespace mozilla {
namespace ipc {
class HostObjectURIParams final
{
private:
typedef ::mozilla::ipc::SimpleURIParams SimpleURIParams;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
HostObjectURIParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT HostObjectURIParams(
const SimpleURIParams& _simpleParams,
const bool& _revoked) :
simpleParams_(_simpleParams),
revoked_(_revoked)
{
}
MOZ_IMPLICIT HostObjectURIParams(
SimpleURIParams&& _simpleParams,
bool&& _revoked) :
simpleParams_(std::move(_simpleParams)),
revoked_(std::move(_revoked))
{
}
SimpleURIParams&
simpleParams()
{
return simpleParams_;
}
const SimpleURIParams&
simpleParams() const
{
return simpleParams_;
}
bool&
revoked()
{
return revoked_;
}
const bool&
revoked() const
{
return revoked_;
}
private:
::mozilla::ipc::IPDLStructMember<SimpleURIParams> simpleParams_;
::mozilla::ipc::IPDLStructMember<bool> revoked_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::HostObjectURIParams>
{
typedef ::mozilla::ipc::HostObjectURIParams paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace ipc {
class JARURIParams;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class IconURIParams;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class JSURIParams;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class SimpleNestedURIParams;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class NestedAboutURIParams;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class SubstitutingJARURIParams;
} // namespace ipc
} // namespace mozilla
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union URIParams|
//
namespace mozilla {
namespace ipc {
class URIParams final
{
public:
enum Type {
T__None,
TSimpleURIParams = 1,
TStandardURLParams,
TJARURIParams,
TIconURIParams,
TJSURIParams,
TSimpleNestedURIParams,
THostObjectURIParams,
TDefaultURIParams,
TNestedAboutURIParams,
TSubstitutingJARURIParams,
T__Last = TSubstitutingJARURIParams
};
private:
typedef ::mozilla::ipc::SimpleURIParams SimpleURIParams;
typedef ::mozilla::ipc::StandardURLParams StandardURLParams;
typedef ::mozilla::ipc::JARURIParams JARURIParams;
typedef ::mozilla::ipc::IconURIParams IconURIParams;
typedef ::mozilla::ipc::JSURIParams JSURIParams;
typedef ::mozilla::ipc::SimpleNestedURIParams SimpleNestedURIParams;
typedef ::mozilla::ipc::HostObjectURIParams HostObjectURIParams;
typedef ::mozilla::ipc::DefaultURIParams DefaultURIParams;
typedef ::mozilla::ipc::NestedAboutURIParams NestedAboutURIParams;
typedef ::mozilla::ipc::SubstitutingJARURIParams SubstitutingJARURIParams;
typedef SimpleURIParams SimpleURIParams__tdef;
typedef StandardURLParams StandardURLParams__tdef;
typedef JARURIParams* JARURIParams__tdef;
typedef IconURIParams* IconURIParams__tdef;
typedef JSURIParams* JSURIParams__tdef;
typedef SimpleNestedURIParams* SimpleNestedURIParams__tdef;
typedef HostObjectURIParams HostObjectURIParams__tdef;
typedef DefaultURIParams DefaultURIParams__tdef;
typedef NestedAboutURIParams* NestedAboutURIParams__tdef;
typedef SubstitutingJARURIParams* SubstitutingJARURIParams__tdef;
union Value {
mozilla::AlignedStorage2<SimpleURIParams> VSimpleURIParams;
mozilla::AlignedStorage2<StandardURLParams> VStandardURLParams;
JARURIParams* VJARURIParams;
IconURIParams* VIconURIParams;
JSURIParams* VJSURIParams;
SimpleNestedURIParams* VSimpleNestedURIParams;
mozilla::AlignedStorage2<HostObjectURIParams> VHostObjectURIParams;
mozilla::AlignedStorage2<DefaultURIParams> VDefaultURIParams;
NestedAboutURIParams* VNestedAboutURIParams;
SubstitutingJARURIParams* VSubstitutingJARURIParams;
};
SimpleURIParams*
ptr_SimpleURIParams()
{
return ((mValue).VSimpleURIParams).addr();
}
const SimpleURIParams*
constptr_SimpleURIParams() const
{
return ((mValue).VSimpleURIParams).addr();
}
StandardURLParams*
ptr_StandardURLParams()
{
return ((mValue).VStandardURLParams).addr();
}
const StandardURLParams*
constptr_StandardURLParams() const
{
return ((mValue).VStandardURLParams).addr();
}
JARURIParams*&
ptr_JARURIParams()
{
return (mValue).VJARURIParams;
}
const JARURIParams*
constptr_JARURIParams() const
{
return (mValue).VJARURIParams;
}
IconURIParams*&
ptr_IconURIParams()
{
return (mValue).VIconURIParams;
}
const IconURIParams*
constptr_IconURIParams() const
{
return (mValue).VIconURIParams;
}
JSURIParams*&
ptr_JSURIParams()
{
return (mValue).VJSURIParams;
}
const JSURIParams*
constptr_JSURIParams() const
{
return (mValue).VJSURIParams;
}
SimpleNestedURIParams*&
ptr_SimpleNestedURIParams()
{
return (mValue).VSimpleNestedURIParams;
}
const SimpleNestedURIParams*
constptr_SimpleNestedURIParams() const
{
return (mValue).VSimpleNestedURIParams;
}
HostObjectURIParams*
ptr_HostObjectURIParams()
{
return ((mValue).VHostObjectURIParams).addr();
}
const HostObjectURIParams*
constptr_HostObjectURIParams() const
{
return ((mValue).VHostObjectURIParams).addr();
}
DefaultURIParams*
ptr_DefaultURIParams()
{
return ((mValue).VDefaultURIParams).addr();
}
const DefaultURIParams*
constptr_DefaultURIParams() const
{
return ((mValue).VDefaultURIParams).addr();
}
NestedAboutURIParams*&
ptr_NestedAboutURIParams()
{
return (mValue).VNestedAboutURIParams;
}
const NestedAboutURIParams*
constptr_NestedAboutURIParams() const
{
return (mValue).VNestedAboutURIParams;
}
SubstitutingJARURIParams*&
ptr_SubstitutingJARURIParams()
{
return (mValue).VSubstitutingJARURIParams;
}
const SubstitutingJARURIParams*
constptr_SubstitutingJARURIParams() const
{
return (mValue).VSubstitutingJARURIParams;
}
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 URIParams() :
mType(T__None)
{
}
MOZ_IMPLICIT URIParams(const SimpleURIParams& aOther);
MOZ_IMPLICIT URIParams(SimpleURIParams&& aOther);
MOZ_IMPLICIT URIParams(const StandardURLParams& aOther);
MOZ_IMPLICIT URIParams(StandardURLParams&& aOther);
MOZ_IMPLICIT URIParams(const JARURIParams& aOther);
MOZ_IMPLICIT URIParams(JARURIParams&& aOther);
MOZ_IMPLICIT URIParams(const IconURIParams& aOther);
MOZ_IMPLICIT URIParams(IconURIParams&& aOther);
MOZ_IMPLICIT URIParams(const JSURIParams& aOther);
MOZ_IMPLICIT URIParams(JSURIParams&& aOther);
MOZ_IMPLICIT URIParams(const SimpleNestedURIParams& aOther);
MOZ_IMPLICIT URIParams(SimpleNestedURIParams&& aOther);
MOZ_IMPLICIT URIParams(const HostObjectURIParams& aOther);
MOZ_IMPLICIT URIParams(HostObjectURIParams&& aOther);
MOZ_IMPLICIT URIParams(const DefaultURIParams& aOther);
MOZ_IMPLICIT URIParams(DefaultURIParams&& aOther);
MOZ_IMPLICIT URIParams(const NestedAboutURIParams& aOther);
MOZ_IMPLICIT URIParams(NestedAboutURIParams&& aOther);
MOZ_IMPLICIT URIParams(const SubstitutingJARURIParams& aOther);
MOZ_IMPLICIT URIParams(SubstitutingJARURIParams&& aOther);
MOZ_IMPLICIT URIParams(const URIParams& aOther);
MOZ_IMPLICIT URIParams(URIParams&& aOther);
~URIParams();
Type
type() const
{
return mType;
}
URIParams&
operator=(const SimpleURIParams& aRhs);
URIParams&
operator=(SimpleURIParams&& aRhs);
URIParams&
operator=(const StandardURLParams& aRhs);
URIParams&
operator=(StandardURLParams&& aRhs);
URIParams&
operator=(const JARURIParams& aRhs);
URIParams&
operator=(JARURIParams&& aRhs);
URIParams&
operator=(const IconURIParams& aRhs);
URIParams&
operator=(IconURIParams&& aRhs);
URIParams&
operator=(const JSURIParams& aRhs);
URIParams&
operator=(JSURIParams&& aRhs);
URIParams&
operator=(const SimpleNestedURIParams& aRhs);
URIParams&
operator=(SimpleNestedURIParams&& aRhs);
URIParams&
operator=(const HostObjectURIParams& aRhs);
URIParams&
operator=(HostObjectURIParams&& aRhs);
URIParams&
operator=(const DefaultURIParams& aRhs);
URIParams&
operator=(DefaultURIParams&& aRhs);
URIParams&
operator=(const NestedAboutURIParams& aRhs);
URIParams&
operator=(NestedAboutURIParams&& aRhs);
URIParams&
operator=(const SubstitutingJARURIParams& aRhs);
URIParams&
operator=(SubstitutingJARURIParams&& aRhs);
URIParams&
operator=(const URIParams& aRhs);
URIParams&
operator=(URIParams&& aRhs);
SimpleURIParams&
get_SimpleURIParams()
{
AssertSanity(TSimpleURIParams);
return (*(ptr_SimpleURIParams()));
}
const SimpleURIParams&
get_SimpleURIParams() const
{
AssertSanity(TSimpleURIParams);
return (*(constptr_SimpleURIParams()));
}
operator SimpleURIParams&()
{
return get_SimpleURIParams();
}
operator const SimpleURIParams&() const
{
return get_SimpleURIParams();
}
StandardURLParams&
get_StandardURLParams()
{
AssertSanity(TStandardURLParams);
return (*(ptr_StandardURLParams()));
}
const StandardURLParams&
get_StandardURLParams() const
{
AssertSanity(TStandardURLParams);
return (*(constptr_StandardURLParams()));
}
operator StandardURLParams&()
{
return get_StandardURLParams();
}
operator const StandardURLParams&() const
{
return get_StandardURLParams();
}
JARURIParams&
get_JARURIParams()
{
AssertSanity(TJARURIParams);
return (*(ptr_JARURIParams()));
}
const JARURIParams&
get_JARURIParams() const
{
AssertSanity(TJARURIParams);
return (*(constptr_JARURIParams()));
}
operator JARURIParams&()
{
return get_JARURIParams();
}
operator const JARURIParams&() const
{
return get_JARURIParams();
}
IconURIParams&
get_IconURIParams()
{
AssertSanity(TIconURIParams);
return (*(ptr_IconURIParams()));
}
const IconURIParams&
get_IconURIParams() const
{
AssertSanity(TIconURIParams);
return (*(constptr_IconURIParams()));
}
operator IconURIParams&()
{
return get_IconURIParams();
}
operator const IconURIParams&() const
{
return get_IconURIParams();
}
JSURIParams&
get_JSURIParams()
{
AssertSanity(TJSURIParams);
return (*(ptr_JSURIParams()));
}
const JSURIParams&
get_JSURIParams() const
{
AssertSanity(TJSURIParams);
return (*(constptr_JSURIParams()));
}
operator JSURIParams&()
{
return get_JSURIParams();
}
operator const JSURIParams&() const
{
return get_JSURIParams();
}
SimpleNestedURIParams&
get_SimpleNestedURIParams()
{
AssertSanity(TSimpleNestedURIParams);
return (*(ptr_SimpleNestedURIParams()));
}
const SimpleNestedURIParams&
get_SimpleNestedURIParams() const
{
AssertSanity(TSimpleNestedURIParams);
return (*(constptr_SimpleNestedURIParams()));
}
operator SimpleNestedURIParams&()
{
return get_SimpleNestedURIParams();
}
operator const SimpleNestedURIParams&() const
{
return get_SimpleNestedURIParams();
}
HostObjectURIParams&
get_HostObjectURIParams()
{
AssertSanity(THostObjectURIParams);
return (*(ptr_HostObjectURIParams()));
}
const HostObjectURIParams&
get_HostObjectURIParams() const
{
AssertSanity(THostObjectURIParams);
return (*(constptr_HostObjectURIParams()));
}
operator HostObjectURIParams&()
{
return get_HostObjectURIParams();
}
operator const HostObjectURIParams&() const
{
return get_HostObjectURIParams();
}
DefaultURIParams&
get_DefaultURIParams()
{
AssertSanity(TDefaultURIParams);
return (*(ptr_DefaultURIParams()));
}
const DefaultURIParams&
get_DefaultURIParams() const
{
AssertSanity(TDefaultURIParams);
return (*(constptr_DefaultURIParams()));
}
operator DefaultURIParams&()
{
return get_DefaultURIParams();
}
operator const DefaultURIParams&() const
{
return get_DefaultURIParams();
}
NestedAboutURIParams&
get_NestedAboutURIParams()
{
AssertSanity(TNestedAboutURIParams);
return (*(ptr_NestedAboutURIParams()));
}
const NestedAboutURIParams&
get_NestedAboutURIParams() const
{
AssertSanity(TNestedAboutURIParams);
return (*(constptr_NestedAboutURIParams()));
}
operator NestedAboutURIParams&()
{
return get_NestedAboutURIParams();
}
operator const NestedAboutURIParams&() const
{
return get_NestedAboutURIParams();
}
SubstitutingJARURIParams&
get_SubstitutingJARURIParams()
{
AssertSanity(TSubstitutingJARURIParams);
return (*(ptr_SubstitutingJARURIParams()));
}
const SubstitutingJARURIParams&
get_SubstitutingJARURIParams() const
{
AssertSanity(TSubstitutingJARURIParams);
return (*(constptr_SubstitutingJARURIParams()));
}
operator SubstitutingJARURIParams&()
{
return get_SubstitutingJARURIParams();
}
operator const SubstitutingJARURIParams&() const
{
return get_SubstitutingJARURIParams();
}
private:
Value mValue;
Type mType;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::URIParams>
{
typedef ::mozilla::ipc::URIParams 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 JARURIParams|
//
namespace mozilla {
namespace ipc {
class JARURIParams final
{
private:
typedef ::mozilla::ipc::URIParams URIParams;
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
JARURIParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT JARURIParams(
const URIParams& _jarFile,
const URIParams& _jarEntry,
const nsCString& _charset) :
jarFile_(_jarFile),
jarEntry_(_jarEntry),
charset_(_charset)
{
}
MOZ_IMPLICIT JARURIParams(
URIParams&& _jarFile,
URIParams&& _jarEntry,
nsCString&& _charset) :
jarFile_(std::move(_jarFile)),
jarEntry_(std::move(_jarEntry)),
charset_(std::move(_charset))
{
}
URIParams&
jarFile()
{
return jarFile_;
}
const URIParams&
jarFile() const
{
return jarFile_;
}
URIParams&
jarEntry()
{
return jarEntry_;
}
const URIParams&
jarEntry() const
{
return jarEntry_;
}
nsCString&
charset()
{
return charset_;
}
const nsCString&
charset() const
{
return charset_;
}
private:
::mozilla::ipc::IPDLStructMember<URIParams> jarFile_;
::mozilla::ipc::IPDLStructMember<URIParams> jarEntry_;
::mozilla::ipc::IPDLStructMember<nsCString> charset_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::JARURIParams>
{
typedef ::mozilla::ipc::JARURIParams 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 IconURIParams|
//
namespace mozilla {
namespace ipc {
class IconURIParams final
{
private:
typedef ::mozilla::ipc::URIParams URIParams;
typedef ::uint32_t uint32_t;
typedef ::nsCString nsCString;
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
IconURIParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IconURIParams(
const mozilla::Maybe<URIParams>& _uri,
const uint32_t& _size,
const nsCString& _contentType,
const nsCString& _fileName,
const nsCString& _stockIcon,
const int32_t& _iconSize,
const int32_t& _iconState) :
uri_(_uri),
contentType_(_contentType),
fileName_(_fileName),
stockIcon_(_stockIcon),
size_(_size),
iconSize_(_iconSize),
iconState_(_iconState)
{
}
MOZ_IMPLICIT IconURIParams(
mozilla::Maybe<URIParams>&& _uri,
uint32_t&& _size,
nsCString&& _contentType,
nsCString&& _fileName,
nsCString&& _stockIcon,
int32_t&& _iconSize,
int32_t&& _iconState) :
uri_(std::move(_uri)),
contentType_(std::move(_contentType)),
fileName_(std::move(_fileName)),
stockIcon_(std::move(_stockIcon)),
size_(std::move(_size)),
iconSize_(std::move(_iconSize)),
iconState_(std::move(_iconState))
{
}
mozilla::Maybe<URIParams>&
uri()
{
return uri_;
}
const mozilla::Maybe<URIParams>&
uri() const
{
return uri_;
}
uint32_t&
size()
{
return size_;
}
const uint32_t&
size() const
{
return size_;
}
nsCString&
contentType()
{
return contentType_;
}
const nsCString&
contentType() const
{
return contentType_;
}
nsCString&
fileName()
{
return fileName_;
}
const nsCString&
fileName() const
{
return fileName_;
}
nsCString&
stockIcon()
{
return stockIcon_;
}
const nsCString&
stockIcon() const
{
return stockIcon_;
}
int32_t&
iconSize()
{
return iconSize_;
}
const int32_t&
iconSize() const
{
return iconSize_;
}
int32_t&
iconState()
{
return iconState_;
}
const int32_t&
iconState() const
{
return iconState_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<URIParams>> uri_;
::mozilla::ipc::IPDLStructMember<nsCString> contentType_;
::mozilla::ipc::IPDLStructMember<nsCString> fileName_;
::mozilla::ipc::IPDLStructMember<nsCString> stockIcon_;
::mozilla::ipc::IPDLStructMember<uint32_t> size_;
::mozilla::ipc::IPDLStructMember<int32_t> iconSize_;
::mozilla::ipc::IPDLStructMember<int32_t> iconState_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::IconURIParams>
{
typedef ::mozilla::ipc::IconURIParams 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 JSURIParams|
//
namespace mozilla {
namespace ipc {
class JSURIParams final
{
private:
typedef ::mozilla::ipc::SimpleURIParams SimpleURIParams;
typedef ::mozilla::ipc::URIParams URIParams;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
JSURIParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT JSURIParams(
const SimpleURIParams& _simpleParams,
const mozilla::Maybe<URIParams>& _baseURI) :
simpleParams_(_simpleParams),
baseURI_(_baseURI)
{
}
MOZ_IMPLICIT JSURIParams(
SimpleURIParams&& _simpleParams,
mozilla::Maybe<URIParams>&& _baseURI) :
simpleParams_(std::move(_simpleParams)),
baseURI_(std::move(_baseURI))
{
}
SimpleURIParams&
simpleParams()
{
return simpleParams_;
}
const SimpleURIParams&
simpleParams() const
{
return simpleParams_;
}
mozilla::Maybe<URIParams>&
baseURI()
{
return baseURI_;
}
const mozilla::Maybe<URIParams>&
baseURI() const
{
return baseURI_;
}
private:
::mozilla::ipc::IPDLStructMember<SimpleURIParams> simpleParams_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<URIParams>> baseURI_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::JSURIParams>
{
typedef ::mozilla::ipc::JSURIParams 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 SimpleNestedURIParams|
//
namespace mozilla {
namespace ipc {
class SimpleNestedURIParams final
{
private:
typedef ::mozilla::ipc::SimpleURIParams SimpleURIParams;
typedef ::mozilla::ipc::URIParams URIParams;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
SimpleNestedURIParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT SimpleNestedURIParams(
const SimpleURIParams& _simpleParams,
const URIParams& _innerURI) :
simpleParams_(_simpleParams),
innerURI_(_innerURI)
{
}
MOZ_IMPLICIT SimpleNestedURIParams(
SimpleURIParams&& _simpleParams,
URIParams&& _innerURI) :
simpleParams_(std::move(_simpleParams)),
innerURI_(std::move(_innerURI))
{
}
SimpleURIParams&
simpleParams()
{
return simpleParams_;
}
const SimpleURIParams&
simpleParams() const
{
return simpleParams_;
}
URIParams&
innerURI()
{
return innerURI_;
}
const URIParams&
innerURI() const
{
return innerURI_;
}
private:
::mozilla::ipc::IPDLStructMember<SimpleURIParams> simpleParams_;
::mozilla::ipc::IPDLStructMember<URIParams> innerURI_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::SimpleNestedURIParams>
{
typedef ::mozilla::ipc::SimpleNestedURIParams 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 NestedAboutURIParams|
//
namespace mozilla {
namespace ipc {
class NestedAboutURIParams final
{
private:
typedef ::mozilla::ipc::SimpleNestedURIParams SimpleNestedURIParams;
typedef ::mozilla::ipc::URIParams URIParams;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
NestedAboutURIParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT NestedAboutURIParams(
const SimpleNestedURIParams& _nestedParams,
const mozilla::Maybe<URIParams>& _baseURI) :
nestedParams_(_nestedParams),
baseURI_(_baseURI)
{
}
MOZ_IMPLICIT NestedAboutURIParams(
SimpleNestedURIParams&& _nestedParams,
mozilla::Maybe<URIParams>&& _baseURI) :
nestedParams_(std::move(_nestedParams)),
baseURI_(std::move(_baseURI))
{
}
SimpleNestedURIParams&
nestedParams()
{
return nestedParams_;
}
const SimpleNestedURIParams&
nestedParams() const
{
return nestedParams_;
}
mozilla::Maybe<URIParams>&
baseURI()
{
return baseURI_;
}
const mozilla::Maybe<URIParams>&
baseURI() const
{
return baseURI_;
}
private:
::mozilla::ipc::IPDLStructMember<SimpleNestedURIParams> nestedParams_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<URIParams>> baseURI_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::NestedAboutURIParams>
{
typedef ::mozilla::ipc::NestedAboutURIParams 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 SubstitutingJARURIParams|
//
namespace mozilla {
namespace ipc {
class SubstitutingJARURIParams final
{
private:
typedef ::mozilla::ipc::URIParams URIParams;
typedef ::mozilla::ipc::JARURIParams JARURIParams;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
SubstitutingJARURIParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT SubstitutingJARURIParams(
const URIParams& _source,
const JARURIParams& _resolved) :
source_(_source),
resolved_(_resolved)
{
}
MOZ_IMPLICIT SubstitutingJARURIParams(
URIParams&& _source,
JARURIParams&& _resolved) :
source_(std::move(_source)),
resolved_(std::move(_resolved))
{
}
URIParams&
source()
{
return source_;
}
const URIParams&
source() const
{
return source_;
}
JARURIParams&
resolved()
{
return resolved_;
}
const JARURIParams&
resolved() const
{
return resolved_;
}
private:
::mozilla::ipc::IPDLStructMember<URIParams> source_;
::mozilla::ipc::IPDLStructMember<JARURIParams> resolved_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::SubstitutingJARURIParams>
{
typedef ::mozilla::ipc::SubstitutingJARURIParams paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
#endif // ifndef URIParams_h