hondacrx
2525 lines
80 KiB
C#
2525 lines
80 KiB
C#
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: bgs/low/pb/client/challenge_service.proto
|
|
#pragma warning disable 1591, 0612, 3021
|
|
#region Designer generated code
|
|
|
|
using pb = Google.Protobuf;
|
|
using pbc = Google.Protobuf.Collections;
|
|
using pbr = Google.Protobuf.Reflection;
|
|
namespace Bgs.Protocol.Challenge.V1
|
|
{
|
|
|
|
/// <summary>Holder for reflection information generated from bgs/low/pb/client/challenge_service.proto</summary>
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public static partial class ChallengeServiceReflection
|
|
{
|
|
#region Descriptor
|
|
/// <summary>File descriptor for bgs/low/pb/client/challenge_service.proto</summary>
|
|
public static pbr::FileDescriptor Descriptor
|
|
{
|
|
get { return descriptor; }
|
|
}
|
|
private static pbr::FileDescriptor descriptor;
|
|
|
|
static ChallengeServiceReflection()
|
|
{
|
|
byte[] descriptorData = System.Convert.FromBase64String(
|
|
string.Concat(
|
|
"CiliZ3MvbG93L3BiL2NsaWVudC9jaGFsbGVuZ2Vfc2VydmljZS5wcm90bxIZ",
|
|
"YmdzLnByb3RvY29sLmNoYWxsZW5nZS52MRonYmdzL2xvdy9wYi9jbGllbnQv",
|
|
"YXR0cmlidXRlX3R5cGVzLnByb3RvGiRiZ3MvbG93L3BiL2NsaWVudC9lbnRp",
|
|
"dHlfdHlwZXMucHJvdG8aIWJncy9sb3cvcGIvY2xpZW50L3JwY190eXBlcy5w",
|
|
"cm90byJICglDaGFsbGVuZ2USDAoEdHlwZRgBIAEoBxIMCgRpbmZvGAIgASgJ",
|
|
"Eg4KBmFuc3dlchgDIAEoCRIPCgdyZXRyaWVzGAQgASgNIlcKFkNoYWxsZW5n",
|
|
"ZVBpY2tlZFJlcXVlc3QSEQoJY2hhbGxlbmdlGAEgASgHEgoKAmlkGAIgASgN",
|
|
"Eh4KFm5ld19jaGFsbGVuZ2VfcHJvdG9jb2wYAyABKAgiJwoXQ2hhbGxlbmdl",
|
|
"UGlja2VkUmVzcG9uc2USDAoEZGF0YRgBIAEoDCJEChhDaGFsbGVuZ2VBbnN3",
|
|
"ZXJlZFJlcXVlc3QSDgoGYW5zd2VyGAEgASgJEgwKBGRhdGEYAiABKAwSCgoC",
|
|
"aWQYAyABKA0iVQoZQ2hhbGxlbmdlQW5zd2VyZWRSZXNwb25zZRIMCgRkYXRh",
|
|
"GAEgASgMEhAKCGRvX3JldHJ5GAIgASgIEhgKEHJlY29yZF9ub3RfZm91bmQY",
|
|
"AyABKAgiJwoZQ2hhbGxlbmdlQ2FuY2VsbGVkUmVxdWVzdBIKCgJpZBgBIAEo",
|
|
"DSLTAgoaU2VuZENoYWxsZW5nZVRvVXNlclJlcXVlc3QSKAoHcGVlcl9pZBgB",
|
|
"IAEoCzIXLmJncy5wcm90b2NvbC5Qcm9jZXNzSWQSLwoPZ2FtZV9hY2NvdW50",
|
|
"X2lkGAIgASgLMhYuYmdzLnByb3RvY29sLkVudGl0eUlkEjgKCmNoYWxsZW5n",
|
|
"ZXMYAyADKAsyJC5iZ3MucHJvdG9jb2wuY2hhbGxlbmdlLnYxLkNoYWxsZW5n",
|
|
"ZRIPCgdjb250ZXh0GAQgASgHEg8KB3RpbWVvdXQYBSABKAQSKwoKYXR0cmli",
|
|
"dXRlcxgGIAMoCzIXLmJncy5wcm90b2NvbC5BdHRyaWJ1dGUSJQoEaG9zdBgH",
|
|
"IAEoCzIXLmJncy5wcm90b2NvbC5Qcm9jZXNzSWQSKgoKYWNjb3VudF9pZBgI",
|
|
"IAEoCzIWLmJncy5wcm90b2NvbC5FbnRpdHlJZCIpChtTZW5kQ2hhbGxlbmdl",
|
|
"VG9Vc2VyUmVzcG9uc2USCgoCaWQYASABKA0i3QEKFENoYWxsZW5nZVVzZXJS",
|
|
"ZXF1ZXN0EjgKCmNoYWxsZW5nZXMYASADKAsyJC5iZ3MucHJvdG9jb2wuY2hh",
|
|
"bGxlbmdlLnYxLkNoYWxsZW5nZRIPCgdjb250ZXh0GAIgASgHEgoKAmlkGAMg",
|
|
"ASgNEhAKCGRlYWRsaW5lGAQgASgEEisKCmF0dHJpYnV0ZXMYBSADKAsyFy5i",
|
|
"Z3MucHJvdG9jb2wuQXR0cmlidXRlEi8KD2dhbWVfYWNjb3VudF9pZBgGIAEo",
|
|
"CzIWLmJncy5wcm90b2NvbC5FbnRpdHlJZCJUChZDaGFsbGVuZ2VSZXN1bHRS",
|
|
"ZXF1ZXN0EgoKAmlkGAEgASgNEgwKBHR5cGUYAiABKAcSEAoIZXJyb3JfaWQY",
|
|
"AyABKA0SDgoGYW5zd2VyGAQgASgMIlgKGENoYWxsZW5nZUV4dGVybmFsUmVx",
|
|
"dWVzdBIVCg1yZXF1ZXN0X3Rva2VuGAEgASgJEhQKDHBheWxvYWRfdHlwZRgC",
|
|
"IAEoCRIPCgdwYXlsb2FkGAMgASgMIkAKF0NoYWxsZW5nZUV4dGVybmFsUmVz",
|
|
"dWx0EhUKDXJlcXVlc3RfdG9rZW4YASABKAkSDgoGcGFzc2VkGAIgASgIMvUD",
|
|
"ChBDaGFsbGVuZ2VTZXJ2aWNlEngKD0NoYWxsZW5nZVBpY2tlZBIxLmJncy5w",
|
|
"cm90b2NvbC5jaGFsbGVuZ2UudjEuQ2hhbGxlbmdlUGlja2VkUmVxdWVzdBoy",
|
|
"LmJncy5wcm90b2NvbC5jaGFsbGVuZ2UudjEuQ2hhbGxlbmdlUGlja2VkUmVz",
|
|
"cG9uc2USfgoRQ2hhbGxlbmdlQW5zd2VyZWQSMy5iZ3MucHJvdG9jb2wuY2hh",
|
|
"bGxlbmdlLnYxLkNoYWxsZW5nZUFuc3dlcmVkUmVxdWVzdBo0LmJncy5wcm90",
|
|
"b2NvbC5jaGFsbGVuZ2UudjEuQ2hhbGxlbmdlQW5zd2VyZWRSZXNwb25zZRJg",
|
|
"ChJDaGFsbGVuZ2VDYW5jZWxsZWQSNC5iZ3MucHJvdG9jb2wuY2hhbGxlbmdl",
|
|
"LnYxLkNoYWxsZW5nZUNhbmNlbGxlZFJlcXVlc3QaFC5iZ3MucHJvdG9jb2wu",
|
|
"Tm9EYXRhEoQBChNTZW5kQ2hhbGxlbmdlVG9Vc2VyEjUuYmdzLnByb3RvY29s",
|
|
"LmNoYWxsZW5nZS52MS5TZW5kQ2hhbGxlbmdlVG9Vc2VyUmVxdWVzdBo2LmJn",
|
|
"cy5wcm90b2NvbC5jaGFsbGVuZ2UudjEuU2VuZENoYWxsZW5nZVRvVXNlclJl",
|
|
"c3BvbnNlMqgDChFDaGFsbGVuZ2VMaXN0ZW5lchJdCg9PbkNoYWxsZW5nZVVz",
|
|
"ZXISLy5iZ3MucHJvdG9jb2wuY2hhbGxlbmdlLnYxLkNoYWxsZW5nZVVzZXJS",
|
|
"ZXF1ZXN0GhkuYmdzLnByb3RvY29sLk5PX1JFU1BPTlNFEmEKEU9uQ2hhbGxl",
|
|
"bmdlUmVzdWx0EjEuYmdzLnByb3RvY29sLmNoYWxsZW5nZS52MS5DaGFsbGVu",
|
|
"Z2VSZXN1bHRSZXF1ZXN0GhkuYmdzLnByb3RvY29sLk5PX1JFU1BPTlNFEmUK",
|
|
"E09uRXh0ZXJuYWxDaGFsbGVuZ2USMy5iZ3MucHJvdG9jb2wuY2hhbGxlbmdl",
|
|
"LnYxLkNoYWxsZW5nZUV4dGVybmFsUmVxdWVzdBoZLmJncy5wcm90b2NvbC5O",
|
|
"T19SRVNQT05TRRJqChlPbkV4dGVybmFsQ2hhbGxlbmdlUmVzdWx0EjIuYmdz",
|
|
"LnByb3RvY29sLmNoYWxsZW5nZS52MS5DaGFsbGVuZ2VFeHRlcm5hbFJlc3Vs",
|
|
"dBoZLmJncy5wcm90b2NvbC5OT19SRVNQT05TRUIFSAKAAQBiBnByb3RvMw=="));
|
|
descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
|
|
new pbr::FileDescriptor[] { Bgs.Protocol.AttributeTypesReflection.Descriptor, Bgs.Protocol.EntityTypesReflection.Descriptor, Bgs.Protocol.RpcTypesReflection.Descriptor, },
|
|
new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Challenge.V1.Challenge), Bgs.Protocol.Challenge.V1.Challenge.Parser, new[]{ "Type", "Info", "Answer", "Retries" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Challenge.V1.ChallengePickedRequest), Bgs.Protocol.Challenge.V1.ChallengePickedRequest.Parser, new[]{ "Challenge", "Id", "NewChallengeProtocol" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Challenge.V1.ChallengePickedResponse), Bgs.Protocol.Challenge.V1.ChallengePickedResponse.Parser, new[]{ "Data" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Challenge.V1.ChallengeAnsweredRequest), Bgs.Protocol.Challenge.V1.ChallengeAnsweredRequest.Parser, new[]{ "Answer", "Data", "Id" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Challenge.V1.ChallengeAnsweredResponse), Bgs.Protocol.Challenge.V1.ChallengeAnsweredResponse.Parser, new[]{ "Data", "DoRetry", "RecordNotFound" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Challenge.V1.ChallengeCancelledRequest), Bgs.Protocol.Challenge.V1.ChallengeCancelledRequest.Parser, new[]{ "Id" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Challenge.V1.SendChallengeToUserRequest), Bgs.Protocol.Challenge.V1.SendChallengeToUserRequest.Parser, new[]{ "PeerId", "GameAccountId", "Challenges", "Context", "Timeout", "Attributes", "Host", "AccountId" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Challenge.V1.SendChallengeToUserResponse), Bgs.Protocol.Challenge.V1.SendChallengeToUserResponse.Parser, new[]{ "Id" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Challenge.V1.ChallengeUserRequest), Bgs.Protocol.Challenge.V1.ChallengeUserRequest.Parser, new[]{ "Challenges", "Context", "Id", "Deadline", "Attributes", "GameAccountId" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Challenge.V1.ChallengeResultRequest), Bgs.Protocol.Challenge.V1.ChallengeResultRequest.Parser, new[]{ "Id", "Type", "ErrorId", "Answer" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Challenge.V1.ChallengeExternalRequest), Bgs.Protocol.Challenge.V1.ChallengeExternalRequest.Parser, new[]{ "RequestToken", "PayloadType", "Payload" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Challenge.V1.ChallengeExternalResult), Bgs.Protocol.Challenge.V1.ChallengeExternalResult.Parser, new[]{ "RequestToken", "Passed" }, null, null, null)
|
|
}));
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
#region Messages
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class Challenge : pb::IMessage<Challenge>
|
|
{
|
|
private static readonly pb::MessageParser<Challenge> _parser = new pb::MessageParser<Challenge>(() => new Challenge());
|
|
public static pb::MessageParser<Challenge> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Challenge.V1.ChallengeServiceReflection.Descriptor.MessageTypes[0]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public Challenge()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public Challenge(Challenge other) : this()
|
|
{
|
|
type_ = other.type_;
|
|
info_ = other.info_;
|
|
answer_ = other.answer_;
|
|
retries_ = other.retries_;
|
|
}
|
|
|
|
public Challenge Clone()
|
|
{
|
|
return new Challenge(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "type" field.</summary>
|
|
public const int TypeFieldNumber = 1;
|
|
private uint type_;
|
|
public uint Type
|
|
{
|
|
get { return type_; }
|
|
set
|
|
{
|
|
type_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "info" field.</summary>
|
|
public const int InfoFieldNumber = 2;
|
|
private string info_ = "";
|
|
public string Info
|
|
{
|
|
get { return info_; }
|
|
set
|
|
{
|
|
info_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "answer" field.</summary>
|
|
public const int AnswerFieldNumber = 3;
|
|
private string answer_ = "";
|
|
public string Answer
|
|
{
|
|
get { return answer_; }
|
|
set
|
|
{
|
|
answer_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "retries" field.</summary>
|
|
public const int RetriesFieldNumber = 4;
|
|
private uint retries_;
|
|
public uint Retries
|
|
{
|
|
get { return retries_; }
|
|
set
|
|
{
|
|
retries_ = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as Challenge);
|
|
}
|
|
|
|
public bool Equals(Challenge other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (Type != other.Type) return false;
|
|
if (Info != other.Info) return false;
|
|
if (Answer != other.Answer) return false;
|
|
if (Retries != other.Retries) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (Type != 0) hash ^= Type.GetHashCode();
|
|
if (Info.Length != 0) hash ^= Info.GetHashCode();
|
|
if (Answer.Length != 0) hash ^= Answer.GetHashCode();
|
|
if (Retries != 0) hash ^= Retries.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (Type != 0)
|
|
{
|
|
output.WriteRawTag(13);
|
|
output.WriteFixed32(Type);
|
|
}
|
|
if (Info.Length != 0)
|
|
{
|
|
output.WriteRawTag(18);
|
|
output.WriteString(Info);
|
|
}
|
|
if (Answer.Length != 0)
|
|
{
|
|
output.WriteRawTag(26);
|
|
output.WriteString(Answer);
|
|
}
|
|
if (Retries != 0)
|
|
{
|
|
output.WriteRawTag(32);
|
|
output.WriteUInt32(Retries);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (Type != 0)
|
|
{
|
|
size += 1 + 4;
|
|
}
|
|
if (Info.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeStringSize(Info);
|
|
}
|
|
if (Answer.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeStringSize(Answer);
|
|
}
|
|
if (Retries != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Retries);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(Challenge other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.Type != 0)
|
|
{
|
|
Type = other.Type;
|
|
}
|
|
if (other.Info.Length != 0)
|
|
{
|
|
Info = other.Info;
|
|
}
|
|
if (other.Answer.Length != 0)
|
|
{
|
|
Answer = other.Answer;
|
|
}
|
|
if (other.Retries != 0)
|
|
{
|
|
Retries = other.Retries;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 13:
|
|
{
|
|
Type = input.ReadFixed32();
|
|
break;
|
|
}
|
|
case 18:
|
|
{
|
|
Info = input.ReadString();
|
|
break;
|
|
}
|
|
case 26:
|
|
{
|
|
Answer = input.ReadString();
|
|
break;
|
|
}
|
|
case 32:
|
|
{
|
|
Retries = input.ReadUInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class ChallengePickedRequest : pb::IMessage<ChallengePickedRequest>
|
|
{
|
|
private static readonly pb::MessageParser<ChallengePickedRequest> _parser = new pb::MessageParser<ChallengePickedRequest>(() => new ChallengePickedRequest());
|
|
public static pb::MessageParser<ChallengePickedRequest> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Challenge.V1.ChallengeServiceReflection.Descriptor.MessageTypes[1]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public ChallengePickedRequest()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public ChallengePickedRequest(ChallengePickedRequest other) : this()
|
|
{
|
|
challenge_ = other.challenge_;
|
|
id_ = other.id_;
|
|
newChallengeProtocol_ = other.newChallengeProtocol_;
|
|
}
|
|
|
|
public ChallengePickedRequest Clone()
|
|
{
|
|
return new ChallengePickedRequest(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "challenge" field.</summary>
|
|
public const int ChallengeFieldNumber = 1;
|
|
private uint challenge_;
|
|
public uint Challenge
|
|
{
|
|
get { return challenge_; }
|
|
set
|
|
{
|
|
challenge_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "id" field.</summary>
|
|
public const int IdFieldNumber = 2;
|
|
private uint id_;
|
|
public uint Id
|
|
{
|
|
get { return id_; }
|
|
set
|
|
{
|
|
id_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "new_challenge_protocol" field.</summary>
|
|
public const int NewChallengeProtocolFieldNumber = 3;
|
|
private bool newChallengeProtocol_;
|
|
public bool NewChallengeProtocol
|
|
{
|
|
get { return newChallengeProtocol_; }
|
|
set
|
|
{
|
|
newChallengeProtocol_ = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as ChallengePickedRequest);
|
|
}
|
|
|
|
public bool Equals(ChallengePickedRequest other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (Challenge != other.Challenge) return false;
|
|
if (Id != other.Id) return false;
|
|
if (NewChallengeProtocol != other.NewChallengeProtocol) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (Challenge != 0) hash ^= Challenge.GetHashCode();
|
|
if (Id != 0) hash ^= Id.GetHashCode();
|
|
if (NewChallengeProtocol != false) hash ^= NewChallengeProtocol.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (Challenge != 0)
|
|
{
|
|
output.WriteRawTag(13);
|
|
output.WriteFixed32(Challenge);
|
|
}
|
|
if (Id != 0)
|
|
{
|
|
output.WriteRawTag(16);
|
|
output.WriteUInt32(Id);
|
|
}
|
|
if (NewChallengeProtocol != false)
|
|
{
|
|
output.WriteRawTag(24);
|
|
output.WriteBool(NewChallengeProtocol);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (Challenge != 0)
|
|
{
|
|
size += 1 + 4;
|
|
}
|
|
if (Id != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Id);
|
|
}
|
|
if (NewChallengeProtocol != false)
|
|
{
|
|
size += 1 + 1;
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(ChallengePickedRequest other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.Challenge != 0)
|
|
{
|
|
Challenge = other.Challenge;
|
|
}
|
|
if (other.Id != 0)
|
|
{
|
|
Id = other.Id;
|
|
}
|
|
if (other.NewChallengeProtocol != false)
|
|
{
|
|
NewChallengeProtocol = other.NewChallengeProtocol;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 13:
|
|
{
|
|
Challenge = input.ReadFixed32();
|
|
break;
|
|
}
|
|
case 16:
|
|
{
|
|
Id = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 24:
|
|
{
|
|
NewChallengeProtocol = input.ReadBool();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class ChallengePickedResponse : pb::IMessage<ChallengePickedResponse>
|
|
{
|
|
private static readonly pb::MessageParser<ChallengePickedResponse> _parser = new pb::MessageParser<ChallengePickedResponse>(() => new ChallengePickedResponse());
|
|
public static pb::MessageParser<ChallengePickedResponse> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Challenge.V1.ChallengeServiceReflection.Descriptor.MessageTypes[2]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public ChallengePickedResponse()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public ChallengePickedResponse(ChallengePickedResponse other) : this()
|
|
{
|
|
data_ = other.data_;
|
|
}
|
|
|
|
public ChallengePickedResponse Clone()
|
|
{
|
|
return new ChallengePickedResponse(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "data" field.</summary>
|
|
public const int DataFieldNumber = 1;
|
|
private pb::ByteString data_ = pb::ByteString.Empty;
|
|
public pb::ByteString Data
|
|
{
|
|
get { return data_; }
|
|
set
|
|
{
|
|
data_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as ChallengePickedResponse);
|
|
}
|
|
|
|
public bool Equals(ChallengePickedResponse other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (Data != other.Data) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (Data.Length != 0) hash ^= Data.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (Data.Length != 0)
|
|
{
|
|
output.WriteRawTag(10);
|
|
output.WriteBytes(Data);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (Data.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeBytesSize(Data);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(ChallengePickedResponse other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.Data.Length != 0)
|
|
{
|
|
Data = other.Data;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 10:
|
|
{
|
|
Data = input.ReadBytes();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class ChallengeAnsweredRequest : pb::IMessage<ChallengeAnsweredRequest>
|
|
{
|
|
private static readonly pb::MessageParser<ChallengeAnsweredRequest> _parser = new pb::MessageParser<ChallengeAnsweredRequest>(() => new ChallengeAnsweredRequest());
|
|
public static pb::MessageParser<ChallengeAnsweredRequest> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Challenge.V1.ChallengeServiceReflection.Descriptor.MessageTypes[3]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public ChallengeAnsweredRequest()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public ChallengeAnsweredRequest(ChallengeAnsweredRequest other) : this()
|
|
{
|
|
answer_ = other.answer_;
|
|
data_ = other.data_;
|
|
id_ = other.id_;
|
|
}
|
|
|
|
public ChallengeAnsweredRequest Clone()
|
|
{
|
|
return new ChallengeAnsweredRequest(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "answer" field.</summary>
|
|
public const int AnswerFieldNumber = 1;
|
|
private string answer_ = "";
|
|
public string Answer
|
|
{
|
|
get { return answer_; }
|
|
set
|
|
{
|
|
answer_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "data" field.</summary>
|
|
public const int DataFieldNumber = 2;
|
|
private pb::ByteString data_ = pb::ByteString.Empty;
|
|
public pb::ByteString Data
|
|
{
|
|
get { return data_; }
|
|
set
|
|
{
|
|
data_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "id" field.</summary>
|
|
public const int IdFieldNumber = 3;
|
|
private uint id_;
|
|
public uint Id
|
|
{
|
|
get { return id_; }
|
|
set
|
|
{
|
|
id_ = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as ChallengeAnsweredRequest);
|
|
}
|
|
|
|
public bool Equals(ChallengeAnsweredRequest other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (Answer != other.Answer) return false;
|
|
if (Data != other.Data) return false;
|
|
if (Id != other.Id) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (Answer.Length != 0) hash ^= Answer.GetHashCode();
|
|
if (Data.Length != 0) hash ^= Data.GetHashCode();
|
|
if (Id != 0) hash ^= Id.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (Answer.Length != 0)
|
|
{
|
|
output.WriteRawTag(10);
|
|
output.WriteString(Answer);
|
|
}
|
|
if (Data.Length != 0)
|
|
{
|
|
output.WriteRawTag(18);
|
|
output.WriteBytes(Data);
|
|
}
|
|
if (Id != 0)
|
|
{
|
|
output.WriteRawTag(24);
|
|
output.WriteUInt32(Id);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (Answer.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeStringSize(Answer);
|
|
}
|
|
if (Data.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeBytesSize(Data);
|
|
}
|
|
if (Id != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Id);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(ChallengeAnsweredRequest other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.Answer.Length != 0)
|
|
{
|
|
Answer = other.Answer;
|
|
}
|
|
if (other.Data.Length != 0)
|
|
{
|
|
Data = other.Data;
|
|
}
|
|
if (other.Id != 0)
|
|
{
|
|
Id = other.Id;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 10:
|
|
{
|
|
Answer = input.ReadString();
|
|
break;
|
|
}
|
|
case 18:
|
|
{
|
|
Data = input.ReadBytes();
|
|
break;
|
|
}
|
|
case 24:
|
|
{
|
|
Id = input.ReadUInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class ChallengeAnsweredResponse : pb::IMessage<ChallengeAnsweredResponse>
|
|
{
|
|
private static readonly pb::MessageParser<ChallengeAnsweredResponse> _parser = new pb::MessageParser<ChallengeAnsweredResponse>(() => new ChallengeAnsweredResponse());
|
|
public static pb::MessageParser<ChallengeAnsweredResponse> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Challenge.V1.ChallengeServiceReflection.Descriptor.MessageTypes[4]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public ChallengeAnsweredResponse()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public ChallengeAnsweredResponse(ChallengeAnsweredResponse other) : this()
|
|
{
|
|
data_ = other.data_;
|
|
doRetry_ = other.doRetry_;
|
|
recordNotFound_ = other.recordNotFound_;
|
|
}
|
|
|
|
public ChallengeAnsweredResponse Clone()
|
|
{
|
|
return new ChallengeAnsweredResponse(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "data" field.</summary>
|
|
public const int DataFieldNumber = 1;
|
|
private pb::ByteString data_ = pb::ByteString.Empty;
|
|
public pb::ByteString Data
|
|
{
|
|
get { return data_; }
|
|
set
|
|
{
|
|
data_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "do_retry" field.</summary>
|
|
public const int DoRetryFieldNumber = 2;
|
|
private bool doRetry_;
|
|
public bool DoRetry
|
|
{
|
|
get { return doRetry_; }
|
|
set
|
|
{
|
|
doRetry_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "record_not_found" field.</summary>
|
|
public const int RecordNotFoundFieldNumber = 3;
|
|
private bool recordNotFound_;
|
|
public bool RecordNotFound
|
|
{
|
|
get { return recordNotFound_; }
|
|
set
|
|
{
|
|
recordNotFound_ = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as ChallengeAnsweredResponse);
|
|
}
|
|
|
|
public bool Equals(ChallengeAnsweredResponse other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (Data != other.Data) return false;
|
|
if (DoRetry != other.DoRetry) return false;
|
|
if (RecordNotFound != other.RecordNotFound) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (Data.Length != 0) hash ^= Data.GetHashCode();
|
|
if (DoRetry != false) hash ^= DoRetry.GetHashCode();
|
|
if (RecordNotFound != false) hash ^= RecordNotFound.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (Data.Length != 0)
|
|
{
|
|
output.WriteRawTag(10);
|
|
output.WriteBytes(Data);
|
|
}
|
|
if (DoRetry != false)
|
|
{
|
|
output.WriteRawTag(16);
|
|
output.WriteBool(DoRetry);
|
|
}
|
|
if (RecordNotFound != false)
|
|
{
|
|
output.WriteRawTag(24);
|
|
output.WriteBool(RecordNotFound);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (Data.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeBytesSize(Data);
|
|
}
|
|
if (DoRetry != false)
|
|
{
|
|
size += 1 + 1;
|
|
}
|
|
if (RecordNotFound != false)
|
|
{
|
|
size += 1 + 1;
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(ChallengeAnsweredResponse other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.Data.Length != 0)
|
|
{
|
|
Data = other.Data;
|
|
}
|
|
if (other.DoRetry != false)
|
|
{
|
|
DoRetry = other.DoRetry;
|
|
}
|
|
if (other.RecordNotFound != false)
|
|
{
|
|
RecordNotFound = other.RecordNotFound;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 10:
|
|
{
|
|
Data = input.ReadBytes();
|
|
break;
|
|
}
|
|
case 16:
|
|
{
|
|
DoRetry = input.ReadBool();
|
|
break;
|
|
}
|
|
case 24:
|
|
{
|
|
RecordNotFound = input.ReadBool();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class ChallengeCancelledRequest : pb::IMessage<ChallengeCancelledRequest>
|
|
{
|
|
private static readonly pb::MessageParser<ChallengeCancelledRequest> _parser = new pb::MessageParser<ChallengeCancelledRequest>(() => new ChallengeCancelledRequest());
|
|
public static pb::MessageParser<ChallengeCancelledRequest> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Challenge.V1.ChallengeServiceReflection.Descriptor.MessageTypes[5]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public ChallengeCancelledRequest()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public ChallengeCancelledRequest(ChallengeCancelledRequest other) : this()
|
|
{
|
|
id_ = other.id_;
|
|
}
|
|
|
|
public ChallengeCancelledRequest Clone()
|
|
{
|
|
return new ChallengeCancelledRequest(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "id" field.</summary>
|
|
public const int IdFieldNumber = 1;
|
|
private uint id_;
|
|
public uint Id
|
|
{
|
|
get { return id_; }
|
|
set
|
|
{
|
|
id_ = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as ChallengeCancelledRequest);
|
|
}
|
|
|
|
public bool Equals(ChallengeCancelledRequest other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (Id != other.Id) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (Id != 0) hash ^= Id.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (Id != 0)
|
|
{
|
|
output.WriteRawTag(8);
|
|
output.WriteUInt32(Id);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (Id != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Id);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(ChallengeCancelledRequest other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.Id != 0)
|
|
{
|
|
Id = other.Id;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 8:
|
|
{
|
|
Id = input.ReadUInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class SendChallengeToUserRequest : pb::IMessage<SendChallengeToUserRequest>
|
|
{
|
|
private static readonly pb::MessageParser<SendChallengeToUserRequest> _parser = new pb::MessageParser<SendChallengeToUserRequest>(() => new SendChallengeToUserRequest());
|
|
public static pb::MessageParser<SendChallengeToUserRequest> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Challenge.V1.ChallengeServiceReflection.Descriptor.MessageTypes[6]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public SendChallengeToUserRequest()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public SendChallengeToUserRequest(SendChallengeToUserRequest other) : this()
|
|
{
|
|
PeerId = other.peerId_ != null ? other.PeerId.Clone() : null;
|
|
GameAccountId = other.gameAccountId_ != null ? other.GameAccountId.Clone() : null;
|
|
challenges_ = other.challenges_.Clone();
|
|
context_ = other.context_;
|
|
timeout_ = other.timeout_;
|
|
attributes_ = other.attributes_.Clone();
|
|
Host = other.host_ != null ? other.Host.Clone() : null;
|
|
AccountId = other.accountId_ != null ? other.AccountId.Clone() : null;
|
|
}
|
|
|
|
public SendChallengeToUserRequest Clone()
|
|
{
|
|
return new SendChallengeToUserRequest(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "peer_id" field.</summary>
|
|
public const int PeerIdFieldNumber = 1;
|
|
private Bgs.Protocol.ProcessId peerId_;
|
|
public Bgs.Protocol.ProcessId PeerId
|
|
{
|
|
get { return peerId_; }
|
|
set
|
|
{
|
|
peerId_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "game_account_id" field.</summary>
|
|
public const int GameAccountIdFieldNumber = 2;
|
|
private Bgs.Protocol.EntityId gameAccountId_;
|
|
public Bgs.Protocol.EntityId GameAccountId
|
|
{
|
|
get { return gameAccountId_; }
|
|
set
|
|
{
|
|
gameAccountId_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "challenges" field.</summary>
|
|
public const int ChallengesFieldNumber = 3;
|
|
private static readonly pb::FieldCodec<Bgs.Protocol.Challenge.V1.Challenge> _repeated_challenges_codec
|
|
= pb::FieldCodec.ForMessage(26, Bgs.Protocol.Challenge.V1.Challenge.Parser);
|
|
private readonly pbc::RepeatedField<Bgs.Protocol.Challenge.V1.Challenge> challenges_ = new pbc::RepeatedField<Bgs.Protocol.Challenge.V1.Challenge>();
|
|
public pbc::RepeatedField<Bgs.Protocol.Challenge.V1.Challenge> Challenges
|
|
{
|
|
get { return challenges_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "context" field.</summary>
|
|
public const int ContextFieldNumber = 4;
|
|
private uint context_;
|
|
public uint Context
|
|
{
|
|
get { return context_; }
|
|
set
|
|
{
|
|
context_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "timeout" field.</summary>
|
|
public const int TimeoutFieldNumber = 5;
|
|
private ulong timeout_;
|
|
public ulong Timeout
|
|
{
|
|
get { return timeout_; }
|
|
set
|
|
{
|
|
timeout_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "attributes" field.</summary>
|
|
public const int AttributesFieldNumber = 6;
|
|
private static readonly pb::FieldCodec<Bgs.Protocol.Attribute> _repeated_attributes_codec
|
|
= pb::FieldCodec.ForMessage(50, Bgs.Protocol.Attribute.Parser);
|
|
private readonly pbc::RepeatedField<Bgs.Protocol.Attribute> attributes_ = new pbc::RepeatedField<Bgs.Protocol.Attribute>();
|
|
public pbc::RepeatedField<Bgs.Protocol.Attribute> Attributes
|
|
{
|
|
get { return attributes_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "host" field.</summary>
|
|
public const int HostFieldNumber = 7;
|
|
private Bgs.Protocol.ProcessId host_;
|
|
public Bgs.Protocol.ProcessId Host
|
|
{
|
|
get { return host_; }
|
|
set
|
|
{
|
|
host_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "account_id" field.</summary>
|
|
public const int AccountIdFieldNumber = 8;
|
|
private Bgs.Protocol.EntityId accountId_;
|
|
public Bgs.Protocol.EntityId AccountId
|
|
{
|
|
get { return accountId_; }
|
|
set
|
|
{
|
|
accountId_ = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as SendChallengeToUserRequest);
|
|
}
|
|
|
|
public bool Equals(SendChallengeToUserRequest other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (!object.Equals(PeerId, other.PeerId)) return false;
|
|
if (!object.Equals(GameAccountId, other.GameAccountId)) return false;
|
|
if (!challenges_.Equals(other.challenges_)) return false;
|
|
if (Context != other.Context) return false;
|
|
if (Timeout != other.Timeout) return false;
|
|
if (!attributes_.Equals(other.attributes_)) return false;
|
|
if (!object.Equals(Host, other.Host)) return false;
|
|
if (!object.Equals(AccountId, other.AccountId)) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (peerId_ != null) hash ^= PeerId.GetHashCode();
|
|
if (gameAccountId_ != null) hash ^= GameAccountId.GetHashCode();
|
|
hash ^= challenges_.GetHashCode();
|
|
if (Context != 0) hash ^= Context.GetHashCode();
|
|
if (Timeout != 0UL) hash ^= Timeout.GetHashCode();
|
|
hash ^= attributes_.GetHashCode();
|
|
if (host_ != null) hash ^= Host.GetHashCode();
|
|
if (accountId_ != null) hash ^= AccountId.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (peerId_ != null)
|
|
{
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(PeerId);
|
|
}
|
|
if (gameAccountId_ != null)
|
|
{
|
|
output.WriteRawTag(18);
|
|
output.WriteMessage(GameAccountId);
|
|
}
|
|
challenges_.WriteTo(output, _repeated_challenges_codec);
|
|
if (Context != 0)
|
|
{
|
|
output.WriteRawTag(37);
|
|
output.WriteFixed32(Context);
|
|
}
|
|
if (Timeout != 0UL)
|
|
{
|
|
output.WriteRawTag(40);
|
|
output.WriteUInt64(Timeout);
|
|
}
|
|
attributes_.WriteTo(output, _repeated_attributes_codec);
|
|
if (host_ != null)
|
|
{
|
|
output.WriteRawTag(58);
|
|
output.WriteMessage(Host);
|
|
}
|
|
if (accountId_ != null)
|
|
{
|
|
output.WriteRawTag(66);
|
|
output.WriteMessage(AccountId);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (peerId_ != null)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(PeerId);
|
|
}
|
|
if (gameAccountId_ != null)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(GameAccountId);
|
|
}
|
|
size += challenges_.CalculateSize(_repeated_challenges_codec);
|
|
if (Context != 0)
|
|
{
|
|
size += 1 + 4;
|
|
}
|
|
if (Timeout != 0UL)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Timeout);
|
|
}
|
|
size += attributes_.CalculateSize(_repeated_attributes_codec);
|
|
if (host_ != null)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Host);
|
|
}
|
|
if (accountId_ != null)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(AccountId);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(SendChallengeToUserRequest other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.peerId_ != null)
|
|
{
|
|
if (peerId_ == null)
|
|
{
|
|
peerId_ = new Bgs.Protocol.ProcessId();
|
|
}
|
|
PeerId.MergeFrom(other.PeerId);
|
|
}
|
|
if (other.gameAccountId_ != null)
|
|
{
|
|
if (gameAccountId_ == null)
|
|
{
|
|
gameAccountId_ = new Bgs.Protocol.EntityId();
|
|
}
|
|
GameAccountId.MergeFrom(other.GameAccountId);
|
|
}
|
|
challenges_.Add(other.challenges_);
|
|
if (other.Context != 0)
|
|
{
|
|
Context = other.Context;
|
|
}
|
|
if (other.Timeout != 0UL)
|
|
{
|
|
Timeout = other.Timeout;
|
|
}
|
|
attributes_.Add(other.attributes_);
|
|
if (other.host_ != null)
|
|
{
|
|
if (host_ == null)
|
|
{
|
|
host_ = new Bgs.Protocol.ProcessId();
|
|
}
|
|
Host.MergeFrom(other.Host);
|
|
}
|
|
if (other.accountId_ != null)
|
|
{
|
|
if (accountId_ == null)
|
|
{
|
|
accountId_ = new Bgs.Protocol.EntityId();
|
|
}
|
|
AccountId.MergeFrom(other.AccountId);
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 10:
|
|
{
|
|
if (peerId_ == null)
|
|
{
|
|
peerId_ = new Bgs.Protocol.ProcessId();
|
|
}
|
|
input.ReadMessage(peerId_);
|
|
break;
|
|
}
|
|
case 18:
|
|
{
|
|
if (gameAccountId_ == null)
|
|
{
|
|
gameAccountId_ = new Bgs.Protocol.EntityId();
|
|
}
|
|
input.ReadMessage(gameAccountId_);
|
|
break;
|
|
}
|
|
case 26:
|
|
{
|
|
challenges_.AddEntriesFrom(input, _repeated_challenges_codec);
|
|
break;
|
|
}
|
|
case 37:
|
|
{
|
|
Context = input.ReadFixed32();
|
|
break;
|
|
}
|
|
case 40:
|
|
{
|
|
Timeout = input.ReadUInt64();
|
|
break;
|
|
}
|
|
case 50:
|
|
{
|
|
attributes_.AddEntriesFrom(input, _repeated_attributes_codec);
|
|
break;
|
|
}
|
|
case 58:
|
|
{
|
|
if (host_ == null)
|
|
{
|
|
host_ = new Bgs.Protocol.ProcessId();
|
|
}
|
|
input.ReadMessage(host_);
|
|
break;
|
|
}
|
|
case 66:
|
|
{
|
|
if (accountId_ == null)
|
|
{
|
|
accountId_ = new Bgs.Protocol.EntityId();
|
|
}
|
|
input.ReadMessage(accountId_);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class SendChallengeToUserResponse : pb::IMessage<SendChallengeToUserResponse>
|
|
{
|
|
private static readonly pb::MessageParser<SendChallengeToUserResponse> _parser = new pb::MessageParser<SendChallengeToUserResponse>(() => new SendChallengeToUserResponse());
|
|
public static pb::MessageParser<SendChallengeToUserResponse> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Challenge.V1.ChallengeServiceReflection.Descriptor.MessageTypes[7]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public SendChallengeToUserResponse()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public SendChallengeToUserResponse(SendChallengeToUserResponse other) : this()
|
|
{
|
|
id_ = other.id_;
|
|
}
|
|
|
|
public SendChallengeToUserResponse Clone()
|
|
{
|
|
return new SendChallengeToUserResponse(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "id" field.</summary>
|
|
public const int IdFieldNumber = 1;
|
|
private uint id_;
|
|
public uint Id
|
|
{
|
|
get { return id_; }
|
|
set
|
|
{
|
|
id_ = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as SendChallengeToUserResponse);
|
|
}
|
|
|
|
public bool Equals(SendChallengeToUserResponse other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (Id != other.Id) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (Id != 0) hash ^= Id.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (Id != 0)
|
|
{
|
|
output.WriteRawTag(8);
|
|
output.WriteUInt32(Id);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (Id != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Id);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(SendChallengeToUserResponse other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.Id != 0)
|
|
{
|
|
Id = other.Id;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 8:
|
|
{
|
|
Id = input.ReadUInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class ChallengeUserRequest : pb::IMessage<ChallengeUserRequest>
|
|
{
|
|
private static readonly pb::MessageParser<ChallengeUserRequest> _parser = new pb::MessageParser<ChallengeUserRequest>(() => new ChallengeUserRequest());
|
|
public static pb::MessageParser<ChallengeUserRequest> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Challenge.V1.ChallengeServiceReflection.Descriptor.MessageTypes[8]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public ChallengeUserRequest()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public ChallengeUserRequest(ChallengeUserRequest other) : this()
|
|
{
|
|
challenges_ = other.challenges_.Clone();
|
|
context_ = other.context_;
|
|
id_ = other.id_;
|
|
deadline_ = other.deadline_;
|
|
attributes_ = other.attributes_.Clone();
|
|
GameAccountId = other.gameAccountId_ != null ? other.GameAccountId.Clone() : null;
|
|
}
|
|
|
|
public ChallengeUserRequest Clone()
|
|
{
|
|
return new ChallengeUserRequest(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "challenges" field.</summary>
|
|
public const int ChallengesFieldNumber = 1;
|
|
private static readonly pb::FieldCodec<Bgs.Protocol.Challenge.V1.Challenge> _repeated_challenges_codec
|
|
= pb::FieldCodec.ForMessage(10, Bgs.Protocol.Challenge.V1.Challenge.Parser);
|
|
private readonly pbc::RepeatedField<Bgs.Protocol.Challenge.V1.Challenge> challenges_ = new pbc::RepeatedField<Bgs.Protocol.Challenge.V1.Challenge>();
|
|
public pbc::RepeatedField<Bgs.Protocol.Challenge.V1.Challenge> Challenges
|
|
{
|
|
get { return challenges_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "context" field.</summary>
|
|
public const int ContextFieldNumber = 2;
|
|
private uint context_;
|
|
public uint Context
|
|
{
|
|
get { return context_; }
|
|
set
|
|
{
|
|
context_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "id" field.</summary>
|
|
public const int IdFieldNumber = 3;
|
|
private uint id_;
|
|
public uint Id
|
|
{
|
|
get { return id_; }
|
|
set
|
|
{
|
|
id_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "deadline" field.</summary>
|
|
public const int DeadlineFieldNumber = 4;
|
|
private ulong deadline_;
|
|
public ulong Deadline
|
|
{
|
|
get { return deadline_; }
|
|
set
|
|
{
|
|
deadline_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "attributes" field.</summary>
|
|
public const int AttributesFieldNumber = 5;
|
|
private static readonly pb::FieldCodec<Bgs.Protocol.Attribute> _repeated_attributes_codec
|
|
= pb::FieldCodec.ForMessage(42, Bgs.Protocol.Attribute.Parser);
|
|
private readonly pbc::RepeatedField<Bgs.Protocol.Attribute> attributes_ = new pbc::RepeatedField<Bgs.Protocol.Attribute>();
|
|
public pbc::RepeatedField<Bgs.Protocol.Attribute> Attributes
|
|
{
|
|
get { return attributes_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "game_account_id" field.</summary>
|
|
public const int GameAccountIdFieldNumber = 6;
|
|
private Bgs.Protocol.EntityId gameAccountId_;
|
|
public Bgs.Protocol.EntityId GameAccountId
|
|
{
|
|
get { return gameAccountId_; }
|
|
set
|
|
{
|
|
gameAccountId_ = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as ChallengeUserRequest);
|
|
}
|
|
|
|
public bool Equals(ChallengeUserRequest other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (!challenges_.Equals(other.challenges_)) return false;
|
|
if (Context != other.Context) return false;
|
|
if (Id != other.Id) return false;
|
|
if (Deadline != other.Deadline) return false;
|
|
if (!attributes_.Equals(other.attributes_)) return false;
|
|
if (!object.Equals(GameAccountId, other.GameAccountId)) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
hash ^= challenges_.GetHashCode();
|
|
if (Context != 0) hash ^= Context.GetHashCode();
|
|
if (Id != 0) hash ^= Id.GetHashCode();
|
|
if (Deadline != 0UL) hash ^= Deadline.GetHashCode();
|
|
hash ^= attributes_.GetHashCode();
|
|
if (gameAccountId_ != null) hash ^= GameAccountId.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
challenges_.WriteTo(output, _repeated_challenges_codec);
|
|
if (Context != 0)
|
|
{
|
|
output.WriteRawTag(21);
|
|
output.WriteFixed32(Context);
|
|
}
|
|
if (Id != 0)
|
|
{
|
|
output.WriteRawTag(24);
|
|
output.WriteUInt32(Id);
|
|
}
|
|
if (Deadline != 0UL)
|
|
{
|
|
output.WriteRawTag(32);
|
|
output.WriteUInt64(Deadline);
|
|
}
|
|
attributes_.WriteTo(output, _repeated_attributes_codec);
|
|
if (gameAccountId_ != null)
|
|
{
|
|
output.WriteRawTag(50);
|
|
output.WriteMessage(GameAccountId);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
size += challenges_.CalculateSize(_repeated_challenges_codec);
|
|
if (Context != 0)
|
|
{
|
|
size += 1 + 4;
|
|
}
|
|
if (Id != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Id);
|
|
}
|
|
if (Deadline != 0UL)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Deadline);
|
|
}
|
|
size += attributes_.CalculateSize(_repeated_attributes_codec);
|
|
if (gameAccountId_ != null)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(GameAccountId);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(ChallengeUserRequest other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
challenges_.Add(other.challenges_);
|
|
if (other.Context != 0)
|
|
{
|
|
Context = other.Context;
|
|
}
|
|
if (other.Id != 0)
|
|
{
|
|
Id = other.Id;
|
|
}
|
|
if (other.Deadline != 0UL)
|
|
{
|
|
Deadline = other.Deadline;
|
|
}
|
|
attributes_.Add(other.attributes_);
|
|
if (other.gameAccountId_ != null)
|
|
{
|
|
if (gameAccountId_ == null)
|
|
{
|
|
gameAccountId_ = new Bgs.Protocol.EntityId();
|
|
}
|
|
GameAccountId.MergeFrom(other.GameAccountId);
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 10:
|
|
{
|
|
challenges_.AddEntriesFrom(input, _repeated_challenges_codec);
|
|
break;
|
|
}
|
|
case 21:
|
|
{
|
|
Context = input.ReadFixed32();
|
|
break;
|
|
}
|
|
case 24:
|
|
{
|
|
Id = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 32:
|
|
{
|
|
Deadline = input.ReadUInt64();
|
|
break;
|
|
}
|
|
case 42:
|
|
{
|
|
attributes_.AddEntriesFrom(input, _repeated_attributes_codec);
|
|
break;
|
|
}
|
|
case 50:
|
|
{
|
|
if (gameAccountId_ == null)
|
|
{
|
|
gameAccountId_ = new Bgs.Protocol.EntityId();
|
|
}
|
|
input.ReadMessage(gameAccountId_);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class ChallengeResultRequest : pb::IMessage<ChallengeResultRequest>
|
|
{
|
|
private static readonly pb::MessageParser<ChallengeResultRequest> _parser = new pb::MessageParser<ChallengeResultRequest>(() => new ChallengeResultRequest());
|
|
public static pb::MessageParser<ChallengeResultRequest> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Challenge.V1.ChallengeServiceReflection.Descriptor.MessageTypes[9]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public ChallengeResultRequest()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public ChallengeResultRequest(ChallengeResultRequest other) : this()
|
|
{
|
|
id_ = other.id_;
|
|
type_ = other.type_;
|
|
errorId_ = other.errorId_;
|
|
answer_ = other.answer_;
|
|
}
|
|
|
|
public ChallengeResultRequest Clone()
|
|
{
|
|
return new ChallengeResultRequest(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "id" field.</summary>
|
|
public const int IdFieldNumber = 1;
|
|
private uint id_;
|
|
public uint Id
|
|
{
|
|
get { return id_; }
|
|
set
|
|
{
|
|
id_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "type" field.</summary>
|
|
public const int TypeFieldNumber = 2;
|
|
private uint type_;
|
|
public uint Type
|
|
{
|
|
get { return type_; }
|
|
set
|
|
{
|
|
type_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "error_id" field.</summary>
|
|
public const int ErrorIdFieldNumber = 3;
|
|
private uint errorId_;
|
|
public uint ErrorId
|
|
{
|
|
get { return errorId_; }
|
|
set
|
|
{
|
|
errorId_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "answer" field.</summary>
|
|
public const int AnswerFieldNumber = 4;
|
|
private pb::ByteString answer_ = pb::ByteString.Empty;
|
|
public pb::ByteString Answer
|
|
{
|
|
get { return answer_; }
|
|
set
|
|
{
|
|
answer_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as ChallengeResultRequest);
|
|
}
|
|
|
|
public bool Equals(ChallengeResultRequest other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (Id != other.Id) return false;
|
|
if (Type != other.Type) return false;
|
|
if (ErrorId != other.ErrorId) return false;
|
|
if (Answer != other.Answer) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (Id != 0) hash ^= Id.GetHashCode();
|
|
if (Type != 0) hash ^= Type.GetHashCode();
|
|
if (ErrorId != 0) hash ^= ErrorId.GetHashCode();
|
|
if (Answer.Length != 0) hash ^= Answer.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (Id != 0)
|
|
{
|
|
output.WriteRawTag(8);
|
|
output.WriteUInt32(Id);
|
|
}
|
|
if (Type != 0)
|
|
{
|
|
output.WriteRawTag(21);
|
|
output.WriteFixed32(Type);
|
|
}
|
|
if (ErrorId != 0)
|
|
{
|
|
output.WriteRawTag(24);
|
|
output.WriteUInt32(ErrorId);
|
|
}
|
|
if (Answer.Length != 0)
|
|
{
|
|
output.WriteRawTag(34);
|
|
output.WriteBytes(Answer);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (Id != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Id);
|
|
}
|
|
if (Type != 0)
|
|
{
|
|
size += 1 + 4;
|
|
}
|
|
if (ErrorId != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ErrorId);
|
|
}
|
|
if (Answer.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeBytesSize(Answer);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(ChallengeResultRequest other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.Id != 0)
|
|
{
|
|
Id = other.Id;
|
|
}
|
|
if (other.Type != 0)
|
|
{
|
|
Type = other.Type;
|
|
}
|
|
if (other.ErrorId != 0)
|
|
{
|
|
ErrorId = other.ErrorId;
|
|
}
|
|
if (other.Answer.Length != 0)
|
|
{
|
|
Answer = other.Answer;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 8:
|
|
{
|
|
Id = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 21:
|
|
{
|
|
Type = input.ReadFixed32();
|
|
break;
|
|
}
|
|
case 24:
|
|
{
|
|
ErrorId = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 34:
|
|
{
|
|
Answer = input.ReadBytes();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class ChallengeExternalRequest : pb::IMessage<ChallengeExternalRequest>
|
|
{
|
|
private static readonly pb::MessageParser<ChallengeExternalRequest> _parser = new pb::MessageParser<ChallengeExternalRequest>(() => new ChallengeExternalRequest());
|
|
public static pb::MessageParser<ChallengeExternalRequest> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Challenge.V1.ChallengeServiceReflection.Descriptor.MessageTypes[10]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public ChallengeExternalRequest()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public ChallengeExternalRequest(ChallengeExternalRequest other) : this()
|
|
{
|
|
requestToken_ = other.requestToken_;
|
|
payloadType_ = other.payloadType_;
|
|
payload_ = other.payload_;
|
|
}
|
|
|
|
public ChallengeExternalRequest Clone()
|
|
{
|
|
return new ChallengeExternalRequest(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "request_token" field.</summary>
|
|
public const int RequestTokenFieldNumber = 1;
|
|
private string requestToken_ = "";
|
|
public string RequestToken
|
|
{
|
|
get { return requestToken_; }
|
|
set
|
|
{
|
|
requestToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "payload_type" field.</summary>
|
|
public const int PayloadTypeFieldNumber = 2;
|
|
private string payloadType_ = "";
|
|
public string PayloadType
|
|
{
|
|
get { return payloadType_; }
|
|
set
|
|
{
|
|
payloadType_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "payload" field.</summary>
|
|
public const int PayloadFieldNumber = 3;
|
|
private pb::ByteString payload_ = pb::ByteString.Empty;
|
|
public pb::ByteString Payload
|
|
{
|
|
get { return payload_; }
|
|
set
|
|
{
|
|
payload_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as ChallengeExternalRequest);
|
|
}
|
|
|
|
public bool Equals(ChallengeExternalRequest other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (RequestToken != other.RequestToken) return false;
|
|
if (PayloadType != other.PayloadType) return false;
|
|
if (Payload != other.Payload) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (RequestToken.Length != 0) hash ^= RequestToken.GetHashCode();
|
|
if (PayloadType.Length != 0) hash ^= PayloadType.GetHashCode();
|
|
if (Payload.Length != 0) hash ^= Payload.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (RequestToken.Length != 0)
|
|
{
|
|
output.WriteRawTag(10);
|
|
output.WriteString(RequestToken);
|
|
}
|
|
if (PayloadType.Length != 0)
|
|
{
|
|
output.WriteRawTag(18);
|
|
output.WriteString(PayloadType);
|
|
}
|
|
if (Payload.Length != 0)
|
|
{
|
|
output.WriteRawTag(26);
|
|
output.WriteBytes(Payload);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (RequestToken.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestToken);
|
|
}
|
|
if (PayloadType.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeStringSize(PayloadType);
|
|
}
|
|
if (Payload.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeBytesSize(Payload);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(ChallengeExternalRequest other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.RequestToken.Length != 0)
|
|
{
|
|
RequestToken = other.RequestToken;
|
|
}
|
|
if (other.PayloadType.Length != 0)
|
|
{
|
|
PayloadType = other.PayloadType;
|
|
}
|
|
if (other.Payload.Length != 0)
|
|
{
|
|
Payload = other.Payload;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 10:
|
|
{
|
|
RequestToken = input.ReadString();
|
|
break;
|
|
}
|
|
case 18:
|
|
{
|
|
PayloadType = input.ReadString();
|
|
break;
|
|
}
|
|
case 26:
|
|
{
|
|
Payload = input.ReadBytes();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class ChallengeExternalResult : pb::IMessage<ChallengeExternalResult>
|
|
{
|
|
private static readonly pb::MessageParser<ChallengeExternalResult> _parser = new pb::MessageParser<ChallengeExternalResult>(() => new ChallengeExternalResult());
|
|
public static pb::MessageParser<ChallengeExternalResult> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Challenge.V1.ChallengeServiceReflection.Descriptor.MessageTypes[11]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public ChallengeExternalResult()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public ChallengeExternalResult(ChallengeExternalResult other) : this()
|
|
{
|
|
requestToken_ = other.requestToken_;
|
|
passed_ = other.passed_;
|
|
}
|
|
|
|
public ChallengeExternalResult Clone()
|
|
{
|
|
return new ChallengeExternalResult(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "request_token" field.</summary>
|
|
public const int RequestTokenFieldNumber = 1;
|
|
private string requestToken_ = "";
|
|
public string RequestToken
|
|
{
|
|
get { return requestToken_; }
|
|
set
|
|
{
|
|
requestToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "passed" field.</summary>
|
|
public const int PassedFieldNumber = 2;
|
|
private bool passed_;
|
|
public bool Passed
|
|
{
|
|
get { return passed_; }
|
|
set
|
|
{
|
|
passed_ = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as ChallengeExternalResult);
|
|
}
|
|
|
|
public bool Equals(ChallengeExternalResult other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (RequestToken != other.RequestToken) return false;
|
|
if (Passed != other.Passed) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (RequestToken.Length != 0) hash ^= RequestToken.GetHashCode();
|
|
if (Passed != false) hash ^= Passed.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (RequestToken.Length != 0)
|
|
{
|
|
output.WriteRawTag(10);
|
|
output.WriteString(RequestToken);
|
|
}
|
|
if (Passed != false)
|
|
{
|
|
output.WriteRawTag(16);
|
|
output.WriteBool(Passed);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (RequestToken.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestToken);
|
|
}
|
|
if (Passed != false)
|
|
{
|
|
size += 1 + 1;
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(ChallengeExternalResult other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.RequestToken.Length != 0)
|
|
{
|
|
RequestToken = other.RequestToken;
|
|
}
|
|
if (other.Passed != false)
|
|
{
|
|
Passed = other.Passed;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 10:
|
|
{
|
|
RequestToken = input.ReadString();
|
|
break;
|
|
}
|
|
case 16:
|
|
{
|
|
Passed = input.ReadBool();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#endregion Designer generated code
|