hondacrx
2026 lines
67 KiB
C#
2026 lines
67 KiB
C#
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: bgs/low/pb/client/connection_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.Connection.V1
|
|
{
|
|
|
|
/// <summary>Holder for reflection information generated from bgs/low/pb/client/connection_service.proto</summary>
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public static partial class ConnectionServiceReflection
|
|
{
|
|
|
|
#region Descriptor
|
|
/// <summary>File descriptor for bgs/low/pb/client/connection_service.proto</summary>
|
|
public static pbr::FileDescriptor Descriptor
|
|
{
|
|
get { return descriptor; }
|
|
}
|
|
private static pbr::FileDescriptor descriptor;
|
|
|
|
static ConnectionServiceReflection()
|
|
{
|
|
byte[] descriptorData = System.Convert.FromBase64String(
|
|
string.Concat(
|
|
"CipiZ3MvbG93L3BiL2NsaWVudC9jb25uZWN0aW9uX3NlcnZpY2UucHJvdG8S",
|
|
"GmJncy5wcm90b2NvbC5jb25uZWN0aW9uLnYxGixiZ3MvbG93L3BiL2NsaWVu",
|
|
"dC9jb250ZW50X2hhbmRsZV90eXBlcy5wcm90bxohYmdzL2xvdy9wYi9jbGll",
|
|
"bnQvcnBjX3R5cGVzLnByb3RvIpUBCg5Db25uZWN0UmVxdWVzdBIqCgljbGll",
|
|
"bnRfaWQYASABKAsyFy5iZ3MucHJvdG9jb2wuUHJvY2Vzc0lkEj0KDGJpbmRf",
|
|
"cmVxdWVzdBgCIAEoCzInLmJncy5wcm90b2NvbC5jb25uZWN0aW9uLnYxLkJp",
|
|
"bmRSZXF1ZXN0EhgKEHVzZV9iaW5kbGVzc19ycGMYAyABKAgiVwogQ29ubmVj",
|
|
"dGlvbk1ldGVyaW5nQ29udGVudEhhbmRsZXMSMwoOY29udGVudF9oYW5kbGUY",
|
|
"ASADKAsyGy5iZ3MucHJvdG9jb2wuQ29udGVudEhhbmRsZSKtAwoPQ29ubmVj",
|
|
"dFJlc3BvbnNlEioKCXNlcnZlcl9pZBgBIAEoCzIXLmJncy5wcm90b2NvbC5Q",
|
|
"cm9jZXNzSWQSKgoJY2xpZW50X2lkGAIgASgLMhcuYmdzLnByb3RvY29sLlBy",
|
|
"b2Nlc3NJZBITCgtiaW5kX3Jlc3VsdBgDIAEoDRI/Cg1iaW5kX3Jlc3BvbnNl",
|
|
"GAQgASgLMiguYmdzLnByb3RvY29sLmNvbm5lY3Rpb24udjEuQmluZFJlc3Bv",
|
|
"bnNlEloKFGNvbnRlbnRfaGFuZGxlX2FycmF5GAUgASgLMjwuYmdzLnByb3Rv",
|
|
"Y29sLmNvbm5lY3Rpb24udjEuQ29ubmVjdGlvbk1ldGVyaW5nQ29udGVudEhh",
|
|
"bmRsZXMSEwoLc2VydmVyX3RpbWUYBiABKAQSGAoQdXNlX2JpbmRsZXNzX3Jw",
|
|
"YxgHIAEoCBJhChtiaW5hcnlfY29udGVudF9oYW5kbGVfYXJyYXkYCCABKAsy",
|
|
"PC5iZ3MucHJvdG9jb2wuY29ubmVjdGlvbi52MS5Db25uZWN0aW9uTWV0ZXJp",
|
|
"bmdDb250ZW50SGFuZGxlcyIoCgxCb3VuZFNlcnZpY2USDAoEaGFzaBgBIAEo",
|
|
"BxIKCgJpZBgCIAEoDSKYAgoLQmluZFJlcXVlc3QSLgogZGVwcmVjYXRlZF9p",
|
|
"bXBvcnRlZF9zZXJ2aWNlX2hhc2gYASADKAdCBBABGAESUQobZGVwcmVjYXRl",
|
|
"ZF9leHBvcnRlZF9zZXJ2aWNlGAIgAygLMiguYmdzLnByb3RvY29sLmNvbm5l",
|
|
"Y3Rpb24udjEuQm91bmRTZXJ2aWNlQgIYARJCChBleHBvcnRlZF9zZXJ2aWNl",
|
|
"GAMgAygLMiguYmdzLnByb3RvY29sLmNvbm5lY3Rpb24udjEuQm91bmRTZXJ2",
|
|
"aWNlEkIKEGltcG9ydGVkX3NlcnZpY2UYBCADKAsyKC5iZ3MucHJvdG9jb2wu",
|
|
"Y29ubmVjdGlvbi52MS5Cb3VuZFNlcnZpY2UiMQoMQmluZFJlc3BvbnNlEiEK",
|
|
"E2ltcG9ydGVkX3NlcnZpY2VfaWQYASADKA1CBBABGAEiQgoLRWNob1JlcXVl",
|
|
"c3QSDAoEdGltZRgBIAEoBhIUCgxuZXR3b3JrX29ubHkYAiABKAgSDwoHcGF5",
|
|
"bG9hZBgDIAEoDCItCgxFY2hvUmVzcG9uc2USDAoEdGltZRgBIAEoBhIPCgdw",
|
|
"YXlsb2FkGAIgASgMIicKEURpc2Nvbm5lY3RSZXF1ZXN0EhIKCmVycm9yX2Nv",
|
|
"ZGUYASABKA0iPAoWRGlzY29ubmVjdE5vdGlmaWNhdGlvbhISCgplcnJvcl9j",
|
|
"b2RlGAEgASgNEg4KBnJlYXNvbhgCIAEoCSIQCg5FbmNyeXB0UmVxdWVzdDKD",
|
|
"BQoRQ29ubmVjdGlvblNlcnZpY2USYgoHQ29ubmVjdBIqLmJncy5wcm90b2Nv",
|
|
"bC5jb25uZWN0aW9uLnYxLkNvbm5lY3RSZXF1ZXN0GisuYmdzLnByb3RvY29s",
|
|
"LmNvbm5lY3Rpb24udjEuQ29ubmVjdFJlc3BvbnNlEl4KBEJpbmQSJy5iZ3Mu",
|
|
"cHJvdG9jb2wuY29ubmVjdGlvbi52MS5CaW5kUmVxdWVzdBooLmJncy5wcm90",
|
|
"b2NvbC5jb25uZWN0aW9uLnYxLkJpbmRSZXNwb25zZSIDiAIBElkKBEVjaG8S",
|
|
"Jy5iZ3MucHJvdG9jb2wuY29ubmVjdGlvbi52MS5FY2hvUmVxdWVzdBooLmJn",
|
|
"cy5wcm90b2NvbC5jb25uZWN0aW9uLnYxLkVjaG9SZXNwb25zZRJgCg9Gb3Jj",
|
|
"ZURpc2Nvbm5lY3QSMi5iZ3MucHJvdG9jb2wuY29ubmVjdGlvbi52MS5EaXNj",
|
|
"b25uZWN0Tm90aWZpY2F0aW9uGhkuYmdzLnByb3RvY29sLk5PX1JFU1BPTlNF",
|
|
"EjwKCUtlZXBBbGl2ZRIULmJncy5wcm90b2NvbC5Ob0RhdGEaGS5iZ3MucHJv",
|
|
"dG9jb2wuTk9fUkVTUE9OU0USUAoHRW5jcnlwdBIqLmJncy5wcm90b2NvbC5j",
|
|
"b25uZWN0aW9uLnYxLkVuY3J5cHRSZXF1ZXN0GhQuYmdzLnByb3RvY29sLk5v",
|
|
"RGF0YSIDiAIBEl0KEVJlcXVlc3REaXNjb25uZWN0Ei0uYmdzLnByb3RvY29s",
|
|
"LmNvbm5lY3Rpb24udjEuRGlzY29ubmVjdFJlcXVlc3QaGS5iZ3MucHJvdG9j",
|
|
"b2wuTk9fUkVTUE9OU0VCPQobYm5ldC5wcm90b2NvbC5jb25uZWN0aW9uLnYx",
|
|
"QhZDb25uZWN0aW9uU2VydmljZVByb3RvSAKAAQCIAQFiBnByb3RvMw=="));
|
|
descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
|
|
new pbr::FileDescriptor[] { Bgs.Protocol.ContentHandleTypesReflection.Descriptor, Bgs.Protocol.RpcTypesReflection.Descriptor, },
|
|
new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.ConnectRequest), Bgs.Protocol.Connection.V1.ConnectRequest.Parser, new[]{ "ClientId", "BindRequest", "UseBindlessRpc" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles), Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles.Parser, new[]{ "ContentHandle" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.ConnectResponse), Bgs.Protocol.Connection.V1.ConnectResponse.Parser, new[]{ "ServerId", "ClientId", "BindResult", "BindResponse", "ContentHandleArray", "ServerTime", "UseBindlessRpc", "BinaryContentHandleArray" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.BoundService), Bgs.Protocol.Connection.V1.BoundService.Parser, new[]{ "Hash", "Id" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.BindRequest), Bgs.Protocol.Connection.V1.BindRequest.Parser, new[]{ "DeprecatedImportedServiceHash", "DeprecatedExportedService", "ExportedService", "ImportedService" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.BindResponse), Bgs.Protocol.Connection.V1.BindResponse.Parser, new[]{ "ImportedServiceId" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.EchoRequest), Bgs.Protocol.Connection.V1.EchoRequest.Parser, new[]{ "Time", "NetworkOnly", "Payload" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.EchoResponse), Bgs.Protocol.Connection.V1.EchoResponse.Parser, new[]{ "Time", "Payload" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.DisconnectRequest), Bgs.Protocol.Connection.V1.DisconnectRequest.Parser, new[]{ "ErrorCode" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.DisconnectNotification), Bgs.Protocol.Connection.V1.DisconnectNotification.Parser, new[]{ "ErrorCode", "Reason" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.EncryptRequest), Bgs.Protocol.Connection.V1.EncryptRequest.Parser, null, null, null, null)
|
|
}));
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
#region Messages
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class ConnectRequest : pb::IMessage<ConnectRequest>
|
|
{
|
|
private static readonly pb::MessageParser<ConnectRequest> _parser = new pb::MessageParser<ConnectRequest>(() => new ConnectRequest());
|
|
public static pb::MessageParser<ConnectRequest> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Connection.V1.ConnectionServiceReflection.Descriptor.MessageTypes[0]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public ConnectRequest()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public ConnectRequest(ConnectRequest other) : this()
|
|
{
|
|
ClientId = other.clientId_ != null ? other.ClientId.Clone() : null;
|
|
BindRequest = other.bindRequest_ != null ? other.BindRequest.Clone() : null;
|
|
useBindlessRpc_ = other.useBindlessRpc_;
|
|
}
|
|
|
|
public ConnectRequest Clone()
|
|
{
|
|
return new ConnectRequest(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "client_id" field.</summary>
|
|
public const int ClientIdFieldNumber = 1;
|
|
private Bgs.Protocol.ProcessId clientId_;
|
|
public Bgs.Protocol.ProcessId ClientId
|
|
{
|
|
get { return clientId_; }
|
|
set
|
|
{
|
|
clientId_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "bind_request" field.</summary>
|
|
public const int BindRequestFieldNumber = 2;
|
|
private Bgs.Protocol.Connection.V1.BindRequest bindRequest_;
|
|
public Bgs.Protocol.Connection.V1.BindRequest BindRequest
|
|
{
|
|
get { return bindRequest_; }
|
|
set
|
|
{
|
|
bindRequest_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "use_bindless_rpc" field.</summary>
|
|
public const int UseBindlessRpcFieldNumber = 3;
|
|
private bool useBindlessRpc_;
|
|
public bool UseBindlessRpc
|
|
{
|
|
get { return useBindlessRpc_; }
|
|
set
|
|
{
|
|
useBindlessRpc_ = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as ConnectRequest);
|
|
}
|
|
|
|
public bool Equals(ConnectRequest other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (!object.Equals(ClientId, other.ClientId)) return false;
|
|
if (!object.Equals(BindRequest, other.BindRequest)) return false;
|
|
if (UseBindlessRpc != other.UseBindlessRpc) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (clientId_ != null) hash ^= ClientId.GetHashCode();
|
|
if (bindRequest_ != null) hash ^= BindRequest.GetHashCode();
|
|
if (UseBindlessRpc != false) hash ^= UseBindlessRpc.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (clientId_ != null)
|
|
{
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(ClientId);
|
|
}
|
|
if (bindRequest_ != null)
|
|
{
|
|
output.WriteRawTag(18);
|
|
output.WriteMessage(BindRequest);
|
|
}
|
|
if (UseBindlessRpc != false)
|
|
{
|
|
output.WriteRawTag(24);
|
|
output.WriteBool(UseBindlessRpc);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (clientId_ != null)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(ClientId);
|
|
}
|
|
if (bindRequest_ != null)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(BindRequest);
|
|
}
|
|
if (UseBindlessRpc != false)
|
|
{
|
|
size += 1 + 1;
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(ConnectRequest other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.clientId_ != null)
|
|
{
|
|
if (clientId_ == null)
|
|
{
|
|
clientId_ = new Bgs.Protocol.ProcessId();
|
|
}
|
|
ClientId.MergeFrom(other.ClientId);
|
|
}
|
|
if (other.bindRequest_ != null)
|
|
{
|
|
if (bindRequest_ == null)
|
|
{
|
|
bindRequest_ = new Bgs.Protocol.Connection.V1.BindRequest();
|
|
}
|
|
BindRequest.MergeFrom(other.BindRequest);
|
|
}
|
|
if (other.UseBindlessRpc != false)
|
|
{
|
|
UseBindlessRpc = other.UseBindlessRpc;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 10:
|
|
{
|
|
if (clientId_ == null)
|
|
{
|
|
clientId_ = new Bgs.Protocol.ProcessId();
|
|
}
|
|
input.ReadMessage(clientId_);
|
|
break;
|
|
}
|
|
case 18:
|
|
{
|
|
if (bindRequest_ == null)
|
|
{
|
|
bindRequest_ = new Bgs.Protocol.Connection.V1.BindRequest();
|
|
}
|
|
input.ReadMessage(bindRequest_);
|
|
break;
|
|
}
|
|
case 24:
|
|
{
|
|
UseBindlessRpc = input.ReadBool();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class ConnectionMeteringContentHandles : pb::IMessage<ConnectionMeteringContentHandles>
|
|
{
|
|
private static readonly pb::MessageParser<ConnectionMeteringContentHandles> _parser = new pb::MessageParser<ConnectionMeteringContentHandles>(() => new ConnectionMeteringContentHandles());
|
|
public static pb::MessageParser<ConnectionMeteringContentHandles> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Connection.V1.ConnectionServiceReflection.Descriptor.MessageTypes[1]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public ConnectionMeteringContentHandles()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public ConnectionMeteringContentHandles(ConnectionMeteringContentHandles other) : this()
|
|
{
|
|
contentHandle_ = other.contentHandle_.Clone();
|
|
}
|
|
|
|
public ConnectionMeteringContentHandles Clone()
|
|
{
|
|
return new ConnectionMeteringContentHandles(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "content_handle" field.</summary>
|
|
public const int ContentHandleFieldNumber = 1;
|
|
private static readonly pb::FieldCodec<Bgs.Protocol.ContentHandle> _repeated_contentHandle_codec
|
|
= pb::FieldCodec.ForMessage(10, Bgs.Protocol.ContentHandle.Parser);
|
|
private readonly pbc::RepeatedField<Bgs.Protocol.ContentHandle> contentHandle_ = new pbc::RepeatedField<Bgs.Protocol.ContentHandle>();
|
|
public pbc::RepeatedField<Bgs.Protocol.ContentHandle> ContentHandle
|
|
{
|
|
get { return contentHandle_; }
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as ConnectionMeteringContentHandles);
|
|
}
|
|
|
|
public bool Equals(ConnectionMeteringContentHandles other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (!contentHandle_.Equals(other.contentHandle_)) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
hash ^= contentHandle_.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
contentHandle_.WriteTo(output, _repeated_contentHandle_codec);
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
size += contentHandle_.CalculateSize(_repeated_contentHandle_codec);
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(ConnectionMeteringContentHandles other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
contentHandle_.Add(other.contentHandle_);
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 10:
|
|
{
|
|
contentHandle_.AddEntriesFrom(input, _repeated_contentHandle_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class ConnectResponse : pb::IMessage<ConnectResponse>
|
|
{
|
|
private static readonly pb::MessageParser<ConnectResponse> _parser = new pb::MessageParser<ConnectResponse>(() => new ConnectResponse());
|
|
public static pb::MessageParser<ConnectResponse> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Connection.V1.ConnectionServiceReflection.Descriptor.MessageTypes[2]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public ConnectResponse()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public ConnectResponse(ConnectResponse other) : this()
|
|
{
|
|
ServerId = other.serverId_ != null ? other.ServerId.Clone() : null;
|
|
ClientId = other.clientId_ != null ? other.ClientId.Clone() : null;
|
|
bindResult_ = other.bindResult_;
|
|
BindResponse = other.bindResponse_ != null ? other.BindResponse.Clone() : null;
|
|
ContentHandleArray = other.contentHandleArray_ != null ? other.ContentHandleArray.Clone() : null;
|
|
serverTime_ = other.serverTime_;
|
|
useBindlessRpc_ = other.useBindlessRpc_;
|
|
BinaryContentHandleArray = other.binaryContentHandleArray_ != null ? other.BinaryContentHandleArray.Clone() : null;
|
|
}
|
|
|
|
public ConnectResponse Clone()
|
|
{
|
|
return new ConnectResponse(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "server_id" field.</summary>
|
|
public const int ServerIdFieldNumber = 1;
|
|
private Bgs.Protocol.ProcessId serverId_;
|
|
public Bgs.Protocol.ProcessId ServerId
|
|
{
|
|
get { return serverId_; }
|
|
set
|
|
{
|
|
serverId_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "client_id" field.</summary>
|
|
public const int ClientIdFieldNumber = 2;
|
|
private Bgs.Protocol.ProcessId clientId_;
|
|
public Bgs.Protocol.ProcessId ClientId
|
|
{
|
|
get { return clientId_; }
|
|
set
|
|
{
|
|
clientId_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "bind_result" field.</summary>
|
|
public const int BindResultFieldNumber = 3;
|
|
private uint bindResult_;
|
|
public uint BindResult
|
|
{
|
|
get { return bindResult_; }
|
|
set
|
|
{
|
|
bindResult_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "bind_response" field.</summary>
|
|
public const int BindResponseFieldNumber = 4;
|
|
private Bgs.Protocol.Connection.V1.BindResponse bindResponse_;
|
|
public Bgs.Protocol.Connection.V1.BindResponse BindResponse
|
|
{
|
|
get { return bindResponse_; }
|
|
set
|
|
{
|
|
bindResponse_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "content_handle_array" field.</summary>
|
|
public const int ContentHandleArrayFieldNumber = 5;
|
|
private Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles contentHandleArray_;
|
|
public Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles ContentHandleArray
|
|
{
|
|
get { return contentHandleArray_; }
|
|
set
|
|
{
|
|
contentHandleArray_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "server_time" field.</summary>
|
|
public const int ServerTimeFieldNumber = 6;
|
|
private ulong serverTime_;
|
|
public ulong ServerTime
|
|
{
|
|
get { return serverTime_; }
|
|
set
|
|
{
|
|
serverTime_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "use_bindless_rpc" field.</summary>
|
|
public const int UseBindlessRpcFieldNumber = 7;
|
|
private bool useBindlessRpc_;
|
|
public bool UseBindlessRpc
|
|
{
|
|
get { return useBindlessRpc_; }
|
|
set
|
|
{
|
|
useBindlessRpc_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "binary_content_handle_array" field.</summary>
|
|
public const int BinaryContentHandleArrayFieldNumber = 8;
|
|
private Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles binaryContentHandleArray_;
|
|
public Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles BinaryContentHandleArray
|
|
{
|
|
get { return binaryContentHandleArray_; }
|
|
set
|
|
{
|
|
binaryContentHandleArray_ = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as ConnectResponse);
|
|
}
|
|
|
|
public bool Equals(ConnectResponse other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (!object.Equals(ServerId, other.ServerId)) return false;
|
|
if (!object.Equals(ClientId, other.ClientId)) return false;
|
|
if (BindResult != other.BindResult) return false;
|
|
if (!object.Equals(BindResponse, other.BindResponse)) return false;
|
|
if (!object.Equals(ContentHandleArray, other.ContentHandleArray)) return false;
|
|
if (ServerTime != other.ServerTime) return false;
|
|
if (UseBindlessRpc != other.UseBindlessRpc) return false;
|
|
if (!object.Equals(BinaryContentHandleArray, other.BinaryContentHandleArray)) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (serverId_ != null) hash ^= ServerId.GetHashCode();
|
|
if (clientId_ != null) hash ^= ClientId.GetHashCode();
|
|
if (BindResult != 0) hash ^= BindResult.GetHashCode();
|
|
if (bindResponse_ != null) hash ^= BindResponse.GetHashCode();
|
|
if (contentHandleArray_ != null) hash ^= ContentHandleArray.GetHashCode();
|
|
if (ServerTime != 0UL) hash ^= ServerTime.GetHashCode();
|
|
if (UseBindlessRpc != false) hash ^= UseBindlessRpc.GetHashCode();
|
|
if (binaryContentHandleArray_ != null) hash ^= BinaryContentHandleArray.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (serverId_ != null)
|
|
{
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(ServerId);
|
|
}
|
|
if (clientId_ != null)
|
|
{
|
|
output.WriteRawTag(18);
|
|
output.WriteMessage(ClientId);
|
|
}
|
|
if (BindResult != 0)
|
|
{
|
|
output.WriteRawTag(24);
|
|
output.WriteUInt32(BindResult);
|
|
}
|
|
if (bindResponse_ != null)
|
|
{
|
|
output.WriteRawTag(34);
|
|
output.WriteMessage(BindResponse);
|
|
}
|
|
if (contentHandleArray_ != null)
|
|
{
|
|
output.WriteRawTag(42);
|
|
output.WriteMessage(ContentHandleArray);
|
|
}
|
|
if (ServerTime != 0UL)
|
|
{
|
|
output.WriteRawTag(48);
|
|
output.WriteUInt64(ServerTime);
|
|
}
|
|
if (UseBindlessRpc != false)
|
|
{
|
|
output.WriteRawTag(56);
|
|
output.WriteBool(UseBindlessRpc);
|
|
}
|
|
if (binaryContentHandleArray_ != null)
|
|
{
|
|
output.WriteRawTag(66);
|
|
output.WriteMessage(BinaryContentHandleArray);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (serverId_ != null)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(ServerId);
|
|
}
|
|
if (clientId_ != null)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(ClientId);
|
|
}
|
|
if (BindResult != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(BindResult);
|
|
}
|
|
if (bindResponse_ != null)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(BindResponse);
|
|
}
|
|
if (contentHandleArray_ != null)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(ContentHandleArray);
|
|
}
|
|
if (ServerTime != 0UL)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ServerTime);
|
|
}
|
|
if (UseBindlessRpc != false)
|
|
{
|
|
size += 1 + 1;
|
|
}
|
|
if (binaryContentHandleArray_ != null)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(BinaryContentHandleArray);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(ConnectResponse other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.serverId_ != null)
|
|
{
|
|
if (serverId_ == null)
|
|
{
|
|
serverId_ = new Bgs.Protocol.ProcessId();
|
|
}
|
|
ServerId.MergeFrom(other.ServerId);
|
|
}
|
|
if (other.clientId_ != null)
|
|
{
|
|
if (clientId_ == null)
|
|
{
|
|
clientId_ = new Bgs.Protocol.ProcessId();
|
|
}
|
|
ClientId.MergeFrom(other.ClientId);
|
|
}
|
|
if (other.BindResult != 0)
|
|
{
|
|
BindResult = other.BindResult;
|
|
}
|
|
if (other.bindResponse_ != null)
|
|
{
|
|
if (bindResponse_ == null)
|
|
{
|
|
bindResponse_ = new Bgs.Protocol.Connection.V1.BindResponse();
|
|
}
|
|
BindResponse.MergeFrom(other.BindResponse);
|
|
}
|
|
if (other.contentHandleArray_ != null)
|
|
{
|
|
if (contentHandleArray_ == null)
|
|
{
|
|
contentHandleArray_ = new Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles();
|
|
}
|
|
ContentHandleArray.MergeFrom(other.ContentHandleArray);
|
|
}
|
|
if (other.ServerTime != 0UL)
|
|
{
|
|
ServerTime = other.ServerTime;
|
|
}
|
|
if (other.UseBindlessRpc != false)
|
|
{
|
|
UseBindlessRpc = other.UseBindlessRpc;
|
|
}
|
|
if (other.binaryContentHandleArray_ != null)
|
|
{
|
|
if (binaryContentHandleArray_ == null)
|
|
{
|
|
binaryContentHandleArray_ = new Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles();
|
|
}
|
|
BinaryContentHandleArray.MergeFrom(other.BinaryContentHandleArray);
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 10:
|
|
{
|
|
if (serverId_ == null)
|
|
{
|
|
serverId_ = new Bgs.Protocol.ProcessId();
|
|
}
|
|
input.ReadMessage(serverId_);
|
|
break;
|
|
}
|
|
case 18:
|
|
{
|
|
if (clientId_ == null)
|
|
{
|
|
clientId_ = new Bgs.Protocol.ProcessId();
|
|
}
|
|
input.ReadMessage(clientId_);
|
|
break;
|
|
}
|
|
case 24:
|
|
{
|
|
BindResult = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 34:
|
|
{
|
|
if (bindResponse_ == null)
|
|
{
|
|
bindResponse_ = new Bgs.Protocol.Connection.V1.BindResponse();
|
|
}
|
|
input.ReadMessage(bindResponse_);
|
|
break;
|
|
}
|
|
case 42:
|
|
{
|
|
if (contentHandleArray_ == null)
|
|
{
|
|
contentHandleArray_ = new Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles();
|
|
}
|
|
input.ReadMessage(contentHandleArray_);
|
|
break;
|
|
}
|
|
case 48:
|
|
{
|
|
ServerTime = input.ReadUInt64();
|
|
break;
|
|
}
|
|
case 56:
|
|
{
|
|
UseBindlessRpc = input.ReadBool();
|
|
break;
|
|
}
|
|
case 66:
|
|
{
|
|
if (binaryContentHandleArray_ == null)
|
|
{
|
|
binaryContentHandleArray_ = new Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles();
|
|
}
|
|
input.ReadMessage(binaryContentHandleArray_);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class BoundService : pb::IMessage<BoundService>
|
|
{
|
|
private static readonly pb::MessageParser<BoundService> _parser = new pb::MessageParser<BoundService>(() => new BoundService());
|
|
public static pb::MessageParser<BoundService> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Connection.V1.ConnectionServiceReflection.Descriptor.MessageTypes[3]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public BoundService()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public BoundService(BoundService other) : this()
|
|
{
|
|
hash_ = other.hash_;
|
|
id_ = other.id_;
|
|
}
|
|
|
|
public BoundService Clone()
|
|
{
|
|
return new BoundService(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "hash" field.</summary>
|
|
public const int HashFieldNumber = 1;
|
|
private uint hash_;
|
|
public uint Hash
|
|
{
|
|
get { return hash_; }
|
|
set
|
|
{
|
|
hash_ = 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;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as BoundService);
|
|
}
|
|
|
|
public bool Equals(BoundService other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (Hash != other.Hash) return false;
|
|
if (Id != other.Id) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (Hash != 0) hash ^= Hash.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 (Hash != 0)
|
|
{
|
|
output.WriteRawTag(13);
|
|
output.WriteFixed32(Hash);
|
|
}
|
|
if (Id != 0)
|
|
{
|
|
output.WriteRawTag(16);
|
|
output.WriteUInt32(Id);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (Hash != 0)
|
|
{
|
|
size += 1 + 4;
|
|
}
|
|
if (Id != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Id);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(BoundService other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.Hash != 0)
|
|
{
|
|
Hash = other.Hash;
|
|
}
|
|
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 13:
|
|
{
|
|
Hash = input.ReadFixed32();
|
|
break;
|
|
}
|
|
case 16:
|
|
{
|
|
Id = input.ReadUInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class BindRequest : pb::IMessage<BindRequest>
|
|
{
|
|
private static readonly pb::MessageParser<BindRequest> _parser = new pb::MessageParser<BindRequest>(() => new BindRequest());
|
|
public static pb::MessageParser<BindRequest> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Connection.V1.ConnectionServiceReflection.Descriptor.MessageTypes[4]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public BindRequest()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public BindRequest(BindRequest other) : this()
|
|
{
|
|
deprecatedImportedServiceHash_ = other.deprecatedImportedServiceHash_.Clone();
|
|
deprecatedExportedService_ = other.deprecatedExportedService_.Clone();
|
|
exportedService_ = other.exportedService_.Clone();
|
|
importedService_ = other.importedService_.Clone();
|
|
}
|
|
|
|
public BindRequest Clone()
|
|
{
|
|
return new BindRequest(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "deprecated_imported_service_hash" field.</summary>
|
|
public const int DeprecatedImportedServiceHashFieldNumber = 1;
|
|
private static readonly pb::FieldCodec<uint> _repeated_deprecatedImportedServiceHash_codec
|
|
= pb::FieldCodec.ForFixed32(10);
|
|
private readonly pbc::RepeatedField<uint> deprecatedImportedServiceHash_ = new pbc::RepeatedField<uint>();
|
|
[System.ObsoleteAttribute()]
|
|
public pbc::RepeatedField<uint> DeprecatedImportedServiceHash
|
|
{
|
|
get { return deprecatedImportedServiceHash_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "deprecated_exported_service" field.</summary>
|
|
public const int DeprecatedExportedServiceFieldNumber = 2;
|
|
private static readonly pb::FieldCodec<Bgs.Protocol.Connection.V1.BoundService> _repeated_deprecatedExportedService_codec
|
|
= pb::FieldCodec.ForMessage(18, Bgs.Protocol.Connection.V1.BoundService.Parser);
|
|
private readonly pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService> deprecatedExportedService_ = new pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService>();
|
|
[System.ObsoleteAttribute()]
|
|
public pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService> DeprecatedExportedService
|
|
{
|
|
get { return deprecatedExportedService_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "exported_service" field.</summary>
|
|
public const int ExportedServiceFieldNumber = 3;
|
|
private static readonly pb::FieldCodec<Bgs.Protocol.Connection.V1.BoundService> _repeated_exportedService_codec
|
|
= pb::FieldCodec.ForMessage(26, Bgs.Protocol.Connection.V1.BoundService.Parser);
|
|
private readonly pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService> exportedService_ = new pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService>();
|
|
public pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService> ExportedService
|
|
{
|
|
get { return exportedService_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "imported_service" field.</summary>
|
|
public const int ImportedServiceFieldNumber = 4;
|
|
private static readonly pb::FieldCodec<Bgs.Protocol.Connection.V1.BoundService> _repeated_importedService_codec
|
|
= pb::FieldCodec.ForMessage(34, Bgs.Protocol.Connection.V1.BoundService.Parser);
|
|
private readonly pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService> importedService_ = new pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService>();
|
|
public pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService> ImportedService
|
|
{
|
|
get { return importedService_; }
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as BindRequest);
|
|
}
|
|
|
|
public bool Equals(BindRequest other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (!deprecatedImportedServiceHash_.Equals(other.deprecatedImportedServiceHash_)) return false;
|
|
if (!deprecatedExportedService_.Equals(other.deprecatedExportedService_)) return false;
|
|
if (!exportedService_.Equals(other.exportedService_)) return false;
|
|
if (!importedService_.Equals(other.importedService_)) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
hash ^= deprecatedImportedServiceHash_.GetHashCode();
|
|
hash ^= deprecatedExportedService_.GetHashCode();
|
|
hash ^= exportedService_.GetHashCode();
|
|
hash ^= importedService_.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
deprecatedImportedServiceHash_.WriteTo(output, _repeated_deprecatedImportedServiceHash_codec);
|
|
deprecatedExportedService_.WriteTo(output, _repeated_deprecatedExportedService_codec);
|
|
exportedService_.WriteTo(output, _repeated_exportedService_codec);
|
|
importedService_.WriteTo(output, _repeated_importedService_codec);
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
size += deprecatedImportedServiceHash_.CalculateSize(_repeated_deprecatedImportedServiceHash_codec);
|
|
size += deprecatedExportedService_.CalculateSize(_repeated_deprecatedExportedService_codec);
|
|
size += exportedService_.CalculateSize(_repeated_exportedService_codec);
|
|
size += importedService_.CalculateSize(_repeated_importedService_codec);
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(BindRequest other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
deprecatedImportedServiceHash_.Add(other.deprecatedImportedServiceHash_);
|
|
deprecatedExportedService_.Add(other.deprecatedExportedService_);
|
|
exportedService_.Add(other.exportedService_);
|
|
importedService_.Add(other.importedService_);
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 10:
|
|
case 13:
|
|
{
|
|
deprecatedImportedServiceHash_.AddEntriesFrom(input, _repeated_deprecatedImportedServiceHash_codec);
|
|
break;
|
|
}
|
|
case 18:
|
|
{
|
|
deprecatedExportedService_.AddEntriesFrom(input, _repeated_deprecatedExportedService_codec);
|
|
break;
|
|
}
|
|
case 26:
|
|
{
|
|
exportedService_.AddEntriesFrom(input, _repeated_exportedService_codec);
|
|
break;
|
|
}
|
|
case 34:
|
|
{
|
|
importedService_.AddEntriesFrom(input, _repeated_importedService_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class BindResponse : pb::IMessage<BindResponse>
|
|
{
|
|
private static readonly pb::MessageParser<BindResponse> _parser = new pb::MessageParser<BindResponse>(() => new BindResponse());
|
|
public static pb::MessageParser<BindResponse> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Connection.V1.ConnectionServiceReflection.Descriptor.MessageTypes[5]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public BindResponse()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public BindResponse(BindResponse other) : this()
|
|
{
|
|
importedServiceId_ = other.importedServiceId_.Clone();
|
|
}
|
|
|
|
public BindResponse Clone()
|
|
{
|
|
return new BindResponse(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "imported_service_id" field.</summary>
|
|
public const int ImportedServiceIdFieldNumber = 1;
|
|
private static readonly pb::FieldCodec<uint> _repeated_importedServiceId_codec
|
|
= pb::FieldCodec.ForUInt32(10);
|
|
private readonly pbc::RepeatedField<uint> importedServiceId_ = new pbc::RepeatedField<uint>();
|
|
[System.ObsoleteAttribute()]
|
|
public pbc::RepeatedField<uint> ImportedServiceId
|
|
{
|
|
get { return importedServiceId_; }
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as BindResponse);
|
|
}
|
|
|
|
public bool Equals(BindResponse other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (!importedServiceId_.Equals(other.importedServiceId_)) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
hash ^= importedServiceId_.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
importedServiceId_.WriteTo(output, _repeated_importedServiceId_codec);
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
size += importedServiceId_.CalculateSize(_repeated_importedServiceId_codec);
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(BindResponse other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
importedServiceId_.Add(other.importedServiceId_);
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 10:
|
|
case 8:
|
|
{
|
|
importedServiceId_.AddEntriesFrom(input, _repeated_importedServiceId_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class EchoRequest : pb::IMessage<EchoRequest>
|
|
{
|
|
private static readonly pb::MessageParser<EchoRequest> _parser = new pb::MessageParser<EchoRequest>(() => new EchoRequest());
|
|
public static pb::MessageParser<EchoRequest> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Connection.V1.ConnectionServiceReflection.Descriptor.MessageTypes[6]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public EchoRequest()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public EchoRequest(EchoRequest other) : this()
|
|
{
|
|
time_ = other.time_;
|
|
networkOnly_ = other.networkOnly_;
|
|
payload_ = other.payload_;
|
|
}
|
|
|
|
public EchoRequest Clone()
|
|
{
|
|
return new EchoRequest(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "time" field.</summary>
|
|
public const int TimeFieldNumber = 1;
|
|
private ulong time_;
|
|
public ulong Time
|
|
{
|
|
get { return time_; }
|
|
set
|
|
{
|
|
time_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "network_only" field.</summary>
|
|
public const int NetworkOnlyFieldNumber = 2;
|
|
private bool networkOnly_;
|
|
public bool NetworkOnly
|
|
{
|
|
get { return networkOnly_; }
|
|
set
|
|
{
|
|
networkOnly_ = 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 EchoRequest);
|
|
}
|
|
|
|
public bool Equals(EchoRequest other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (Time != other.Time) return false;
|
|
if (NetworkOnly != other.NetworkOnly) return false;
|
|
if (Payload != other.Payload) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (Time != 0UL) hash ^= Time.GetHashCode();
|
|
if (NetworkOnly != false) hash ^= NetworkOnly.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 (Time != 0UL)
|
|
{
|
|
output.WriteRawTag(9);
|
|
output.WriteFixed64(Time);
|
|
}
|
|
if (NetworkOnly != false)
|
|
{
|
|
output.WriteRawTag(16);
|
|
output.WriteBool(NetworkOnly);
|
|
}
|
|
if (Payload.Length != 0)
|
|
{
|
|
output.WriteRawTag(26);
|
|
output.WriteBytes(Payload);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (Time != 0UL)
|
|
{
|
|
size += 1 + 8;
|
|
}
|
|
if (NetworkOnly != false)
|
|
{
|
|
size += 1 + 1;
|
|
}
|
|
if (Payload.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeBytesSize(Payload);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(EchoRequest other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.Time != 0UL)
|
|
{
|
|
Time = other.Time;
|
|
}
|
|
if (other.NetworkOnly != false)
|
|
{
|
|
NetworkOnly = other.NetworkOnly;
|
|
}
|
|
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 9:
|
|
{
|
|
Time = input.ReadFixed64();
|
|
break;
|
|
}
|
|
case 16:
|
|
{
|
|
NetworkOnly = input.ReadBool();
|
|
break;
|
|
}
|
|
case 26:
|
|
{
|
|
Payload = input.ReadBytes();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class EchoResponse : pb::IMessage<EchoResponse>
|
|
{
|
|
private static readonly pb::MessageParser<EchoResponse> _parser = new pb::MessageParser<EchoResponse>(() => new EchoResponse());
|
|
public static pb::MessageParser<EchoResponse> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Connection.V1.ConnectionServiceReflection.Descriptor.MessageTypes[7]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public EchoResponse()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public EchoResponse(EchoResponse other) : this()
|
|
{
|
|
time_ = other.time_;
|
|
payload_ = other.payload_;
|
|
}
|
|
|
|
public EchoResponse Clone()
|
|
{
|
|
return new EchoResponse(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "time" field.</summary>
|
|
public const int TimeFieldNumber = 1;
|
|
private ulong time_;
|
|
public ulong Time
|
|
{
|
|
get { return time_; }
|
|
set
|
|
{
|
|
time_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "payload" field.</summary>
|
|
public const int PayloadFieldNumber = 2;
|
|
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 EchoResponse);
|
|
}
|
|
|
|
public bool Equals(EchoResponse other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (Time != other.Time) return false;
|
|
if (Payload != other.Payload) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (Time != 0UL) hash ^= Time.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 (Time != 0UL)
|
|
{
|
|
output.WriteRawTag(9);
|
|
output.WriteFixed64(Time);
|
|
}
|
|
if (Payload.Length != 0)
|
|
{
|
|
output.WriteRawTag(18);
|
|
output.WriteBytes(Payload);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (Time != 0UL)
|
|
{
|
|
size += 1 + 8;
|
|
}
|
|
if (Payload.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeBytesSize(Payload);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(EchoResponse other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.Time != 0UL)
|
|
{
|
|
Time = other.Time;
|
|
}
|
|
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 9:
|
|
{
|
|
Time = input.ReadFixed64();
|
|
break;
|
|
}
|
|
case 18:
|
|
{
|
|
Payload = input.ReadBytes();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class DisconnectRequest : pb::IMessage<DisconnectRequest>
|
|
{
|
|
private static readonly pb::MessageParser<DisconnectRequest> _parser = new pb::MessageParser<DisconnectRequest>(() => new DisconnectRequest());
|
|
public static pb::MessageParser<DisconnectRequest> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Connection.V1.ConnectionServiceReflection.Descriptor.MessageTypes[8]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public DisconnectRequest()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public DisconnectRequest(DisconnectRequest other) : this()
|
|
{
|
|
errorCode_ = other.errorCode_;
|
|
}
|
|
|
|
public DisconnectRequest Clone()
|
|
{
|
|
return new DisconnectRequest(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "error_code" field.</summary>
|
|
public const int ErrorCodeFieldNumber = 1;
|
|
private uint errorCode_;
|
|
public uint ErrorCode
|
|
{
|
|
get { return errorCode_; }
|
|
set
|
|
{
|
|
errorCode_ = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as DisconnectRequest);
|
|
}
|
|
|
|
public bool Equals(DisconnectRequest other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (ErrorCode != other.ErrorCode) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (ErrorCode != 0) hash ^= ErrorCode.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (ErrorCode != 0)
|
|
{
|
|
output.WriteRawTag(8);
|
|
output.WriteUInt32(ErrorCode);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (ErrorCode != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ErrorCode);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(DisconnectRequest other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.ErrorCode != 0)
|
|
{
|
|
ErrorCode = other.ErrorCode;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 8:
|
|
{
|
|
ErrorCode = input.ReadUInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class DisconnectNotification : pb::IMessage<DisconnectNotification>
|
|
{
|
|
private static readonly pb::MessageParser<DisconnectNotification> _parser = new pb::MessageParser<DisconnectNotification>(() => new DisconnectNotification());
|
|
public static pb::MessageParser<DisconnectNotification> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Connection.V1.ConnectionServiceReflection.Descriptor.MessageTypes[9]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public DisconnectNotification()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public DisconnectNotification(DisconnectNotification other) : this()
|
|
{
|
|
errorCode_ = other.errorCode_;
|
|
reason_ = other.reason_;
|
|
}
|
|
|
|
public DisconnectNotification Clone()
|
|
{
|
|
return new DisconnectNotification(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "error_code" field.</summary>
|
|
public const int ErrorCodeFieldNumber = 1;
|
|
private uint errorCode_;
|
|
public uint ErrorCode
|
|
{
|
|
get { return errorCode_; }
|
|
set
|
|
{
|
|
errorCode_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "reason" field.</summary>
|
|
public const int ReasonFieldNumber = 2;
|
|
private string reason_ = "";
|
|
public string Reason
|
|
{
|
|
get { return reason_; }
|
|
set
|
|
{
|
|
reason_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as DisconnectNotification);
|
|
}
|
|
|
|
public bool Equals(DisconnectNotification other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
if (ErrorCode != other.ErrorCode) return false;
|
|
if (Reason != other.Reason) return false;
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
if (ErrorCode != 0) hash ^= ErrorCode.GetHashCode();
|
|
if (Reason.Length != 0) hash ^= Reason.GetHashCode();
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
if (ErrorCode != 0)
|
|
{
|
|
output.WriteRawTag(8);
|
|
output.WriteUInt32(ErrorCode);
|
|
}
|
|
if (Reason.Length != 0)
|
|
{
|
|
output.WriteRawTag(18);
|
|
output.WriteString(Reason);
|
|
}
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
if (ErrorCode != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ErrorCode);
|
|
}
|
|
if (Reason.Length != 0)
|
|
{
|
|
size += 1 + pb::CodedOutputStream.ComputeStringSize(Reason);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(DisconnectNotification other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.ErrorCode != 0)
|
|
{
|
|
ErrorCode = other.ErrorCode;
|
|
}
|
|
if (other.Reason.Length != 0)
|
|
{
|
|
Reason = other.Reason;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
case 8:
|
|
{
|
|
ErrorCode = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 18:
|
|
{
|
|
Reason = input.ReadString();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
public sealed partial class EncryptRequest : pb::IMessage<EncryptRequest>
|
|
{
|
|
private static readonly pb::MessageParser<EncryptRequest> _parser = new pb::MessageParser<EncryptRequest>(() => new EncryptRequest());
|
|
public static pb::MessageParser<EncryptRequest> Parser { get { return _parser; } }
|
|
|
|
public static pbr::MessageDescriptor Descriptor
|
|
{
|
|
get { return Bgs.Protocol.Connection.V1.ConnectionServiceReflection.Descriptor.MessageTypes[10]; }
|
|
}
|
|
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor
|
|
{
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
public EncryptRequest()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
public EncryptRequest(EncryptRequest other) : this()
|
|
{
|
|
}
|
|
|
|
public EncryptRequest Clone()
|
|
{
|
|
return new EncryptRequest(this);
|
|
}
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
return Equals(other as EncryptRequest);
|
|
}
|
|
|
|
public bool Equals(EncryptRequest other)
|
|
{
|
|
if (ReferenceEquals(other, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this))
|
|
{
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hash = 1;
|
|
return hash;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
public void WriteTo(pb::CodedOutputStream output)
|
|
{
|
|
}
|
|
|
|
public int CalculateSize()
|
|
{
|
|
int size = 0;
|
|
return size;
|
|
}
|
|
|
|
public void MergeFrom(EncryptRequest other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void MergeFrom(pb::CodedInputStream input)
|
|
{
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0)
|
|
{
|
|
switch (tag)
|
|
{
|
|
default:
|
|
input.SkipLastField();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#endregion Designer generated code
|