mirror of
https://github.com/opensim/opensim.git
synced 2026-05-22 00:19:03 +08:00
631 lines
21 KiB
C#
631 lines
21 KiB
C#
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
|
|
using pb = global::Google.ProtocolBuffers;
|
|
using pbc = global::Google.ProtocolBuffers.Collections;
|
|
using pbd = global::Google.ProtocolBuffers.Descriptors;
|
|
using scg = global::System.Collections.Generic;
|
|
namespace Sirikata.Protocol._PBJ_Internal {
|
|
|
|
public static partial class MessageHeader {
|
|
|
|
#region Extension registration
|
|
public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
|
|
}
|
|
#endregion
|
|
#region Static variables
|
|
internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_Header__Descriptor;
|
|
internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.Header, global::Sirikata.Protocol._PBJ_Internal.Header.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_Header__FieldAccessorTable;
|
|
#endregion
|
|
#region Descriptor
|
|
public static pbd::FileDescriptor Descriptor {
|
|
get { return descriptor; }
|
|
}
|
|
private static pbd::FileDescriptor descriptor;
|
|
|
|
static MessageHeader() {
|
|
byte[] descriptorData = global::System.Convert.FromBase64String(
|
|
"ChNNZXNzYWdlSGVhZGVyLnByb3RvEh9TaXJpa2F0YS5Qcm90b2NvbC5fUEJK" +
|
|
"X0ludGVybmFsIooDCgZIZWFkZXISFQoNc291cmNlX29iamVjdBgBIAEoDBIT" +
|
|
"Cgtzb3VyY2VfcG9ydBgDIAEoDRIVCgxzb3VyY2Vfc3BhY2UYgAwgASgMEhoK" +
|
|
"EmRlc3RpbmF0aW9uX29iamVjdBgCIAEoDBIYChBkZXN0aW5hdGlvbl9wb3J0" +
|
|
"GAQgASgNEhoKEWRlc3RpbmF0aW9uX3NwYWNlGIEMIAEoDBIKCgJpZBgHIAEo" +
|
|
"AxIQCghyZXBseV9pZBgIIAEoAxJMCg1yZXR1cm5fc3RhdHVzGIAOIAEoDjI0" +
|
|
"LlNpcmlrYXRhLlByb3RvY29sLl9QQkpfSW50ZXJuYWwuSGVhZGVyLlJldHVy" +
|
|
"blN0YXR1cyJ/CgxSZXR1cm5TdGF0dXMSCwoHU1VDQ0VTUxAAEhMKD05FVFdP" +
|
|
"UktfRkFJTFVSRRABEhMKD1RJTUVPVVRfRkFJTFVSRRADEhIKDlBST1RPQ09M" +
|
|
"X0VSUk9SEAQSEAoMUE9SVF9GQUlMVVJFEAUSEgoOVU5LTk9XTl9PQkpFQ1QQ" +
|
|
"Bg==");
|
|
pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
|
|
descriptor = root;
|
|
internal__static_Sirikata_Protocol__PBJ_Internal_Header__Descriptor = Descriptor.MessageTypes[0];
|
|
internal__static_Sirikata_Protocol__PBJ_Internal_Header__FieldAccessorTable =
|
|
new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.Header, global::Sirikata.Protocol._PBJ_Internal.Header.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_Header__Descriptor,
|
|
new string[] { "SourceObject", "SourcePort", "SourceSpace", "DestinationObject", "DestinationPort", "DestinationSpace", "Id", "ReplyId", "ReturnStatus", });
|
|
return null;
|
|
};
|
|
pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
|
|
new pbd::FileDescriptor[] {
|
|
}, assigner);
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
#region Messages
|
|
public sealed partial class Header : pb::GeneratedMessage<Header, Header.Builder> {
|
|
private static readonly Header defaultInstance = new Builder().BuildPartial();
|
|
public static Header DefaultInstance {
|
|
get { return defaultInstance; }
|
|
}
|
|
|
|
public override Header DefaultInstanceForType {
|
|
get { return defaultInstance; }
|
|
}
|
|
|
|
protected override Header ThisMessage {
|
|
get { return this; }
|
|
}
|
|
|
|
public static pbd::MessageDescriptor Descriptor {
|
|
get { return global::Sirikata.Protocol._PBJ_Internal.MessageHeader.internal__static_Sirikata_Protocol__PBJ_Internal_Header__Descriptor; }
|
|
}
|
|
|
|
protected override pb::FieldAccess.FieldAccessorTable<Header, Header.Builder> InternalFieldAccessors {
|
|
get { return global::Sirikata.Protocol._PBJ_Internal.MessageHeader.internal__static_Sirikata_Protocol__PBJ_Internal_Header__FieldAccessorTable; }
|
|
}
|
|
|
|
#region Nested types
|
|
public static class Types {
|
|
public enum ReturnStatus {
|
|
SUCCESS = 0,
|
|
NETWORK_FAILURE = 1,
|
|
TIMEOUT_FAILURE = 3,
|
|
PROTOCOL_ERROR = 4,
|
|
PORT_FAILURE = 5,
|
|
UNKNOWN_OBJECT = 6,
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
public const int SourceObjectFieldNumber = 1;
|
|
private bool hasSourceObject;
|
|
private pb::ByteString sourceObject_ = pb::ByteString.Empty;
|
|
public bool HasSourceObject {
|
|
get { return hasSourceObject; }
|
|
}
|
|
public pb::ByteString SourceObject {
|
|
get { return sourceObject_; }
|
|
}
|
|
|
|
public const int SourcePortFieldNumber = 3;
|
|
private bool hasSourcePort;
|
|
private uint sourcePort_ = 0;
|
|
public bool HasSourcePort {
|
|
get { return hasSourcePort; }
|
|
}
|
|
[global::System.CLSCompliant(false)]
|
|
public uint SourcePort {
|
|
get { return sourcePort_; }
|
|
}
|
|
|
|
public const int SourceSpaceFieldNumber = 1536;
|
|
private bool hasSourceSpace;
|
|
private pb::ByteString sourceSpace_ = pb::ByteString.Empty;
|
|
public bool HasSourceSpace {
|
|
get { return hasSourceSpace; }
|
|
}
|
|
public pb::ByteString SourceSpace {
|
|
get { return sourceSpace_; }
|
|
}
|
|
|
|
public const int DestinationObjectFieldNumber = 2;
|
|
private bool hasDestinationObject;
|
|
private pb::ByteString destinationObject_ = pb::ByteString.Empty;
|
|
public bool HasDestinationObject {
|
|
get { return hasDestinationObject; }
|
|
}
|
|
public pb::ByteString DestinationObject {
|
|
get { return destinationObject_; }
|
|
}
|
|
|
|
public const int DestinationPortFieldNumber = 4;
|
|
private bool hasDestinationPort;
|
|
private uint destinationPort_ = 0;
|
|
public bool HasDestinationPort {
|
|
get { return hasDestinationPort; }
|
|
}
|
|
[global::System.CLSCompliant(false)]
|
|
public uint DestinationPort {
|
|
get { return destinationPort_; }
|
|
}
|
|
|
|
public const int DestinationSpaceFieldNumber = 1537;
|
|
private bool hasDestinationSpace;
|
|
private pb::ByteString destinationSpace_ = pb::ByteString.Empty;
|
|
public bool HasDestinationSpace {
|
|
get { return hasDestinationSpace; }
|
|
}
|
|
public pb::ByteString DestinationSpace {
|
|
get { return destinationSpace_; }
|
|
}
|
|
|
|
public const int IdFieldNumber = 7;
|
|
private bool hasId;
|
|
private long id_ = 0L;
|
|
public bool HasId {
|
|
get { return hasId; }
|
|
}
|
|
public long Id {
|
|
get { return id_; }
|
|
}
|
|
|
|
public const int ReplyIdFieldNumber = 8;
|
|
private bool hasReplyId;
|
|
private long replyId_ = 0L;
|
|
public bool HasReplyId {
|
|
get { return hasReplyId; }
|
|
}
|
|
public long ReplyId {
|
|
get { return replyId_; }
|
|
}
|
|
|
|
public const int ReturnStatusFieldNumber = 1792;
|
|
private bool hasReturnStatus;
|
|
private global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus returnStatus_ = global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus.SUCCESS;
|
|
public bool HasReturnStatus {
|
|
get { return hasReturnStatus; }
|
|
}
|
|
public global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus ReturnStatus {
|
|
get { return returnStatus_; }
|
|
}
|
|
|
|
public override bool IsInitialized {
|
|
get {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public override void WriteTo(pb::CodedOutputStream output) {
|
|
if (HasSourceObject) {
|
|
output.WriteBytes(1, SourceObject);
|
|
}
|
|
if (HasDestinationObject) {
|
|
output.WriteBytes(2, DestinationObject);
|
|
}
|
|
if (HasSourcePort) {
|
|
output.WriteUInt32(3, SourcePort);
|
|
}
|
|
if (HasDestinationPort) {
|
|
output.WriteUInt32(4, DestinationPort);
|
|
}
|
|
if (HasId) {
|
|
output.WriteInt64(7, Id);
|
|
}
|
|
if (HasReplyId) {
|
|
output.WriteInt64(8, ReplyId);
|
|
}
|
|
if (HasSourceSpace) {
|
|
output.WriteBytes(1536, SourceSpace);
|
|
}
|
|
if (HasDestinationSpace) {
|
|
output.WriteBytes(1537, DestinationSpace);
|
|
}
|
|
if (HasReturnStatus) {
|
|
output.WriteEnum(1792, (int) ReturnStatus);
|
|
}
|
|
UnknownFields.WriteTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public override int SerializedSize {
|
|
get {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (HasSourceObject) {
|
|
size += pb::CodedOutputStream.ComputeBytesSize(1, SourceObject);
|
|
}
|
|
if (HasSourcePort) {
|
|
size += pb::CodedOutputStream.ComputeUInt32Size(3, SourcePort);
|
|
}
|
|
if (HasSourceSpace) {
|
|
size += pb::CodedOutputStream.ComputeBytesSize(1536, SourceSpace);
|
|
}
|
|
if (HasDestinationObject) {
|
|
size += pb::CodedOutputStream.ComputeBytesSize(2, DestinationObject);
|
|
}
|
|
if (HasDestinationPort) {
|
|
size += pb::CodedOutputStream.ComputeUInt32Size(4, DestinationPort);
|
|
}
|
|
if (HasDestinationSpace) {
|
|
size += pb::CodedOutputStream.ComputeBytesSize(1537, DestinationSpace);
|
|
}
|
|
if (HasId) {
|
|
size += pb::CodedOutputStream.ComputeInt64Size(7, Id);
|
|
}
|
|
if (HasReplyId) {
|
|
size += pb::CodedOutputStream.ComputeInt64Size(8, ReplyId);
|
|
}
|
|
if (HasReturnStatus) {
|
|
size += pb::CodedOutputStream.ComputeEnumSize(1792, (int) ReturnStatus);
|
|
}
|
|
size += UnknownFields.SerializedSize;
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
}
|
|
|
|
public static Header ParseFrom(pb::ByteString data) {
|
|
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
|
|
}
|
|
public static Header ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
|
|
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
|
|
}
|
|
public static Header ParseFrom(byte[] data) {
|
|
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
|
|
}
|
|
public static Header ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
|
|
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
|
|
}
|
|
public static Header ParseFrom(global::System.IO.Stream input) {
|
|
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
|
|
}
|
|
public static Header ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
|
|
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
|
|
}
|
|
public static Header ParseDelimitedFrom(global::System.IO.Stream input) {
|
|
return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
|
|
}
|
|
public static Header ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
|
|
return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
|
|
}
|
|
public static Header ParseFrom(pb::CodedInputStream input) {
|
|
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
|
|
}
|
|
public static Header ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
|
|
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
|
|
}
|
|
public static Builder CreateBuilder() { return new Builder(); }
|
|
public override Builder ToBuilder() { return CreateBuilder(this); }
|
|
public override Builder CreateBuilderForType() { return new Builder(); }
|
|
public static Builder CreateBuilder(Header prototype) {
|
|
return (Builder) new Builder().MergeFrom(prototype);
|
|
}
|
|
|
|
public sealed partial class Builder : pb::GeneratedBuilder<Header, Builder> {
|
|
protected override Builder ThisBuilder {
|
|
get { return this; }
|
|
}
|
|
public Builder() {}
|
|
|
|
Header result = new Header();
|
|
|
|
protected override Header MessageBeingBuilt {
|
|
get { return result; }
|
|
}
|
|
|
|
public override Builder Clear() {
|
|
result = new Header();
|
|
return this;
|
|
}
|
|
|
|
public override Builder Clone() {
|
|
return new Builder().MergeFrom(result);
|
|
}
|
|
|
|
public override pbd::MessageDescriptor DescriptorForType {
|
|
get { return global::Sirikata.Protocol._PBJ_Internal.Header.Descriptor; }
|
|
}
|
|
|
|
public override Header DefaultInstanceForType {
|
|
get { return global::Sirikata.Protocol._PBJ_Internal.Header.DefaultInstance; }
|
|
}
|
|
|
|
public override Header BuildPartial() {
|
|
if (result == null) {
|
|
throw new global::System.InvalidOperationException("build() has already been called on this Builder");
|
|
}
|
|
Header returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public override Builder MergeFrom(pb::IMessage other) {
|
|
if (other is Header) {
|
|
return MergeFrom((Header) other);
|
|
} else {
|
|
base.MergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public override Builder MergeFrom(Header other) {
|
|
if (other == global::Sirikata.Protocol._PBJ_Internal.Header.DefaultInstance) return this;
|
|
if (other.HasSourceObject) {
|
|
SourceObject = other.SourceObject;
|
|
}
|
|
if (other.HasSourcePort) {
|
|
SourcePort = other.SourcePort;
|
|
}
|
|
if (other.HasSourceSpace) {
|
|
SourceSpace = other.SourceSpace;
|
|
}
|
|
if (other.HasDestinationObject) {
|
|
DestinationObject = other.DestinationObject;
|
|
}
|
|
if (other.HasDestinationPort) {
|
|
DestinationPort = other.DestinationPort;
|
|
}
|
|
if (other.HasDestinationSpace) {
|
|
DestinationSpace = other.DestinationSpace;
|
|
}
|
|
if (other.HasId) {
|
|
Id = other.Id;
|
|
}
|
|
if (other.HasReplyId) {
|
|
ReplyId = other.ReplyId;
|
|
}
|
|
if (other.HasReturnStatus) {
|
|
ReturnStatus = other.ReturnStatus;
|
|
}
|
|
this.MergeUnknownFields(other.UnknownFields);
|
|
return this;
|
|
}
|
|
|
|
public override Builder MergeFrom(pb::CodedInputStream input) {
|
|
return MergeFrom(input, pb::ExtensionRegistry.Empty);
|
|
}
|
|
|
|
public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
|
|
pb::UnknownFieldSet.Builder unknownFields = null;
|
|
while (true) {
|
|
uint tag = input.ReadTag();
|
|
switch (tag) {
|
|
case 0: {
|
|
if (unknownFields != null) {
|
|
this.UnknownFields = unknownFields.Build();
|
|
}
|
|
return this;
|
|
}
|
|
default: {
|
|
if (pb::WireFormat.IsEndGroupTag(tag)) {
|
|
if (unknownFields != null) {
|
|
this.UnknownFields = unknownFields.Build();
|
|
}
|
|
return this;
|
|
}
|
|
if (unknownFields == null) {
|
|
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
|
|
}
|
|
ParseUnknownField(input, unknownFields, extensionRegistry, tag);
|
|
break;
|
|
}
|
|
case 10: {
|
|
SourceObject = input.ReadBytes();
|
|
break;
|
|
}
|
|
case 18: {
|
|
DestinationObject = input.ReadBytes();
|
|
break;
|
|
}
|
|
case 24: {
|
|
SourcePort = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 32: {
|
|
DestinationPort = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 56: {
|
|
Id = input.ReadInt64();
|
|
break;
|
|
}
|
|
case 64: {
|
|
ReplyId = input.ReadInt64();
|
|
break;
|
|
}
|
|
case 12290: {
|
|
SourceSpace = input.ReadBytes();
|
|
break;
|
|
}
|
|
case 12298: {
|
|
DestinationSpace = input.ReadBytes();
|
|
break;
|
|
}
|
|
case 14336: {
|
|
int rawValue = input.ReadEnum();
|
|
if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus), rawValue)) {
|
|
if (unknownFields == null) {
|
|
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
|
|
}
|
|
unknownFields.MergeVarintField(1792, (ulong) rawValue);
|
|
} else {
|
|
ReturnStatus = (global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus) rawValue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public bool HasSourceObject {
|
|
get { return result.HasSourceObject; }
|
|
}
|
|
public pb::ByteString SourceObject {
|
|
get { return result.SourceObject; }
|
|
set { SetSourceObject(value); }
|
|
}
|
|
public Builder SetSourceObject(pb::ByteString value) {
|
|
pb::ThrowHelper.ThrowIfNull(value, "value");
|
|
result.hasSourceObject = true;
|
|
result.sourceObject_ = value;
|
|
return this;
|
|
}
|
|
public Builder ClearSourceObject() {
|
|
result.hasSourceObject = false;
|
|
result.sourceObject_ = pb::ByteString.Empty;
|
|
return this;
|
|
}
|
|
|
|
public bool HasSourcePort {
|
|
get { return result.HasSourcePort; }
|
|
}
|
|
[global::System.CLSCompliant(false)]
|
|
public uint SourcePort {
|
|
get { return result.SourcePort; }
|
|
set { SetSourcePort(value); }
|
|
}
|
|
[global::System.CLSCompliant(false)]
|
|
public Builder SetSourcePort(uint value) {
|
|
result.hasSourcePort = true;
|
|
result.sourcePort_ = value;
|
|
return this;
|
|
}
|
|
public Builder ClearSourcePort() {
|
|
result.hasSourcePort = false;
|
|
result.sourcePort_ = 0;
|
|
return this;
|
|
}
|
|
|
|
public bool HasSourceSpace {
|
|
get { return result.HasSourceSpace; }
|
|
}
|
|
public pb::ByteString SourceSpace {
|
|
get { return result.SourceSpace; }
|
|
set { SetSourceSpace(value); }
|
|
}
|
|
public Builder SetSourceSpace(pb::ByteString value) {
|
|
pb::ThrowHelper.ThrowIfNull(value, "value");
|
|
result.hasSourceSpace = true;
|
|
result.sourceSpace_ = value;
|
|
return this;
|
|
}
|
|
public Builder ClearSourceSpace() {
|
|
result.hasSourceSpace = false;
|
|
result.sourceSpace_ = pb::ByteString.Empty;
|
|
return this;
|
|
}
|
|
|
|
public bool HasDestinationObject {
|
|
get { return result.HasDestinationObject; }
|
|
}
|
|
public pb::ByteString DestinationObject {
|
|
get { return result.DestinationObject; }
|
|
set { SetDestinationObject(value); }
|
|
}
|
|
public Builder SetDestinationObject(pb::ByteString value) {
|
|
pb::ThrowHelper.ThrowIfNull(value, "value");
|
|
result.hasDestinationObject = true;
|
|
result.destinationObject_ = value;
|
|
return this;
|
|
}
|
|
public Builder ClearDestinationObject() {
|
|
result.hasDestinationObject = false;
|
|
result.destinationObject_ = pb::ByteString.Empty;
|
|
return this;
|
|
}
|
|
|
|
public bool HasDestinationPort {
|
|
get { return result.HasDestinationPort; }
|
|
}
|
|
[global::System.CLSCompliant(false)]
|
|
public uint DestinationPort {
|
|
get { return result.DestinationPort; }
|
|
set { SetDestinationPort(value); }
|
|
}
|
|
[global::System.CLSCompliant(false)]
|
|
public Builder SetDestinationPort(uint value) {
|
|
result.hasDestinationPort = true;
|
|
result.destinationPort_ = value;
|
|
return this;
|
|
}
|
|
public Builder ClearDestinationPort() {
|
|
result.hasDestinationPort = false;
|
|
result.destinationPort_ = 0;
|
|
return this;
|
|
}
|
|
|
|
public bool HasDestinationSpace {
|
|
get { return result.HasDestinationSpace; }
|
|
}
|
|
public pb::ByteString DestinationSpace {
|
|
get { return result.DestinationSpace; }
|
|
set { SetDestinationSpace(value); }
|
|
}
|
|
public Builder SetDestinationSpace(pb::ByteString value) {
|
|
pb::ThrowHelper.ThrowIfNull(value, "value");
|
|
result.hasDestinationSpace = true;
|
|
result.destinationSpace_ = value;
|
|
return this;
|
|
}
|
|
public Builder ClearDestinationSpace() {
|
|
result.hasDestinationSpace = false;
|
|
result.destinationSpace_ = pb::ByteString.Empty;
|
|
return this;
|
|
}
|
|
|
|
public bool HasId {
|
|
get { return result.HasId; }
|
|
}
|
|
public long Id {
|
|
get { return result.Id; }
|
|
set { SetId(value); }
|
|
}
|
|
public Builder SetId(long value) {
|
|
result.hasId = true;
|
|
result.id_ = value;
|
|
return this;
|
|
}
|
|
public Builder ClearId() {
|
|
result.hasId = false;
|
|
result.id_ = 0L;
|
|
return this;
|
|
}
|
|
|
|
public bool HasReplyId {
|
|
get { return result.HasReplyId; }
|
|
}
|
|
public long ReplyId {
|
|
get { return result.ReplyId; }
|
|
set { SetReplyId(value); }
|
|
}
|
|
public Builder SetReplyId(long value) {
|
|
result.hasReplyId = true;
|
|
result.replyId_ = value;
|
|
return this;
|
|
}
|
|
public Builder ClearReplyId() {
|
|
result.hasReplyId = false;
|
|
result.replyId_ = 0L;
|
|
return this;
|
|
}
|
|
|
|
public bool HasReturnStatus {
|
|
get { return result.HasReturnStatus; }
|
|
}
|
|
public global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus ReturnStatus {
|
|
get { return result.ReturnStatus; }
|
|
set { SetReturnStatus(value); }
|
|
}
|
|
public Builder SetReturnStatus(global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus value) {
|
|
result.hasReturnStatus = true;
|
|
result.returnStatus_ = value;
|
|
return this;
|
|
}
|
|
public Builder ClearReturnStatus() {
|
|
result.hasReturnStatus = false;
|
|
result.returnStatus_ = global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus.SUCCESS;
|
|
return this;
|
|
}
|
|
}
|
|
static Header() {
|
|
object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.MessageHeader.Descriptor, null);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|