Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PDigitalCredential_h
#define PDigitalCredential_h
#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"
// Headers for typedefs
#include "mozilla/ipc/IPDLStructMember.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCDigitalCredentialRequest|
//
namespace mozilla {
namespace dom {
class IPCDigitalCredentialRequest final
{
private:
typedef ::nsString nsString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IPCDigitalCredentialRequest() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IPCDigitalCredentialRequest(
const nsString& _proto,
const nsString& _data) :
proto_(_proto),
data_(_data)
{
}
MOZ_IMPLICIT IPCDigitalCredentialRequest(
nsString&& _proto,
nsString&& _data) :
proto_(std::move(_proto)),
data_(std::move(_data))
{
}
nsString&
proto()
{
return proto_;
}
const nsString&
proto() const
{
return proto_;
}
nsString&
data()
{
return data_;
}
const nsString&
data() const
{
return data_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> proto_;
::mozilla::ipc::IPDLStructMember<nsString> data_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCDigitalCredentialRequest>
{
typedef ::mozilla::dom::IPCDigitalCredentialRequest 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 IPCDigitalCredential|
//
namespace mozilla {
namespace dom {
class IPCDigitalCredential final
{
private:
typedef ::nsString nsString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IPCDigitalCredential() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IPCDigitalCredential(
const nsString& _proto,
const nsString& _data) :
proto_(_proto),
data_(_data)
{
}
MOZ_IMPLICIT IPCDigitalCredential(
nsString&& _proto,
nsString&& _data) :
proto_(std::move(_proto)),
data_(std::move(_data))
{
}
nsString&
proto()
{
return proto_;
}
const nsString&
proto() const
{
return proto_;
}
nsString&
data()
{
return data_;
}
const nsString&
data() const
{
return data_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> proto_;
::mozilla::ipc::IPDLStructMember<nsString> data_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCDigitalCredential>
{
typedef ::mozilla::dom::IPCDigitalCredential 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 IPCDigitalCredentialResponse|
//
namespace mozilla {
namespace dom {
class IPCDigitalCredentialResponse final
{
public:
enum Type {
T__None,
Tnsresult = 1,
TIPCDigitalCredential,
T__Last = TIPCDigitalCredential
};
private:
typedef ::nsresult nsresult;
typedef ::mozilla::dom::IPCDigitalCredential IPCDigitalCredential;
typedef nsresult nsresult__tdef;
typedef IPCDigitalCredential IPCDigitalCredential__tdef;
nsresult*
ptr_nsresult()
{
return (&(mVnsresult));
}
const nsresult*
constptr_nsresult() const
{
return (&(mVnsresult));
}
IPCDigitalCredential*
ptr_IPCDigitalCredential()
{
return (&(mVIPCDigitalCredential));
}
const IPCDigitalCredential*
constptr_IPCDigitalCredential() const
{
return (&(mVIPCDigitalCredential));
}
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 IPCDigitalCredentialResponse() :
mType(T__None)
{
}
MOZ_IMPLICIT IPCDigitalCredentialResponse(const nsresult& aOther);
MOZ_IMPLICIT IPCDigitalCredentialResponse(nsresult&& aOther);
MOZ_IMPLICIT IPCDigitalCredentialResponse(const IPCDigitalCredential& aOther);
MOZ_IMPLICIT IPCDigitalCredentialResponse(IPCDigitalCredential&& aOther);
MOZ_IMPLICIT IPCDigitalCredentialResponse(const IPCDigitalCredentialResponse& aOther);
MOZ_IMPLICIT IPCDigitalCredentialResponse(IPCDigitalCredentialResponse&& aOther);
~IPCDigitalCredentialResponse();
Type
type() const
{
return mType;
}
IPCDigitalCredentialResponse&
operator=(const nsresult& aRhs);
IPCDigitalCredentialResponse&
operator=(nsresult&& aRhs);
IPCDigitalCredentialResponse&
operator=(const IPCDigitalCredential& aRhs);
IPCDigitalCredentialResponse&
operator=(IPCDigitalCredential&& aRhs);
IPCDigitalCredentialResponse&
operator=(const IPCDigitalCredentialResponse& aRhs);
IPCDigitalCredentialResponse&
operator=(IPCDigitalCredentialResponse&& aRhs);
nsresult&
get_nsresult()
{
AssertSanity(Tnsresult);
return (*(ptr_nsresult()));
}
const nsresult&
get_nsresult() const
{
AssertSanity(Tnsresult);
return (*(constptr_nsresult()));
}
operator nsresult&()
{
return get_nsresult();
}
operator const nsresult&() const
{
return get_nsresult();
}
IPCDigitalCredential&
get_IPCDigitalCredential()
{
AssertSanity(TIPCDigitalCredential);
return (*(ptr_IPCDigitalCredential()));
}
const IPCDigitalCredential&
get_IPCDigitalCredential() const
{
AssertSanity(TIPCDigitalCredential);
return (*(constptr_IPCDigitalCredential()));
}
operator IPCDigitalCredential&()
{
return get_IPCDigitalCredential();
}
operator const IPCDigitalCredential&() const
{
return get_IPCDigitalCredential();
}
private:
union {
nsresult mVnsresult;
IPCDigitalCredential mVIPCDigitalCredential;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCDigitalCredentialResponse>
{
typedef ::mozilla::dom::IPCDigitalCredentialResponse 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 PDigitalCredentialParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PDigitalCredentialChild;
} // namespace dom
} // namespace mozilla
//-----------------------------------------------------------------------------
// Code common to PDigitalCredentialChild and PDigitalCredentialParent
//
namespace mozilla {
namespace dom {
namespace PDigitalCredential {
nsresult
CreateEndpoints(
mozilla::ipc::EndpointProcInfo aParentDestInfo,
mozilla::ipc::EndpointProcInfo aChildDestInfo,
mozilla::ipc::Endpoint<::mozilla::dom::PDigitalCredentialParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PDigitalCredentialChild>* aChild);
nsresult
CreateEndpoints(
mozilla::ipc::Endpoint<::mozilla::dom::PDigitalCredentialParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PDigitalCredentialChild>* aChild);
enum MessageType {
PDigitalCredentialStart = PDigitalCredentialMsgStart << 16,
Msg_GetDigitalCredential__ID,
Reply_GetDigitalCredential__ID,
Msg_CreateDigitalCredential__ID,
Reply_CreateDigitalCredential__ID,
Msg_CancelOperationInParent__ID,
Msg___delete____ID,
Reply___delete____ID,
PDigitalCredentialEnd
};
mozilla::UniquePtr<IPC::Message>
Msg_GetDigitalCredential(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_GetDigitalCredential(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_CreateDigitalCredential(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_CreateDigitalCredential(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_CancelOperationInParent(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg___delete__(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(IPC::Message::routeid_t routingId);
} // namespace PDigitalCredential
} // namespace dom
} // namespace mozilla
#endif // ifndef PDigitalCredential_h