Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PTestDataStructuresCommon_h
#define PTestDataStructuresCommon_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/IPCCore.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/ipc/SideVariant.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union IntDouble|
//
namespace mozilla {
namespace _foo {
class IntDouble final
{
public:
enum Type {
T__None,
Tint = 1,
Tdouble,
T__Last = Tdouble
};
private:
typedef int int__tdef;
typedef double double__tdef;
union Value {
mozilla::AlignedStorage2<int> Vint;
mozilla::AlignedStorage2<double> Vdouble;
};
int*
ptr_int()
{
return ((mValue).Vint).addr();
}
const int*
constptr_int() const
{
return ((mValue).Vint).addr();
}
double*
ptr_double()
{
return ((mValue).Vdouble).addr();
}
const double*
constptr_double() const
{
return ((mValue).Vdouble).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 IntDouble() :
mType(T__None)
{
}
MOZ_IMPLICIT IntDouble(const int& aOther);
MOZ_IMPLICIT IntDouble(int&& aOther);
MOZ_IMPLICIT IntDouble(const double& aOther);
MOZ_IMPLICIT IntDouble(double&& aOther);
MOZ_IMPLICIT IntDouble(const IntDouble& aOther);
MOZ_IMPLICIT IntDouble(IntDouble&& aOther);
~IntDouble();
Type
type() const
{
return mType;
}
IntDouble&
operator=(const int& aRhs);
IntDouble&
operator=(int&& aRhs);
IntDouble&
operator=(const double& aRhs);
IntDouble&
operator=(double&& aRhs);
IntDouble&
operator=(const IntDouble& aRhs);
IntDouble&
operator=(IntDouble&& aRhs);
int&
get_int()
{
AssertSanity(Tint);
return (*(ptr_int()));
}
const int&
get_int() const
{
AssertSanity(Tint);
return (*(constptr_int()));
}
operator int&()
{
return get_int();
}
operator const int&() const
{
return get_int();
}
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();
}
private:
Value mValue;
Type mType;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::IntDouble>
{
typedef ::mozilla::_foo::IntDouble 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 SIntDouble|
//
namespace mozilla {
namespace _foo {
class SIntDouble final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
SIntDouble() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT SIntDouble(
const int& _i,
const double& _d) :
i_(_i),
d_(_d)
{
}
MOZ_IMPLICIT SIntDouble(
int&& _i,
double&& _d) :
i_(std::move(_i)),
d_(std::move(_d))
{
}
int&
i()
{
return i_;
}
const int&
i() const
{
return i_;
}
double&
d()
{
return d_;
}
const double&
d() const
{
return d_;
}
private:
::mozilla::ipc::IPDLStructMember<int> i_;
::mozilla::ipc::IPDLStructMember<double> d_;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::SIntDouble>
{
typedef ::mozilla::_foo::SIntDouble 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 IntDoubleArrays|
//
namespace mozilla {
namespace _foo {
class IntDoubleArrays final
{
public:
enum Type {
T__None,
Tint = 1,
TArrayOfint,
TArrayOfdouble,
T__Last = TArrayOfdouble
};
private:
typedef int int__tdef;
typedef nsTArray<int> ArrayOfint__tdef;
typedef nsTArray<double> ArrayOfdouble__tdef;
union Value {
mozilla::AlignedStorage2<int> Vint;
mozilla::AlignedStorage2<nsTArray<int>> VArrayOfint;
mozilla::AlignedStorage2<nsTArray<double>> VArrayOfdouble;
};
int*
ptr_int()
{
return ((mValue).Vint).addr();
}
const int*
constptr_int() const
{
return ((mValue).Vint).addr();
}
nsTArray<int>*
ptr_ArrayOfint()
{
return ((mValue).VArrayOfint).addr();
}
const nsTArray<int>*
constptr_ArrayOfint() const
{
return ((mValue).VArrayOfint).addr();
}
nsTArray<double>*
ptr_ArrayOfdouble()
{
return ((mValue).VArrayOfdouble).addr();
}
const nsTArray<double>*
constptr_ArrayOfdouble() const
{
return ((mValue).VArrayOfdouble).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 IntDoubleArrays() :
mType(T__None)
{
}
MOZ_IMPLICIT IntDoubleArrays(const int& aOther);
MOZ_IMPLICIT IntDoubleArrays(int&& aOther);
MOZ_IMPLICIT IntDoubleArrays(const nsTArray<int>& aOther);
MOZ_IMPLICIT IntDoubleArrays(nsTArray<int>&& aOther);
MOZ_IMPLICIT IntDoubleArrays(const nsTArray<double>& aOther);
MOZ_IMPLICIT IntDoubleArrays(nsTArray<double>&& aOther);
MOZ_IMPLICIT IntDoubleArrays(const IntDoubleArrays& aOther);
MOZ_IMPLICIT IntDoubleArrays(IntDoubleArrays&& aOther);
~IntDoubleArrays();
Type
type() const
{
return mType;
}
IntDoubleArrays&
operator=(const int& aRhs);
IntDoubleArrays&
operator=(int&& aRhs);
IntDoubleArrays&
operator=(const nsTArray<int>& aRhs);
IntDoubleArrays&
operator=(nsTArray<int>&& aRhs);
IntDoubleArrays&
operator=(const nsTArray<double>& aRhs);
IntDoubleArrays&
operator=(nsTArray<double>&& aRhs);
IntDoubleArrays&
operator=(const IntDoubleArrays& aRhs);
IntDoubleArrays&
operator=(IntDoubleArrays&& aRhs);
int&
get_int()
{
AssertSanity(Tint);
return (*(ptr_int()));
}
const int&
get_int() const
{
AssertSanity(Tint);
return (*(constptr_int()));
}
operator int&()
{
return get_int();
}
operator const int&() const
{
return get_int();
}
nsTArray<int>&
get_ArrayOfint()
{
AssertSanity(TArrayOfint);
return (*(ptr_ArrayOfint()));
}
const nsTArray<int>&
get_ArrayOfint() const
{
AssertSanity(TArrayOfint);
return (*(constptr_ArrayOfint()));
}
operator nsTArray<int>&()
{
return get_ArrayOfint();
}
operator const nsTArray<int>&() const
{
return get_ArrayOfint();
}
nsTArray<double>&
get_ArrayOfdouble()
{
AssertSanity(TArrayOfdouble);
return (*(ptr_ArrayOfdouble()));
}
const nsTArray<double>&
get_ArrayOfdouble() const
{
AssertSanity(TArrayOfdouble);
return (*(constptr_ArrayOfdouble()));
}
operator nsTArray<double>&()
{
return get_ArrayOfdouble();
}
operator const nsTArray<double>&() const
{
return get_ArrayOfdouble();
}
private:
Value mValue;
Type mType;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::IntDoubleArrays>
{
typedef ::mozilla::_foo::IntDoubleArrays 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 SIntDoubleArrays|
//
namespace mozilla {
namespace _foo {
class SIntDoubleArrays final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
SIntDoubleArrays() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT SIntDoubleArrays(
const int& _i,
const nsTArray<int>& _ai,
const nsTArray<double>& _ad) :
i_(_i),
ai_(_ai),
ad_(_ad)
{
}
MOZ_IMPLICIT SIntDoubleArrays(
int&& _i,
nsTArray<int>&& _ai,
nsTArray<double>&& _ad) :
i_(std::move(_i)),
ai_(std::move(_ai)),
ad_(std::move(_ad))
{
}
int&
i()
{
return i_;
}
const int&
i() const
{
return i_;
}
nsTArray<int>&
ai()
{
return ai_;
}
const nsTArray<int>&
ai() const
{
return ai_;
}
nsTArray<double>&
ad()
{
return ad_;
}
const nsTArray<double>&
ad() const
{
return ad_;
}
private:
::mozilla::ipc::IPDLStructMember<int> i_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<int>> ai_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<double>> ad_;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::SIntDoubleArrays>
{
typedef ::mozilla::_foo::SIntDoubleArrays paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubParent;
} // namespace _ipdltest
} // namespace mozilla
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubChild;
} // namespace _ipdltest
} // namespace mozilla
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ActorWrapper|
//
namespace mozilla {
namespace _foo {
class ActorWrapper final
{
private:
typedef ::mozilla::_ipdltest::PTestDataStructuresSubParent PTestDataStructuresSubParent;
typedef ::mozilla::_ipdltest::PTestDataStructuresSubChild PTestDataStructuresSubChild;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ActorWrapper() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ActorWrapper(::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*> _actor) :
actor_(_actor)
{
}
::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>&
actor()
{
return actor_;
}
::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>
actor() const
{
return actor_;
}
private:
::mozilla::ipc::IPDLStructMember<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>> actor_;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::ActorWrapper>
{
typedef ::mozilla::_foo::ActorWrapper paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubParent;
} // namespace _ipdltest
} // namespace mozilla
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubChild;
} // namespace _ipdltest
} // namespace mozilla
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union Actors|
//
namespace mozilla {
namespace _foo {
class Actors final
{
public:
enum Type {
T__None,
Tint = 1,
TArrayOfint,
TArrayOfPTestDataStructuresSub,
T__Last = TArrayOfPTestDataStructuresSub
};
private:
typedef ::mozilla::_ipdltest::PTestDataStructuresSubParent PTestDataStructuresSubParent;
typedef ::mozilla::_ipdltest::PTestDataStructuresSubChild PTestDataStructuresSubChild;
typedef int int__tdef;
typedef nsTArray<int> ArrayOfint__tdef;
typedef nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>> ArrayOfPTestDataStructuresSub__tdef;
union Value {
mozilla::AlignedStorage2<int> Vint;
mozilla::AlignedStorage2<nsTArray<int>> VArrayOfint;
mozilla::AlignedStorage2<nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>> VArrayOfPTestDataStructuresSub;
};
int*
ptr_int()
{
return ((mValue).Vint).addr();
}
const int*
constptr_int() const
{
return ((mValue).Vint).addr();
}
nsTArray<int>*
ptr_ArrayOfint()
{
return ((mValue).VArrayOfint).addr();
}
const nsTArray<int>*
constptr_ArrayOfint() const
{
return ((mValue).VArrayOfint).addr();
}
nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>*
ptr_ArrayOfPTestDataStructuresSub()
{
return ((mValue).VArrayOfPTestDataStructuresSub).addr();
}
const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>*
constptr_ArrayOfPTestDataStructuresSub() const
{
return ((mValue).VArrayOfPTestDataStructuresSub).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 Actors() :
mType(T__None)
{
}
MOZ_IMPLICIT Actors(const int& aOther);
MOZ_IMPLICIT Actors(int&& aOther);
MOZ_IMPLICIT Actors(const nsTArray<int>& aOther);
MOZ_IMPLICIT Actors(nsTArray<int>&& aOther);
MOZ_IMPLICIT Actors(const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>& aOther);
MOZ_IMPLICIT Actors(nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&& aOther);
MOZ_IMPLICIT Actors(const Actors& aOther);
MOZ_IMPLICIT Actors(Actors&& aOther);
~Actors();
Type
type() const
{
return mType;
}
Actors&
operator=(const int& aRhs);
Actors&
operator=(int&& aRhs);
Actors&
operator=(const nsTArray<int>& aRhs);
Actors&
operator=(nsTArray<int>&& aRhs);
Actors&
operator=(const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>& aRhs);
Actors&
operator=(nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&& aRhs);
Actors&
operator=(const Actors& aRhs);
Actors&
operator=(Actors&& aRhs);
int&
get_int()
{
AssertSanity(Tint);
return (*(ptr_int()));
}
const int&
get_int() const
{
AssertSanity(Tint);
return (*(constptr_int()));
}
operator int&()
{
return get_int();
}
operator const int&() const
{
return get_int();
}
nsTArray<int>&
get_ArrayOfint()
{
AssertSanity(TArrayOfint);
return (*(ptr_ArrayOfint()));
}
const nsTArray<int>&
get_ArrayOfint() const
{
AssertSanity(TArrayOfint);
return (*(constptr_ArrayOfint()));
}
operator nsTArray<int>&()
{
return get_ArrayOfint();
}
operator const nsTArray<int>&() const
{
return get_ArrayOfint();
}
nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&
get_ArrayOfPTestDataStructuresSub()
{
AssertSanity(TArrayOfPTestDataStructuresSub);
return (*(ptr_ArrayOfPTestDataStructuresSub()));
}
const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&
get_ArrayOfPTestDataStructuresSub() const
{
AssertSanity(TArrayOfPTestDataStructuresSub);
return (*(constptr_ArrayOfPTestDataStructuresSub()));
}
operator nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&()
{
return get_ArrayOfPTestDataStructuresSub();
}
operator const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&() const
{
return get_ArrayOfPTestDataStructuresSub();
}
private:
Value mValue;
Type mType;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::Actors>
{
typedef ::mozilla::_foo::Actors paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubParent;
} // namespace _ipdltest
} // namespace mozilla
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubChild;
} // namespace _ipdltest
} // namespace mozilla
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SActors|
//
namespace mozilla {
namespace _foo {
class SActors final
{
private:
typedef ::mozilla::_ipdltest::PTestDataStructuresSubParent PTestDataStructuresSubParent;
typedef ::mozilla::_ipdltest::PTestDataStructuresSubChild PTestDataStructuresSubChild;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
SActors() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT SActors(
const int& _i,
const nsTArray<int>& _ai,
const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>& _ap) :
i_(_i),
ai_(_ai),
ap_(_ap)
{
}
MOZ_IMPLICIT SActors(
int&& _i,
nsTArray<int>&& _ai,
nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&& _ap) :
i_(std::move(_i)),
ai_(std::move(_ai)),
ap_(std::move(_ap))
{
}
int&
i()
{
return i_;
}
const int&
i() const
{
return i_;
}
nsTArray<int>&
ai()
{
return ai_;
}
const nsTArray<int>&
ai() const
{
return ai_;
}
nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&
ap()
{
return ap_;
}
const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&
ap() const
{
return ap_;
}
private:
::mozilla::ipc::IPDLStructMember<int> i_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<int>> ai_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>> ap_;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::SActors>
{
typedef ::mozilla::_foo::SActors paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubParent;
} // namespace _ipdltest
} // namespace mozilla
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubChild;
} // namespace _ipdltest
} // namespace mozilla
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union Unions|
//
namespace mozilla {
namespace _foo {
class Unions final
{
public:
enum Type {
T__None,
Tint = 1,
TArrayOfint,
TArrayOfPTestDataStructuresSub,
TArrayOfActors,
T__Last = TArrayOfActors
};
private:
typedef ::mozilla::_ipdltest::PTestDataStructuresSubParent PTestDataStructuresSubParent;
typedef ::mozilla::_ipdltest::PTestDataStructuresSubChild PTestDataStructuresSubChild;
typedef ::mozilla::_foo::Actors Actors;
typedef int int__tdef;
typedef nsTArray<int> ArrayOfint__tdef;
typedef nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>> ArrayOfPTestDataStructuresSub__tdef;
typedef nsTArray<Actors> ArrayOfActors__tdef;
union Value {
mozilla::AlignedStorage2<int> Vint;
mozilla::AlignedStorage2<nsTArray<int>> VArrayOfint;
mozilla::AlignedStorage2<nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>> VArrayOfPTestDataStructuresSub;
mozilla::AlignedStorage2<nsTArray<Actors>> VArrayOfActors;
};
int*
ptr_int()
{
return ((mValue).Vint).addr();
}
const int*
constptr_int() const
{
return ((mValue).Vint).addr();
}
nsTArray<int>*
ptr_ArrayOfint()
{
return ((mValue).VArrayOfint).addr();
}
const nsTArray<int>*
constptr_ArrayOfint() const
{
return ((mValue).VArrayOfint).addr();
}
nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>*
ptr_ArrayOfPTestDataStructuresSub()
{
return ((mValue).VArrayOfPTestDataStructuresSub).addr();
}
const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>*
constptr_ArrayOfPTestDataStructuresSub() const
{
return ((mValue).VArrayOfPTestDataStructuresSub).addr();
}
nsTArray<Actors>*
ptr_ArrayOfActors()
{
return ((mValue).VArrayOfActors).addr();
}
const nsTArray<Actors>*
constptr_ArrayOfActors() const
{
return ((mValue).VArrayOfActors).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 Unions() :
mType(T__None)
{
}
MOZ_IMPLICIT Unions(const int& aOther);
MOZ_IMPLICIT Unions(int&& aOther);
MOZ_IMPLICIT Unions(const nsTArray<int>& aOther);
MOZ_IMPLICIT Unions(nsTArray<int>&& aOther);
MOZ_IMPLICIT Unions(const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>& aOther);
MOZ_IMPLICIT Unions(nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&& aOther);
MOZ_IMPLICIT Unions(const nsTArray<Actors>& aOther);
MOZ_IMPLICIT Unions(nsTArray<Actors>&& aOther);
MOZ_IMPLICIT Unions(const Unions& aOther);
MOZ_IMPLICIT Unions(Unions&& aOther);
~Unions();
Type
type() const
{
return mType;
}
Unions&
operator=(const int& aRhs);
Unions&
operator=(int&& aRhs);
Unions&
operator=(const nsTArray<int>& aRhs);
Unions&
operator=(nsTArray<int>&& aRhs);
Unions&
operator=(const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>& aRhs);
Unions&
operator=(nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&& aRhs);
Unions&
operator=(const nsTArray<Actors>& aRhs);
Unions&
operator=(nsTArray<Actors>&& aRhs);
Unions&
operator=(const Unions& aRhs);
Unions&
operator=(Unions&& aRhs);
int&
get_int()
{
AssertSanity(Tint);
return (*(ptr_int()));
}
const int&
get_int() const
{
AssertSanity(Tint);
return (*(constptr_int()));
}
operator int&()
{
return get_int();
}
operator const int&() const
{
return get_int();
}
nsTArray<int>&
get_ArrayOfint()
{
AssertSanity(TArrayOfint);
return (*(ptr_ArrayOfint()));
}
const nsTArray<int>&
get_ArrayOfint() const
{
AssertSanity(TArrayOfint);
return (*(constptr_ArrayOfint()));
}
operator nsTArray<int>&()
{
return get_ArrayOfint();
}
operator const nsTArray<int>&() const
{
return get_ArrayOfint();
}
nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&
get_ArrayOfPTestDataStructuresSub()
{
AssertSanity(TArrayOfPTestDataStructuresSub);
return (*(ptr_ArrayOfPTestDataStructuresSub()));
}
const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&
get_ArrayOfPTestDataStructuresSub() const
{
AssertSanity(TArrayOfPTestDataStructuresSub);
return (*(constptr_ArrayOfPTestDataStructuresSub()));
}
operator nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&()
{
return get_ArrayOfPTestDataStructuresSub();
}
operator const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&() const
{
return get_ArrayOfPTestDataStructuresSub();
}
nsTArray<Actors>&
get_ArrayOfActors()
{
AssertSanity(TArrayOfActors);
return (*(ptr_ArrayOfActors()));
}
const nsTArray<Actors>&
get_ArrayOfActors() const
{
AssertSanity(TArrayOfActors);
return (*(constptr_ArrayOfActors()));
}
operator nsTArray<Actors>&()
{
return get_ArrayOfActors();
}
operator const nsTArray<Actors>&() const
{
return get_ArrayOfActors();
}
private:
Value mValue;
Type mType;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::Unions>
{
typedef ::mozilla::_foo::Unions paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubParent;
} // namespace _ipdltest
} // namespace mozilla
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubChild;
} // namespace _ipdltest
} // namespace mozilla
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct Structs|
//
namespace mozilla {
namespace _foo {
class Structs final
{
private:
typedef ::mozilla::_ipdltest::PTestDataStructuresSubParent PTestDataStructuresSubParent;
typedef ::mozilla::_ipdltest::PTestDataStructuresSubChild PTestDataStructuresSubChild;
typedef ::mozilla::_foo::SActors SActors;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
Structs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT Structs(
const int& _i,
const nsTArray<int>& _ai,
const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>& _ap,
const nsTArray<SActors>& _aa) :
i_(_i),
ai_(_ai),
ap_(_ap),
aa_(_aa)
{
}
MOZ_IMPLICIT Structs(
int&& _i,
nsTArray<int>&& _ai,
nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&& _ap,
nsTArray<SActors>&& _aa) :
i_(std::move(_i)),
ai_(std::move(_ai)),
ap_(std::move(_ap)),
aa_(std::move(_aa))
{
}
int&
i()
{
return i_;
}
const int&
i() const
{
return i_;
}
nsTArray<int>&
ai()
{
return ai_;
}
const nsTArray<int>&
ai() const
{
return ai_;
}
nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&
ap()
{
return ap_;
}
const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&
ap() const
{
return ap_;
}
nsTArray<SActors>&
aa()
{
return aa_;
}
const nsTArray<SActors>&
aa() const
{
return aa_;
}
private:
::mozilla::ipc::IPDLStructMember<int> i_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<int>> ai_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>> ap_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<SActors>> aa_;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::Structs>
{
typedef ::mozilla::_foo::Structs paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubParent;
} // namespace _ipdltest
} // namespace mozilla
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubChild;
} // namespace _ipdltest
} // namespace mozilla
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union WithStructs|
//
namespace mozilla {
namespace _foo {
class WithStructs final
{
public:
enum Type {
T__None,
Tint = 1,
TArrayOfint,
TArrayOfPTestDataStructuresSub,
TArrayOfSActors,
TArrayOfStructs,
T__Last = TArrayOfStructs
};
private:
typedef ::mozilla::_ipdltest::PTestDataStructuresSubParent PTestDataStructuresSubParent;
typedef ::mozilla::_ipdltest::PTestDataStructuresSubChild PTestDataStructuresSubChild;
typedef ::mozilla::_foo::SActors SActors;
typedef ::mozilla::_foo::Structs Structs;
typedef int int__tdef;
typedef nsTArray<int> ArrayOfint__tdef;
typedef nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>> ArrayOfPTestDataStructuresSub__tdef;
typedef nsTArray<SActors> ArrayOfSActors__tdef;
typedef nsTArray<Structs> ArrayOfStructs__tdef;
union Value {
mozilla::AlignedStorage2<int> Vint;
mozilla::AlignedStorage2<nsTArray<int>> VArrayOfint;
mozilla::AlignedStorage2<nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>> VArrayOfPTestDataStructuresSub;
mozilla::AlignedStorage2<nsTArray<SActors>> VArrayOfSActors;
mozilla::AlignedStorage2<nsTArray<Structs>> VArrayOfStructs;
};
int*
ptr_int()
{
return ((mValue).Vint).addr();
}
const int*
constptr_int() const
{
return ((mValue).Vint).addr();
}
nsTArray<int>*
ptr_ArrayOfint()
{
return ((mValue).VArrayOfint).addr();
}
const nsTArray<int>*
constptr_ArrayOfint() const
{
return ((mValue).VArrayOfint).addr();
}
nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>*
ptr_ArrayOfPTestDataStructuresSub()
{
return ((mValue).VArrayOfPTestDataStructuresSub).addr();
}
const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>*
constptr_ArrayOfPTestDataStructuresSub() const
{
return ((mValue).VArrayOfPTestDataStructuresSub).addr();
}
nsTArray<SActors>*
ptr_ArrayOfSActors()
{
return ((mValue).VArrayOfSActors).addr();
}
const nsTArray<SActors>*
constptr_ArrayOfSActors() const
{
return ((mValue).VArrayOfSActors).addr();
}
nsTArray<Structs>*
ptr_ArrayOfStructs()
{
return ((mValue).VArrayOfStructs).addr();
}
const nsTArray<Structs>*
constptr_ArrayOfStructs() const
{
return ((mValue).VArrayOfStructs).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 WithStructs() :
mType(T__None)
{
}
MOZ_IMPLICIT WithStructs(const int& aOther);
MOZ_IMPLICIT WithStructs(int&& aOther);
MOZ_IMPLICIT WithStructs(const nsTArray<int>& aOther);
MOZ_IMPLICIT WithStructs(nsTArray<int>&& aOther);
MOZ_IMPLICIT WithStructs(const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>& aOther);
MOZ_IMPLICIT WithStructs(nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&& aOther);
MOZ_IMPLICIT WithStructs(const nsTArray<SActors>& aOther);
MOZ_IMPLICIT WithStructs(nsTArray<SActors>&& aOther);
MOZ_IMPLICIT WithStructs(const nsTArray<Structs>& aOther);
MOZ_IMPLICIT WithStructs(nsTArray<Structs>&& aOther);
MOZ_IMPLICIT WithStructs(const WithStructs& aOther);
MOZ_IMPLICIT WithStructs(WithStructs&& aOther);
~WithStructs();
Type
type() const
{
return mType;
}
WithStructs&
operator=(const int& aRhs);
WithStructs&
operator=(int&& aRhs);
WithStructs&
operator=(const nsTArray<int>& aRhs);
WithStructs&
operator=(nsTArray<int>&& aRhs);
WithStructs&
operator=(const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>& aRhs);
WithStructs&
operator=(nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&& aRhs);
WithStructs&
operator=(const nsTArray<SActors>& aRhs);
WithStructs&
operator=(nsTArray<SActors>&& aRhs);
WithStructs&
operator=(const nsTArray<Structs>& aRhs);
WithStructs&
operator=(nsTArray<Structs>&& aRhs);
WithStructs&
operator=(const WithStructs& aRhs);
WithStructs&
operator=(WithStructs&& aRhs);
int&
get_int()
{
AssertSanity(Tint);
return (*(ptr_int()));
}
const int&
get_int() const
{
AssertSanity(Tint);
return (*(constptr_int()));
}
operator int&()
{
return get_int();
}
operator const int&() const
{
return get_int();
}
nsTArray<int>&
get_ArrayOfint()
{
AssertSanity(TArrayOfint);
return (*(ptr_ArrayOfint()));
}
const nsTArray<int>&
get_ArrayOfint() const
{
AssertSanity(TArrayOfint);
return (*(constptr_ArrayOfint()));
}
operator nsTArray<int>&()
{
return get_ArrayOfint();
}
operator const nsTArray<int>&() const
{
return get_ArrayOfint();
}
nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&
get_ArrayOfPTestDataStructuresSub()
{
AssertSanity(TArrayOfPTestDataStructuresSub);
return (*(ptr_ArrayOfPTestDataStructuresSub()));
}
const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&
get_ArrayOfPTestDataStructuresSub() const
{
AssertSanity(TArrayOfPTestDataStructuresSub);
return (*(constptr_ArrayOfPTestDataStructuresSub()));
}
operator nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&()
{
return get_ArrayOfPTestDataStructuresSub();
}
operator const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&() const
{
return get_ArrayOfPTestDataStructuresSub();
}
nsTArray<SActors>&
get_ArrayOfSActors()
{
AssertSanity(TArrayOfSActors);
return (*(ptr_ArrayOfSActors()));
}
const nsTArray<SActors>&
get_ArrayOfSActors() const
{
AssertSanity(TArrayOfSActors);
return (*(constptr_ArrayOfSActors()));
}
operator nsTArray<SActors>&()
{
return get_ArrayOfSActors();
}
operator const nsTArray<SActors>&() const
{
return get_ArrayOfSActors();
}
nsTArray<Structs>&
get_ArrayOfStructs()
{
AssertSanity(TArrayOfStructs);
return (*(ptr_ArrayOfStructs()));
}
const nsTArray<Structs>&
get_ArrayOfStructs() const
{
AssertSanity(TArrayOfStructs);
return (*(constptr_ArrayOfStructs()));
}
operator nsTArray<Structs>&()
{
return get_ArrayOfStructs();
}
operator const nsTArray<Structs>&() const
{
return get_ArrayOfStructs();
}
private:
Value mValue;
Type mType;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::WithStructs>
{
typedef ::mozilla::_foo::WithStructs paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubParent;
} // namespace _ipdltest
} // namespace mozilla
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubChild;
} // namespace _ipdltest
} // namespace mozilla
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WithUnions|
//
namespace mozilla {
namespace _foo {
class WithUnions final
{
private:
typedef ::mozilla::_ipdltest::PTestDataStructuresSubParent PTestDataStructuresSubParent;
typedef ::mozilla::_ipdltest::PTestDataStructuresSubChild PTestDataStructuresSubChild;
typedef ::mozilla::_foo::Actors Actors;
typedef ::mozilla::_foo::Unions Unions;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WithUnions() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WithUnions(
const int& _i,
const nsTArray<int>& _ai,
const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>& _ap,
const nsTArray<Actors>& _aa,
const nsTArray<Unions>& _au) :
i_(_i),
ai_(_ai),
ap_(_ap),
aa_(_aa),
au_(_au)
{
}
MOZ_IMPLICIT WithUnions(
int&& _i,
nsTArray<int>&& _ai,
nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&& _ap,
nsTArray<Actors>&& _aa,
nsTArray<Unions>&& _au) :
i_(std::move(_i)),
ai_(std::move(_ai)),
ap_(std::move(_ap)),
aa_(std::move(_aa)),
au_(std::move(_au))
{
}
int&
i()
{
return i_;
}
const int&
i() const
{
return i_;
}
nsTArray<int>&
ai()
{
return ai_;
}
const nsTArray<int>&
ai() const
{
return ai_;
}
nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&
ap()
{
return ap_;
}
const nsTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>&
ap() const
{
return ap_;
}
nsTArray<Actors>&
aa()
{
return aa_;
}
const nsTArray<Actors>&
aa() const
{
return aa_;
}
nsTArray<Unions>&
au()
{
return au_;
}
const nsTArray<Unions>&
au() const
{
return au_;
}
private:
::mozilla::ipc::IPDLStructMember<int> i_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<int>> ai_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>>> ap_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<Actors>> aa_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<Unions>> au_;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::WithUnions>
{
typedef ::mozilla::_foo::WithUnions 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 CommonAttrs|
//
namespace mozilla {
namespace _foo {
class CommonAttrs final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CommonAttrs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CommonAttrs(const bool& _dummy) :
dummy_(_dummy)
{
}
MOZ_IMPLICIT CommonAttrs(bool&& _dummy) :
dummy_(std::move(_dummy))
{
}
bool&
dummy()
{
return dummy_;
}
const bool&
dummy() const
{
return dummy_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> dummy_;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::CommonAttrs>
{
typedef ::mozilla::_foo::CommonAttrs 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 FooAttrs|
//
namespace mozilla {
namespace _foo {
class FooAttrs final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
FooAttrs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT FooAttrs(const int& _dummy) :
dummy_(_dummy)
{
}
MOZ_IMPLICIT FooAttrs(int&& _dummy) :
dummy_(std::move(_dummy))
{
}
int&
dummy()
{
return dummy_;
}
const int&
dummy() const
{
return dummy_;
}
private:
::mozilla::ipc::IPDLStructMember<int> dummy_;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::FooAttrs>
{
typedef ::mozilla::_foo::FooAttrs 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 BarAttrs|
//
namespace mozilla {
namespace _foo {
class BarAttrs final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
BarAttrs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT BarAttrs(const float& _dummy) :
dummy_(_dummy)
{
}
MOZ_IMPLICIT BarAttrs(float&& _dummy) :
dummy_(std::move(_dummy))
{
}
float&
dummy()
{
return dummy_;
}
const float&
dummy() const
{
return dummy_;
}
private:
::mozilla::ipc::IPDLStructMember<float> dummy_;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::BarAttrs>
{
typedef ::mozilla::_foo::BarAttrs 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 SpecificAttrs|
//
namespace mozilla {
namespace _foo {
class SpecificAttrs final
{
public:
enum Type {
T__None,
TFooAttrs = 1,
TBarAttrs,
T__Last = TBarAttrs
};
private:
typedef ::mozilla::_foo::FooAttrs FooAttrs;
typedef ::mozilla::_foo::BarAttrs BarAttrs;
typedef FooAttrs FooAttrs__tdef;
typedef BarAttrs BarAttrs__tdef;
union Value {
mozilla::AlignedStorage2<FooAttrs> VFooAttrs;
mozilla::AlignedStorage2<BarAttrs> VBarAttrs;
};
FooAttrs*
ptr_FooAttrs()
{
return ((mValue).VFooAttrs).addr();
}
const FooAttrs*
constptr_FooAttrs() const
{
return ((mValue).VFooAttrs).addr();
}
BarAttrs*
ptr_BarAttrs()
{
return ((mValue).VBarAttrs).addr();
}
const BarAttrs*
constptr_BarAttrs() const
{
return ((mValue).VBarAttrs).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 SpecificAttrs() :
mType(T__None)
{
}
MOZ_IMPLICIT SpecificAttrs(const FooAttrs& aOther);
MOZ_IMPLICIT SpecificAttrs(FooAttrs&& aOther);
MOZ_IMPLICIT SpecificAttrs(const BarAttrs& aOther);
MOZ_IMPLICIT SpecificAttrs(BarAttrs&& aOther);
MOZ_IMPLICIT SpecificAttrs(const SpecificAttrs& aOther);
MOZ_IMPLICIT SpecificAttrs(SpecificAttrs&& aOther);
~SpecificAttrs();
Type
type() const
{
return mType;
}
SpecificAttrs&
operator=(const FooAttrs& aRhs);
SpecificAttrs&
operator=(FooAttrs&& aRhs);
SpecificAttrs&
operator=(const BarAttrs& aRhs);
SpecificAttrs&
operator=(BarAttrs&& aRhs);
SpecificAttrs&
operator=(const SpecificAttrs& aRhs);
SpecificAttrs&
operator=(SpecificAttrs&& aRhs);
FooAttrs&
get_FooAttrs()
{
AssertSanity(TFooAttrs);
return (*(ptr_FooAttrs()));
}
const FooAttrs&
get_FooAttrs() const
{
AssertSanity(TFooAttrs);
return (*(constptr_FooAttrs()));
}
operator FooAttrs&()
{
return get_FooAttrs();
}
operator const FooAttrs&() const
{
return get_FooAttrs();
}
BarAttrs&
get_BarAttrs()
{
AssertSanity(TBarAttrs);
return (*(ptr_BarAttrs()));
}
const BarAttrs&
get_BarAttrs() const
{
AssertSanity(TBarAttrs);
return (*(constptr_BarAttrs()));
}
operator BarAttrs&()
{
return get_BarAttrs();
}
operator const BarAttrs&() const
{
return get_BarAttrs();
}
private:
Value mValue;
Type mType;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::SpecificAttrs>
{
typedef ::mozilla::_foo::SpecificAttrs 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 Attrs|
//
namespace mozilla {
namespace _foo {
class Attrs final
{
private:
typedef ::mozilla::_foo::CommonAttrs CommonAttrs;
typedef ::mozilla::_foo::SpecificAttrs SpecificAttrs;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
Attrs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT Attrs(
const CommonAttrs& _common,
const SpecificAttrs& _specific) :
common_(_common),
specific_(_specific)
{
}
MOZ_IMPLICIT Attrs(
CommonAttrs&& _common,
SpecificAttrs&& _specific) :
common_(std::move(_common)),
specific_(std::move(_specific))
{
}
CommonAttrs&
common()
{
return common_;
}
const CommonAttrs&
common() const
{
return common_;
}
SpecificAttrs&
specific()
{
return specific_;
}
const SpecificAttrs&
specific() const
{
return specific_;
}
private:
::mozilla::ipc::IPDLStructMember<CommonAttrs> common_;
::mozilla::ipc::IPDLStructMember<SpecificAttrs> specific_;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::Attrs>
{
typedef ::mozilla::_foo::Attrs paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubParent;
} // namespace _ipdltest
} // namespace mozilla
namespace mozilla {
namespace _ipdltest {
class PTestDataStructuresSubChild;
} // namespace _ipdltest
} // namespace mozilla
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SetAttrs|
//
namespace mozilla {
namespace _foo {
class SetAttrs final
{
private:
typedef ::mozilla::_ipdltest::PTestDataStructuresSubParent PTestDataStructuresSubParent;
typedef ::mozilla::_ipdltest::PTestDataStructuresSubChild PTestDataStructuresSubChild;
typedef ::mozilla::_foo::Attrs Attrs;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
SetAttrs() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT SetAttrs(
const mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>& _x,
const Attrs& _attrs) :
x_(_x),
attrs_(_attrs)
{
}
MOZ_IMPLICIT SetAttrs(
mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>&& _x,
Attrs&& _attrs) :
x_(std::move(_x)),
attrs_(std::move(_attrs))
{
}
mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>&
x()
{
return x_;
}
const mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>&
x() const
{
return x_;
}
Attrs&
attrs()
{
return attrs_;
}
const Attrs&
attrs() const
{
return attrs_;
}
private:
::mozilla::ipc::IPDLStructMember<mozilla::NotNull<::mozilla::ipc::SideVariant<PTestDataStructuresSubParent*, PTestDataStructuresSubChild*>>> x_;
::mozilla::ipc::IPDLStructMember<Attrs> attrs_;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::SetAttrs>
{
typedef ::mozilla::_foo::SetAttrs 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 Op|
//
namespace mozilla {
namespace _foo {
class Op final
{
public:
enum Type {
T__None,
Tnull_t = 1,
TSetAttrs,
T__Last = TSetAttrs
};
private:
typedef ::mozilla::null_t null_t;
typedef ::mozilla::_foo::SetAttrs SetAttrs;
typedef null_t null_t__tdef;
typedef SetAttrs SetAttrs__tdef;
union Value {
mozilla::AlignedStorage2<null_t> Vnull_t;
mozilla::AlignedStorage2<SetAttrs> VSetAttrs;
};
null_t*
ptr_null_t()
{
return ((mValue).Vnull_t).addr();
}
const null_t*
constptr_null_t() const
{
return ((mValue).Vnull_t).addr();
}
SetAttrs*
ptr_SetAttrs()
{
return ((mValue).VSetAttrs).addr();
}
const SetAttrs*
constptr_SetAttrs() const
{
return ((mValue).VSetAttrs).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 Op() :
mType(T__None)
{
}
MOZ_IMPLICIT Op(const null_t& aOther);
MOZ_IMPLICIT Op(null_t&& aOther);
MOZ_IMPLICIT Op(const SetAttrs& aOther);
MOZ_IMPLICIT Op(SetAttrs&& aOther);
MOZ_IMPLICIT Op(const Op& aOther);
MOZ_IMPLICIT Op(Op&& aOther);
~Op();
Type
type() const
{
return mType;
}
Op&
operator=(const null_t& aRhs);
Op&
operator=(null_t&& aRhs);
Op&
operator=(const SetAttrs& aRhs);
Op&
operator=(SetAttrs&& aRhs);
Op&
operator=(const Op& aRhs);
Op&
operator=(Op&& aRhs);
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();
}
SetAttrs&
get_SetAttrs()
{
AssertSanity(TSetAttrs);
return (*(ptr_SetAttrs()));
}
const SetAttrs&
get_SetAttrs() const
{
AssertSanity(TSetAttrs);
return (*(constptr_SetAttrs()));
}
operator SetAttrs&()
{
return get_SetAttrs();
}
operator const SetAttrs&() const
{
return get_SetAttrs();
}
private:
Value mValue;
Type mType;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::Op>
{
typedef ::mozilla::_foo::Op 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 ShmemStruct|
//
namespace mozilla {
namespace _foo {
class ShmemStruct final
{
private:
typedef ::mozilla::ipc::Shmem Shmem;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ShmemStruct() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ShmemStruct(
const int& _i,
Shmem& _mem) :
i_(_i),
mem_(_mem)
{
}
MOZ_IMPLICIT ShmemStruct(
int&& _i,
Shmem&& _mem) :
i_(std::move(_i)),
mem_(std::move(_mem))
{
}
int&
i()
{
return i_;
}
const int&
i() const
{
return i_;
}
Shmem&
mem()
{
return mem_;
}
Shmem&
mem() const
{
return const_cast<Shmem&>(mem_);
}
private:
::mozilla::ipc::IPDLStructMember<int> i_;
::mozilla::ipc::IPDLStructMember<Shmem> mem_;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::ShmemStruct>
{
typedef ::mozilla::_foo::ShmemStruct 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 ShmemUnion|
//
namespace mozilla {
namespace _foo {
class ShmemUnion final
{
public:
enum Type {
T__None,
Tint = 1,
TShmem,
T__Last = TShmem
};
private:
typedef ::mozilla::ipc::Shmem Shmem;
typedef int int__tdef;
typedef Shmem Shmem__tdef;
union Value {
mozilla::AlignedStorage2<int> Vint;
mozilla::AlignedStorage2<Shmem> VShmem;
};
int*
ptr_int()
{
return ((mValue).Vint).addr();
}
const int*
constptr_int() const
{
return ((mValue).Vint).addr();
}
Shmem*
ptr_Shmem()
{
return ((mValue).VShmem).addr();
}
const Shmem*
constptr_Shmem() const
{
return ((mValue).VShmem).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 ShmemUnion() :
mType(T__None)
{
}
MOZ_IMPLICIT ShmemUnion(const int& aOther);
MOZ_IMPLICIT ShmemUnion(int&& aOther);
MOZ_IMPLICIT ShmemUnion(Shmem& aOther);
MOZ_IMPLICIT ShmemUnion(Shmem&& aOther);
MOZ_IMPLICIT ShmemUnion(const ShmemUnion& aOther);
MOZ_IMPLICIT ShmemUnion(ShmemUnion&& aOther);
~ShmemUnion();
Type
type() const
{
return mType;
}
ShmemUnion&
operator=(const int& aRhs);
ShmemUnion&
operator=(int&& aRhs);
ShmemUnion&
operator=(Shmem& aRhs);
ShmemUnion&
operator=(Shmem&& aRhs);
ShmemUnion&
operator=(const ShmemUnion& aRhs);
ShmemUnion&
operator=(ShmemUnion&& aRhs);
int&
get_int()
{
AssertSanity(Tint);
return (*(ptr_int()));
}
const int&
get_int() const
{
AssertSanity(Tint);
return (*(constptr_int()));
}
operator int&()
{
return get_int();
}
operator const int&() const
{
return get_int();
}
Shmem&
get_Shmem()
{
AssertSanity(TShmem);
return (*(ptr_Shmem()));
}
Shmem&
get_Shmem() const
{
AssertSanity(TShmem);
return const_cast<Shmem&>((*(constptr_Shmem())));
}
operator Shmem&()
{
return get_Shmem();
}
operator Shmem&() const
{
return get_Shmem();
}
private:
Value mValue;
Type mType;
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::ShmemUnion>
{
typedef ::mozilla::_foo::ShmemUnion 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 Empty|
//
namespace mozilla {
namespace _foo {
class Empty final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
Empty() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
private:
};
} // namespace _foo
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::_foo::Empty>
{
typedef ::mozilla::_foo::Empty paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
#endif // ifndef PTestDataStructuresCommon_h