Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef JSIPCValue_h
#define JSIPCValue_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/dom/BrowsingContext.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/ipc/IPCCore.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/dom/ClientIPCTypes.h"
#include "mozilla/dom/DOMTypes.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct JSIPCDOMRect|
//
namespace mozilla {
namespace dom {
class JSIPCDOMRect final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
JSIPCDOMRect() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT JSIPCDOMRect(
const double& _x,
const double& _y,
const double& _width,
const double& _height) :
x_(_x),
y_(_y),
width_(_width),
height_(_height)
{
}
MOZ_IMPLICIT JSIPCDOMRect(
double&& _x,
double&& _y,
double&& _width,
double&& _height) :
x_(std::move(_x)),
y_(std::move(_y)),
width_(std::move(_width)),
height_(std::move(_height))
{
}
double&
x()
{
return x_;
}
const double&
x() const
{
return x_;
}
double&
y()
{
return y_;
}
const double&
y() const
{
return y_;
}
double&
width()
{
return width_;
}
const double&
width() const
{
return width_;
}
double&
height()
{
return height_;
}
const double&
height() const
{
return height_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<double> x_;
::mozilla::ipc::IPDLStructMember<double> y_;
::mozilla::ipc::IPDLStructMember<double> width_;
::mozilla::ipc::IPDLStructMember<double> height_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::JSIPCDOMRect>
{
typedef ::mozilla::dom::JSIPCDOMRect paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace dom {
class JSIPCProperty;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class JSIPCArray;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class JSIPCSet;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class JSIPCMapEntry;
} // namespace dom
} // namespace mozilla
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union JSIPCValue|
//
namespace mozilla {
namespace dom {
class JSIPCValue final
{
public:
enum Type {
T__None,
Tvoid_t = 1,
Tnull_t,
TnsString,
Tbool,
Tdouble,
Tint32_t,
TStructuredCloneData,
TClonedMessageData,
TnsIPrincipal,
TMaybeDiscardedBrowsingContext,
TJSIPCDOMRect,
TArrayOfJSIPCProperty,
TJSIPCArray,
TJSIPCSet,
TArrayOfJSIPCMapEntry,
T__Last = TArrayOfJSIPCMapEntry
};
private:
typedef ::mozilla::void_t void_t;
typedef ::mozilla::null_t null_t;
typedef ::nsString nsString;
typedef ::int32_t int32_t;
typedef ::mozilla::dom::ipc::StructuredCloneData StructuredCloneData;
typedef ::mozilla::dom::ClonedMessageData ClonedMessageData;
typedef ::nsIPrincipal nsIPrincipal;
typedef ::mozilla::dom::MaybeDiscardedBrowsingContext MaybeDiscardedBrowsingContext;
typedef ::mozilla::dom::JSIPCDOMRect JSIPCDOMRect;
typedef ::mozilla::dom::JSIPCProperty JSIPCProperty;
typedef ::mozilla::dom::JSIPCArray JSIPCArray;
typedef ::mozilla::dom::JSIPCSet JSIPCSet;
typedef ::mozilla::dom::JSIPCMapEntry JSIPCMapEntry;
typedef void_t void_t__tdef;
typedef null_t null_t__tdef;
typedef nsString nsString__tdef;
typedef bool bool__tdef;
typedef double double__tdef;
typedef int32_t int32_t__tdef;
typedef UniquePtr<StructuredCloneData> StructuredCloneData__tdef;
typedef UniquePtr<ClonedMessageData> ClonedMessageData__tdef;
typedef mozilla::NotNull<RefPtr<nsIPrincipal>> nsIPrincipal__tdef;
typedef MaybeDiscardedBrowsingContext MaybeDiscardedBrowsingContext__tdef;
typedef JSIPCDOMRect JSIPCDOMRect__tdef;
typedef nsTArray<JSIPCProperty>* ArrayOfJSIPCProperty__tdef;
typedef JSIPCArray* JSIPCArray__tdef;
typedef JSIPCSet* JSIPCSet__tdef;
typedef nsTArray<JSIPCMapEntry>* ArrayOfJSIPCMapEntry__tdef;
void_t*
ptr_void_t()
{
return (&(mVvoid_t));
}
const void_t*
constptr_void_t() const
{
return (&(mVvoid_t));
}
null_t*
ptr_null_t()
{
return (&(mVnull_t));
}
const null_t*
constptr_null_t() const
{
return (&(mVnull_t));
}
nsString*
ptr_nsString()
{
return (&(mVnsString));
}
const nsString*
constptr_nsString() const
{
return (&(mVnsString));
}
bool*
ptr_bool()
{
return (&(mVbool));
}
const bool*
constptr_bool() const
{
return (&(mVbool));
}
double*
ptr_double()
{
return (&(mVdouble));
}
const double*
constptr_double() const
{
return (&(mVdouble));
}
int32_t*
ptr_int32_t()
{
return (&(mVint32_t));
}
const int32_t*
constptr_int32_t() const
{
return (&(mVint32_t));
}
UniquePtr<StructuredCloneData>*
ptr_StructuredCloneData()
{
return (&(mVStructuredCloneData));
}
const UniquePtr<StructuredCloneData>*
constptr_StructuredCloneData() const
{
return (&(mVStructuredCloneData));
}
UniquePtr<ClonedMessageData>*
ptr_ClonedMessageData()
{
return (&(mVClonedMessageData));
}
const UniquePtr<ClonedMessageData>*
constptr_ClonedMessageData() const
{
return (&(mVClonedMessageData));
}
mozilla::NotNull<RefPtr<nsIPrincipal>>*
ptr_nsIPrincipal()
{
return (&(mVnsIPrincipal));
}
const mozilla::NotNull<RefPtr<nsIPrincipal>>*
constptr_nsIPrincipal() const
{
return (&(mVnsIPrincipal));
}
MaybeDiscardedBrowsingContext*
ptr_MaybeDiscardedBrowsingContext()
{
return (&(mVMaybeDiscardedBrowsingContext));
}
const MaybeDiscardedBrowsingContext*
constptr_MaybeDiscardedBrowsingContext() const
{
return (&(mVMaybeDiscardedBrowsingContext));
}
JSIPCDOMRect*
ptr_JSIPCDOMRect()
{
return (&(mVJSIPCDOMRect));
}
const JSIPCDOMRect*
constptr_JSIPCDOMRect() const
{
return (&(mVJSIPCDOMRect));
}
nsTArray<JSIPCProperty>*&
ptr_ArrayOfJSIPCProperty()
{
return mVArrayOfJSIPCProperty;
}
const nsTArray<JSIPCProperty>*
constptr_ArrayOfJSIPCProperty() const
{
return mVArrayOfJSIPCProperty;
}
JSIPCArray*&
ptr_JSIPCArray()
{
return mVJSIPCArray;
}
const JSIPCArray*
constptr_JSIPCArray() const
{
return mVJSIPCArray;
}
JSIPCSet*&
ptr_JSIPCSet()
{
return mVJSIPCSet;
}
const JSIPCSet*
constptr_JSIPCSet() const
{
return mVJSIPCSet;
}
nsTArray<JSIPCMapEntry>*&
ptr_ArrayOfJSIPCMapEntry()
{
return mVArrayOfJSIPCMapEntry;
}
const nsTArray<JSIPCMapEntry>*
constptr_ArrayOfJSIPCMapEntry() const
{
return mVArrayOfJSIPCMapEntry;
}
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 JSIPCValue() :
mType(T__None)
{
}
MOZ_IMPLICIT JSIPCValue(const void_t& aOther);
MOZ_IMPLICIT JSIPCValue(void_t&& aOther);
MOZ_IMPLICIT JSIPCValue(const null_t& aOther);
MOZ_IMPLICIT JSIPCValue(null_t&& aOther);
MOZ_IMPLICIT JSIPCValue(const nsString& aOther);
MOZ_IMPLICIT JSIPCValue(nsString&& aOther);
MOZ_IMPLICIT JSIPCValue(const bool& aOther);
MOZ_IMPLICIT JSIPCValue(bool&& aOther);
MOZ_IMPLICIT JSIPCValue(const double& aOther);
MOZ_IMPLICIT JSIPCValue(double&& aOther);
MOZ_IMPLICIT JSIPCValue(const int32_t& aOther);
MOZ_IMPLICIT JSIPCValue(int32_t&& aOther);
MOZ_IMPLICIT JSIPCValue(UniquePtr<StructuredCloneData>&& aOther);
MOZ_IMPLICIT JSIPCValue(UniquePtr<ClonedMessageData>&& aOther);
MOZ_IMPLICIT JSIPCValue(mozilla::NotNull<nsIPrincipal*> aOther);
MOZ_IMPLICIT JSIPCValue(mozilla::NotNull<RefPtr<nsIPrincipal>>&& aOther);
MOZ_IMPLICIT JSIPCValue(const MaybeDiscardedBrowsingContext& aOther);
MOZ_IMPLICIT JSIPCValue(MaybeDiscardedBrowsingContext&& aOther);
MOZ_IMPLICIT JSIPCValue(const JSIPCDOMRect& aOther);
MOZ_IMPLICIT JSIPCValue(JSIPCDOMRect&& aOther);
MOZ_IMPLICIT JSIPCValue(nsTArray<JSIPCProperty>&& aOther);
MOZ_IMPLICIT JSIPCValue(JSIPCArray&& aOther);
MOZ_IMPLICIT JSIPCValue(JSIPCSet&& aOther);
MOZ_IMPLICIT JSIPCValue(nsTArray<JSIPCMapEntry>&& aOther);
MOZ_IMPLICIT JSIPCValue(JSIPCValue&& aOther);
~JSIPCValue();
Type
type() const
{
return mType;
}
JSIPCValue&
operator=(const void_t& aRhs);
JSIPCValue&
operator=(void_t&& aRhs);
JSIPCValue&
operator=(const null_t& aRhs);
JSIPCValue&
operator=(null_t&& aRhs);
JSIPCValue&
operator=(const nsString& aRhs);
JSIPCValue&
operator=(nsString&& aRhs);
JSIPCValue&
operator=(const bool& aRhs);
JSIPCValue&
operator=(bool&& aRhs);
JSIPCValue&
operator=(const double& aRhs);
JSIPCValue&
operator=(double&& aRhs);
JSIPCValue&
operator=(const int32_t& aRhs);
JSIPCValue&
operator=(int32_t&& aRhs);
JSIPCValue&
operator=(UniquePtr<StructuredCloneData>&& aRhs);
JSIPCValue&
operator=(UniquePtr<ClonedMessageData>&& aRhs);
JSIPCValue&
operator=(mozilla::NotNull<nsIPrincipal*> aRhs);
JSIPCValue&
operator=(mozilla::NotNull<RefPtr<nsIPrincipal>>&& aRhs);
JSIPCValue&
operator=(const MaybeDiscardedBrowsingContext& aRhs);
JSIPCValue&
operator=(MaybeDiscardedBrowsingContext&& aRhs);
JSIPCValue&
operator=(const JSIPCDOMRect& aRhs);
JSIPCValue&
operator=(JSIPCDOMRect&& aRhs);
JSIPCValue&
operator=(nsTArray<JSIPCProperty>&& aRhs);
JSIPCValue&
operator=(JSIPCArray&& aRhs);
JSIPCValue&
operator=(JSIPCSet&& aRhs);
JSIPCValue&
operator=(nsTArray<JSIPCMapEntry>&& aRhs);
JSIPCValue&
operator=(JSIPCValue&& aRhs);
void_t&
get_void_t()
{
AssertSanity(Tvoid_t);
return (*(ptr_void_t()));
}
const void_t&
get_void_t() const
{
AssertSanity(Tvoid_t);
return (*(constptr_void_t()));
}
operator void_t&()
{
return get_void_t();
}
operator const void_t&() const
{
return get_void_t();
}
null_t&
get_null_t()
{
AssertSanity(Tnull_t);
return (*(ptr_null_t()));
}
const null_t&
get_null_t() const
{
AssertSanity(Tnull_t);
return (*(constptr_null_t()));
}
operator null_t&()
{
return get_null_t();
}
operator const null_t&() const
{
return get_null_t();
}
nsString&
get_nsString()
{
AssertSanity(TnsString);
return (*(ptr_nsString()));
}
const nsString&
get_nsString() const
{
AssertSanity(TnsString);
return (*(constptr_nsString()));
}
operator nsString&()
{
return get_nsString();
}
operator const nsString&() const
{
return get_nsString();
}
bool&
get_bool()
{
AssertSanity(Tbool);
return (*(ptr_bool()));
}
const bool&
get_bool() const
{
AssertSanity(Tbool);
return (*(constptr_bool()));
}
operator bool&()
{
return get_bool();
}
operator const bool&() const
{
return get_bool();
}
double&
get_double()
{
AssertSanity(Tdouble);
return (*(ptr_double()));
}
const double&
get_double() const
{
AssertSanity(Tdouble);
return (*(constptr_double()));
}
operator double&()
{
return get_double();
}
operator const double&() const
{
return get_double();
}
int32_t&
get_int32_t()
{
AssertSanity(Tint32_t);
return (*(ptr_int32_t()));
}
const int32_t&
get_int32_t() const
{
AssertSanity(Tint32_t);
return (*(constptr_int32_t()));
}
operator int32_t&()
{
return get_int32_t();
}
operator const int32_t&() const
{
return get_int32_t();
}
UniquePtr<StructuredCloneData>&
get_StructuredCloneData()
{
AssertSanity(TStructuredCloneData);
return (*(ptr_StructuredCloneData()));
}
const UniquePtr<StructuredCloneData>&
get_StructuredCloneData() const
{
AssertSanity(TStructuredCloneData);
return (*(constptr_StructuredCloneData()));
}
operator UniquePtr<StructuredCloneData>&()
{
return get_StructuredCloneData();
}
operator const UniquePtr<StructuredCloneData>&() const
{
return get_StructuredCloneData();
}
UniquePtr<ClonedMessageData>&
get_ClonedMessageData()
{
AssertSanity(TClonedMessageData);
return (*(ptr_ClonedMessageData()));
}
const UniquePtr<ClonedMessageData>&
get_ClonedMessageData() const
{
AssertSanity(TClonedMessageData);
return (*(constptr_ClonedMessageData()));
}
operator UniquePtr<ClonedMessageData>&()
{
return get_ClonedMessageData();
}
operator const UniquePtr<ClonedMessageData>&() const
{
return get_ClonedMessageData();
}
mozilla::NotNull<RefPtr<nsIPrincipal>>&
get_nsIPrincipal()
{
AssertSanity(TnsIPrincipal);
return (*(ptr_nsIPrincipal()));
}
mozilla::NotNull<nsIPrincipal*>
get_nsIPrincipal() const
{
AssertSanity(TnsIPrincipal);
return (*(constptr_nsIPrincipal()));
}
operator mozilla::NotNull<RefPtr<nsIPrincipal>>&()
{
return get_nsIPrincipal();
}
operator mozilla::NotNull<nsIPrincipal*>() const
{
return get_nsIPrincipal();
}
MaybeDiscardedBrowsingContext&
get_MaybeDiscardedBrowsingContext()
{
AssertSanity(TMaybeDiscardedBrowsingContext);
return (*(ptr_MaybeDiscardedBrowsingContext()));
}
const MaybeDiscardedBrowsingContext&
get_MaybeDiscardedBrowsingContext() const
{
AssertSanity(TMaybeDiscardedBrowsingContext);
return (*(constptr_MaybeDiscardedBrowsingContext()));
}
operator MaybeDiscardedBrowsingContext&()
{
return get_MaybeDiscardedBrowsingContext();
}
operator const MaybeDiscardedBrowsingContext&() const
{
return get_MaybeDiscardedBrowsingContext();
}
JSIPCDOMRect&
get_JSIPCDOMRect()
{
AssertSanity(TJSIPCDOMRect);
return (*(ptr_JSIPCDOMRect()));
}
const JSIPCDOMRect&
get_JSIPCDOMRect() const
{
AssertSanity(TJSIPCDOMRect);
return (*(constptr_JSIPCDOMRect()));
}
operator JSIPCDOMRect&()
{
return get_JSIPCDOMRect();
}
operator const JSIPCDOMRect&() const
{
return get_JSIPCDOMRect();
}
nsTArray<JSIPCProperty>&
get_ArrayOfJSIPCProperty()
{
AssertSanity(TArrayOfJSIPCProperty);
return (*(ptr_ArrayOfJSIPCProperty()));
}
const nsTArray<JSIPCProperty>&
get_ArrayOfJSIPCProperty() const
{
AssertSanity(TArrayOfJSIPCProperty);
return (*(constptr_ArrayOfJSIPCProperty()));
}
operator nsTArray<JSIPCProperty>&()
{
return get_ArrayOfJSIPCProperty();
}
operator const nsTArray<JSIPCProperty>&() const
{
return get_ArrayOfJSIPCProperty();
}
JSIPCArray&
get_JSIPCArray()
{
AssertSanity(TJSIPCArray);
return (*(ptr_JSIPCArray()));
}
const JSIPCArray&
get_JSIPCArray() const
{
AssertSanity(TJSIPCArray);
return (*(constptr_JSIPCArray()));
}
operator JSIPCArray&()
{
return get_JSIPCArray();
}
operator const JSIPCArray&() const
{
return get_JSIPCArray();
}
JSIPCSet&
get_JSIPCSet()
{
AssertSanity(TJSIPCSet);
return (*(ptr_JSIPCSet()));
}
const JSIPCSet&
get_JSIPCSet() const
{
AssertSanity(TJSIPCSet);
return (*(constptr_JSIPCSet()));
}
operator JSIPCSet&()
{
return get_JSIPCSet();
}
operator const JSIPCSet&() const
{
return get_JSIPCSet();
}
nsTArray<JSIPCMapEntry>&
get_ArrayOfJSIPCMapEntry()
{
AssertSanity(TArrayOfJSIPCMapEntry);
return (*(ptr_ArrayOfJSIPCMapEntry()));
}
const nsTArray<JSIPCMapEntry>&
get_ArrayOfJSIPCMapEntry() const
{
AssertSanity(TArrayOfJSIPCMapEntry);
return (*(constptr_ArrayOfJSIPCMapEntry()));
}
operator nsTArray<JSIPCMapEntry>&()
{
return get_ArrayOfJSIPCMapEntry();
}
operator const nsTArray<JSIPCMapEntry>&() const
{
return get_ArrayOfJSIPCMapEntry();
}
private:
union {
void_t mVvoid_t;
null_t mVnull_t;
nsString mVnsString;
bool mVbool;
double mVdouble;
int32_t mVint32_t;
UniquePtr<StructuredCloneData> mVStructuredCloneData;
UniquePtr<ClonedMessageData> mVClonedMessageData;
mozilla::NotNull<RefPtr<nsIPrincipal>> mVnsIPrincipal;
MaybeDiscardedBrowsingContext mVMaybeDiscardedBrowsingContext;
JSIPCDOMRect mVJSIPCDOMRect;
nsTArray<JSIPCProperty>* mVArrayOfJSIPCProperty;
JSIPCArray* mVJSIPCArray;
JSIPCSet* mVJSIPCSet;
nsTArray<JSIPCMapEntry>* mVArrayOfJSIPCMapEntry;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::JSIPCValue>
{
typedef ::mozilla::dom::JSIPCValue 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 JSIPCProperty|
//
namespace mozilla {
namespace dom {
class JSIPCProperty final
{
private:
typedef ::nsString nsString;
typedef ::mozilla::dom::JSIPCValue JSIPCValue;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
JSIPCProperty() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT JSIPCProperty(
const nsString& _name,
JSIPCValue&& _value) :
name_(_name),
value_(std::move(_value))
{
}
MOZ_IMPLICIT JSIPCProperty(
nsString&& _name,
JSIPCValue&& _value) :
name_(std::move(_name)),
value_(std::move(_value))
{
}
nsString&
name()
{
return name_;
}
const nsString&
name() const
{
return name_;
}
JSIPCValue&
value()
{
return value_;
}
const JSIPCValue&
value() const
{
return value_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> name_;
::mozilla::ipc::IPDLStructMember<JSIPCValue> value_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::JSIPCProperty>
{
typedef ::mozilla::dom::JSIPCProperty 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 JSIPCArray|
//
namespace mozilla {
namespace dom {
class JSIPCArray final
{
private:
typedef ::mozilla::dom::JSIPCValue JSIPCValue;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
JSIPCArray() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT JSIPCArray(nsTArray<JSIPCValue>&& _elements) :
elements_(std::move(_elements))
{
}
nsTArray<JSIPCValue>&
elements()
{
return elements_;
}
const nsTArray<JSIPCValue>&
elements() const
{
return elements_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<JSIPCValue>> elements_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::JSIPCArray>
{
typedef ::mozilla::dom::JSIPCArray 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 JSIPCSet|
//
namespace mozilla {
namespace dom {
class JSIPCSet final
{
private:
typedef ::mozilla::dom::JSIPCValue JSIPCValue;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
JSIPCSet() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT JSIPCSet(nsTArray<JSIPCValue>&& _elements) :
elements_(std::move(_elements))
{
}
nsTArray<JSIPCValue>&
elements()
{
return elements_;
}
const nsTArray<JSIPCValue>&
elements() const
{
return elements_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<JSIPCValue>> elements_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::JSIPCSet>
{
typedef ::mozilla::dom::JSIPCSet 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 JSIPCMapEntry|
//
namespace mozilla {
namespace dom {
class JSIPCMapEntry final
{
private:
typedef ::mozilla::dom::JSIPCValue JSIPCValue;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
JSIPCMapEntry() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT JSIPCMapEntry(
JSIPCValue&& _key,
JSIPCValue&& _value) :
key_(std::move(_key)),
value_(std::move(_value))
{
}
JSIPCValue&
key()
{
return key_;
}
const JSIPCValue&
key() const
{
return key_;
}
JSIPCValue&
value()
{
return value_;
}
const JSIPCValue&
value() const
{
return value_;
}
private:
::mozilla::ipc::IPDLStructMember<JSIPCValue> key_;
::mozilla::ipc::IPDLStructMember<JSIPCValue> value_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::JSIPCMapEntry>
{
typedef ::mozilla::dom::JSIPCMapEntry paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
#endif // ifndef JSIPCValue_h