From fd777cc7b964a302f335ad91735f02554582c648 Mon Sep 17 00:00:00 2001 From: Adam Frisby Date: Sun, 27 Dec 2009 15:03:10 +1100 Subject: * Implements Sirikata ClientStack Module * Just a stub (imports all the sirikata protocol, and that's about it.) --- OpenSim/Client/Sirikata/Protocol/MessageHeader.cs | 630 ++ .../Client/Sirikata/Protocol/MessageHeader.pbj.cs | 312 + OpenSim/Client/Sirikata/Protocol/PBJ.cs | 2077 +++++ OpenSim/Client/Sirikata/Protocol/Persistence.cs | 3299 ++++++++ .../Client/Sirikata/Protocol/Persistence.pbj.cs | 1516 ++++ OpenSim/Client/Sirikata/Protocol/Physics.cs | 840 ++ OpenSim/Client/Sirikata/Protocol/Physics.pbj.cs | 394 + OpenSim/Client/Sirikata/Protocol/Sirikata.cs | 8074 ++++++++++++++++++++ OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs | 3907 ++++++++++ OpenSim/Client/Sirikata/Protocol/Subscription.cs | 856 +++ .../Client/Sirikata/Protocol/Subscription.pbj.cs | 404 + OpenSim/Client/Sirikata/Protocol/Test.cs | 3773 +++++++++ OpenSim/Client/Sirikata/Protocol/Test.pbj.cs | 1734 +++++ OpenSim/Client/Sirikata/Protocol/Time.cs | 454 ++ OpenSim/Client/Sirikata/Protocol/Time.pbj.cs | 218 + 15 files changed, 28488 insertions(+) create mode 100644 OpenSim/Client/Sirikata/Protocol/MessageHeader.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/MessageHeader.pbj.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/PBJ.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/Persistence.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/Physics.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/Physics.pbj.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/Sirikata.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/Subscription.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/Test.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/Test.pbj.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/Time.cs create mode 100644 OpenSim/Client/Sirikata/Protocol/Time.pbj.cs (limited to 'OpenSim/Client/Sirikata/Protocol') diff --git a/OpenSim/Client/Sirikata/Protocol/MessageHeader.cs b/OpenSim/Client/Sirikata/Protocol/MessageHeader.cs new file mode 100644 index 0000000..22e10f7 --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/MessageHeader.cs @@ -0,0 +1,630 @@ +// 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 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(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 { + 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 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 { + 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 + +} diff --git a/OpenSim/Client/Sirikata/Protocol/MessageHeader.pbj.cs b/OpenSim/Client/Sirikata/Protocol/MessageHeader.pbj.cs new file mode 100644 index 0000000..eadb43b --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/MessageHeader.pbj.cs @@ -0,0 +1,312 @@ +using pbd = global::Google.ProtocolBuffers.Descriptors; +using pb = global::Google.ProtocolBuffers; +namespace Sirikata.Protocol { + public class Header : PBJ.IMessage { + protected _PBJ_Internal.Header super; + public _PBJ_Internal.Header _PBJSuper{ get { return super;} } + public Header() { + super=new _PBJ_Internal.Header(); + } + public Header(_PBJ_Internal.Header reference) { + super=reference; + } + public static Header defaultInstance= new Header (_PBJ_Internal.Header.DefaultInstance); + public static Header DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.Header.Descriptor; } } + public static class Types { + public enum ReturnStatus { + SUCCESS=_PBJ_Internal.Header.Types.ReturnStatus.SUCCESS, + NETWORK_FAILURE=_PBJ_Internal.Header.Types.ReturnStatus.NETWORK_FAILURE, + TIMEOUT_FAILURE=_PBJ_Internal.Header.Types.ReturnStatus.TIMEOUT_FAILURE, + PROTOCOL_ERROR=_PBJ_Internal.Header.Types.ReturnStatus.PROTOCOL_ERROR, + PORT_FAILURE=_PBJ_Internal.Header.Types.ReturnStatus.PORT_FAILURE, + UNKNOWN_OBJECT=_PBJ_Internal.Header.Types.ReturnStatus.UNKNOWN_OBJECT + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int SourceObjectFieldTag=1; + public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} } + public PBJ.UUID SourceObject{ get { + if (HasSourceObject) { + return PBJ._PBJ.CastUuid(super.SourceObject); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int SourcePortFieldTag=3; + public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} } + public uint SourcePort{ get { + if (HasSourcePort) { + return PBJ._PBJ.CastUint32(super.SourcePort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int SourceSpaceFieldTag=1536; + public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} } + public PBJ.UUID SourceSpace{ get { + if (HasSourceSpace) { + return PBJ._PBJ.CastUuid(super.SourceSpace); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int DestinationObjectFieldTag=2; + public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} } + public PBJ.UUID DestinationObject{ get { + if (HasDestinationObject) { + return PBJ._PBJ.CastUuid(super.DestinationObject); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int DestinationPortFieldTag=4; + public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} } + public uint DestinationPort{ get { + if (HasDestinationPort) { + return PBJ._PBJ.CastUint32(super.DestinationPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int DestinationSpaceFieldTag=1537; + public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} } + public PBJ.UUID DestinationSpace{ get { + if (HasDestinationSpace) { + return PBJ._PBJ.CastUuid(super.DestinationSpace); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int IdFieldTag=7; + public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} } + public long Id{ get { + if (HasId) { + return PBJ._PBJ.CastInt64(super.Id); + } else { + return PBJ._PBJ.CastInt64(); + } + } + } + public const int ReplyIdFieldTag=8; + public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} } + public long ReplyId{ get { + if (HasReplyId) { + return PBJ._PBJ.CastInt64(super.ReplyId); + } else { + return PBJ._PBJ.CastInt64(); + } + } + } + public const int ReturnStatusFieldTag=1792; + public bool HasReturnStatus{ get {return super.HasReturnStatus;} } + public Types.ReturnStatus ReturnStatus{ get { + if (HasReturnStatus) { + return (Types.ReturnStatus)super.ReturnStatus; + } else { + return new Types.ReturnStatus(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(Header prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static Header ParseFrom(pb::ByteString data) { + return new Header(_PBJ_Internal.Header.ParseFrom(data)); + } + public static Header ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new Header(_PBJ_Internal.Header.ParseFrom(data,er)); + } + public static Header ParseFrom(byte[] data) { + return new Header(_PBJ_Internal.Header.ParseFrom(data)); + } + public static Header ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new Header(_PBJ_Internal.Header.ParseFrom(data,er)); + } + public static Header ParseFrom(global::System.IO.Stream data) { + return new Header(_PBJ_Internal.Header.ParseFrom(data)); + } + public static Header ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new Header(_PBJ_Internal.Header.ParseFrom(data,er)); + } + public static Header ParseFrom(pb::CodedInputStream data) { + return new Header(_PBJ_Internal.Header.ParseFrom(data)); + } + public static Header ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new Header(_PBJ_Internal.Header.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.Header.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.Header.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.Header.Builder();} + public Builder(_PBJ_Internal.Header.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(Header prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public Header BuildPartial() {return new Header(super.BuildPartial());} + public Header Build() {if (_HasAllPBJFields) return new Header(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return Header.Descriptor; } } + public Builder ClearSourceObject() { super.ClearSourceObject();return this;} + public const int SourceObjectFieldTag=1; + public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} } + public PBJ.UUID SourceObject{ get { + if (HasSourceObject) { + return PBJ._PBJ.CastUuid(super.SourceObject); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.SourceObject=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearSourcePort() { super.ClearSourcePort();return this;} + public const int SourcePortFieldTag=3; + public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} } + public uint SourcePort{ get { + if (HasSourcePort) { + return PBJ._PBJ.CastUint32(super.SourcePort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.SourcePort=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearSourceSpace() { super.ClearSourceSpace();return this;} + public const int SourceSpaceFieldTag=1536; + public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} } + public PBJ.UUID SourceSpace{ get { + if (HasSourceSpace) { + return PBJ._PBJ.CastUuid(super.SourceSpace); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.SourceSpace=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearDestinationObject() { super.ClearDestinationObject();return this;} + public const int DestinationObjectFieldTag=2; + public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} } + public PBJ.UUID DestinationObject{ get { + if (HasDestinationObject) { + return PBJ._PBJ.CastUuid(super.DestinationObject); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.DestinationObject=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearDestinationPort() { super.ClearDestinationPort();return this;} + public const int DestinationPortFieldTag=4; + public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} } + public uint DestinationPort{ get { + if (HasDestinationPort) { + return PBJ._PBJ.CastUint32(super.DestinationPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.DestinationPort=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearDestinationSpace() { super.ClearDestinationSpace();return this;} + public const int DestinationSpaceFieldTag=1537; + public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} } + public PBJ.UUID DestinationSpace{ get { + if (HasDestinationSpace) { + return PBJ._PBJ.CastUuid(super.DestinationSpace); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.DestinationSpace=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearId() { super.ClearId();return this;} + public const int IdFieldTag=7; + public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} } + public long Id{ get { + if (HasId) { + return PBJ._PBJ.CastInt64(super.Id); + } else { + return PBJ._PBJ.CastInt64(); + } + } + set { + super.Id=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearReplyId() { super.ClearReplyId();return this;} + public const int ReplyIdFieldTag=8; + public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} } + public long ReplyId{ get { + if (HasReplyId) { + return PBJ._PBJ.CastInt64(super.ReplyId); + } else { + return PBJ._PBJ.CastInt64(); + } + } + set { + super.ReplyId=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;} + public const int ReturnStatusFieldTag=1792; + public bool HasReturnStatus{ get {return super.HasReturnStatus;} } + public Types.ReturnStatus ReturnStatus{ get { + if (HasReturnStatus) { + return (Types.ReturnStatus)super.ReturnStatus; + } else { + return new Types.ReturnStatus(); + } + } + set { + super.ReturnStatus=((_PBJ_Internal.Header.Types.ReturnStatus)value); + } + } + } + } +} diff --git a/OpenSim/Client/Sirikata/Protocol/PBJ.cs b/OpenSim/Client/Sirikata/Protocol/PBJ.cs new file mode 100644 index 0000000..46888b5 --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/PBJ.cs @@ -0,0 +1,2077 @@ +using System; +namespace PBJ +{ + + public class IMessage + { + public virtual Google.ProtocolBuffers.IMessage _PBJISuper { get { return null; } } + protected virtual bool _HasAllPBJFields { get { return true; } } + public void WriteTo(Google.ProtocolBuffers.CodedOutputStream output) + { + _PBJISuper.WriteTo(output); + } + public override bool Equals(object other) + { + return _PBJISuper.Equals(other); + } + public int SerializedSize { get { return _PBJISuper.SerializedSize; } } + + public override int GetHashCode() { return _PBJISuper.GetHashCode(); } + + public override string ToString() + { + return _PBJISuper.ToString(); + } + public virtual IBuilder WeakCreateBuilderForType() { return null; } + public Google.ProtocolBuffers.ByteString ToByteString() + { + return _PBJISuper.ToByteString(); + } + public byte[] ToByteArray() + { + return _PBJISuper.ToByteArray(); + } + public void WriteTo(global::System.IO.Stream output) + { + _PBJISuper.WriteTo(output); + } + // Google.ProtocolBuffers.MessageDescriptor DescriptorForType { get {return _PBJISuper.DescriptorForType;} } + public Google.ProtocolBuffers.UnknownFieldSet UnknownFields { get { return _PBJISuper.UnknownFields; } } + public class IBuilder + { + public virtual Google.ProtocolBuffers.IBuilder _PBJISuper { get { return null; } } + protected virtual bool _HasAllPBJFields { get { return true; } } + } + } + + public struct Vector2f + { + + public float x; + public float y; + + + public Vector2f(float _x, float _y) + { + x = _x; y = _y; + } + + public Vector2f(Vector2f cpy) + { + x = cpy.x; y = cpy.y; + } + + + public Vector2f Negate() + { + return new Vector2f(-x, -y); + } + + public Vector2f Add(Vector2f rhs) + { + return new Vector2f(x + rhs.x, y + rhs.y); + } + + public Vector2f Subtract(Vector2f rhs) + { + return new Vector2f(x - rhs.x, y - rhs.y); + } + + public Vector2f Multiply(Vector2f rhs) + { + return new Vector2f(x * rhs.x, y * rhs.y); + } + + public Vector2f Multiply(float s) + { + return new Vector2f(x * s, y * s); + } + + public Vector2f Divide(Vector2f rhs) + { + return new Vector2f(x / rhs.x, y / rhs.y); + } + + public Vector2f Divide(float s) + { + return new Vector2f(x / s, y / s); + } + + public float Dot(Vector2f rhs) + { + return (x * rhs.x + y * rhs.y); + } + + public void Normalize() + { + float len = Length; + if (len != 0.0) + { + x /= len; y /= len; + } + } + + public Vector2f Normalized + { + get + { + Vector2f normed = new Vector2f(this); + normed.Normalize(); + return normed; + } + } + + public float SquaredLength + { + get + { + return (x * x + y * y); + } + } + public float Length + { + get + { + return (float)Math.Sqrt(SquaredLength); + } + } + + + public override string ToString() + { + return String.Format("<{0}, {1}>", x, y); + } + + + public static Vector2f operator -(Vector2f uo) + { + return uo.Negate(); + } + + public static Vector2f operator +(Vector2f lhs, Vector2f rhs) + { + return lhs.Add(rhs); + } + + public static Vector2f operator -(Vector2f lhs, Vector2f rhs) + { + return lhs.Subtract(rhs); + } + + public static Vector2f operator *(Vector2f lhs, Vector2f rhs) + { + return lhs.Multiply(rhs); + } + + public static Vector2f operator *(Vector2f lhs, float rhs) + { + return lhs.Multiply(rhs); + } + public static Vector2f operator *(float lhs, Vector2f rhs) + { + return rhs.Multiply(lhs); + } + + public static Vector2f operator /(Vector2f lhs, Vector2f rhs) + { + return lhs.Divide(rhs); + } + + public static Vector2f operator /(Vector2f lhs, float rhs) + { + return lhs.Divide(rhs); + } + + } // struct Vector2f + + public struct Vector2d + { + + public double x; + public double y; + + + public Vector2d(double _x, double _y) + { + x = _x; y = _y; + } + + public Vector2d(Vector2d cpy) + { + x = cpy.x; y = cpy.y; + } + + + public Vector2d Negate() + { + return new Vector2d(-x, -y); + } + + public Vector2d Add(Vector2d rhs) + { + return new Vector2d(x + rhs.x, y + rhs.y); + } + + public Vector2d Subtract(Vector2d rhs) + { + return new Vector2d(x - rhs.x, y - rhs.y); + } + + public Vector2d Multiply(Vector2d rhs) + { + return new Vector2d(x * rhs.x, y * rhs.y); + } + + public Vector2d Multiply(double s) + { + return new Vector2d(x * s, y * s); + } + + public Vector2d Divide(Vector2d rhs) + { + return new Vector2d(x / rhs.x, y / rhs.y); + } + + public Vector2d Divide(double s) + { + return new Vector2d(x / s, y / s); + } + + public double Dot(Vector2d rhs) + { + return (x * rhs.x + y * rhs.y); + } + + public void Normalize() + { + double len = Length; + if (len != 0.0) + { + x /= len; y /= len; + } + } + + public Vector2d Normalized + { + get + { + Vector2d normed = new Vector2d(this); + normed.Normalize(); + return normed; + } + } + + public double SquaredLength + { + get + { + return (x * x + y * y); + } + } + public double Length + { + get + { + return Math.Sqrt(SquaredLength); + } + } + + + public override string ToString() + { + return String.Format("<{0}, {1}>", x, y); + } + + + public static Vector2d operator -(Vector2d uo) + { + return uo.Negate(); + } + + public static Vector2d operator +(Vector2d lhs, Vector2d rhs) + { + return lhs.Add(rhs); + } + + public static Vector2d operator -(Vector2d lhs, Vector2d rhs) + { + return lhs.Subtract(rhs); + } + + public static Vector2d operator *(Vector2d lhs, Vector2d rhs) + { + return lhs.Multiply(rhs); + } + + public static Vector2d operator *(Vector2d lhs, double rhs) + { + return lhs.Multiply(rhs); + } + public static Vector2d operator *(double lhs, Vector2d rhs) + { + return rhs.Multiply(lhs); + } + + public static Vector2d operator /(Vector2d lhs, Vector2d rhs) + { + return lhs.Divide(rhs); + } + + public static Vector2d operator /(Vector2d lhs, double rhs) + { + return lhs.Divide(rhs); + } + + } // struct Vector2d + + public struct Vector3f + { + + public float x; + public float y; + public float z; + + + public Vector3f(float _x, float _y, float _z) + { + x = _x; y = _y; z = _z; + } + + public Vector3f(Vector3f cpy) + { + x = cpy.x; y = cpy.y; z = cpy.z; + } + + + public Vector3f Negate() + { + return new Vector3f(-x, -y, -z); + } + + public Vector3f Add(Vector3f rhs) + { + return new Vector3f(x + rhs.x, y + rhs.y, z + rhs.z); + } + + public Vector3f Subtract(Vector3f rhs) + { + return new Vector3f(x - rhs.x, y - rhs.y, z - rhs.z); + } + + public Vector3f Multiply(Vector3f rhs) + { + return new Vector3f(x * rhs.x, y * rhs.y, z * rhs.z); + } + + public Vector3f Multiply(float s) + { + return new Vector3f(x * s, y * s, z * s); + } + + public Vector3f Divide(Vector3f rhs) + { + return new Vector3f(x / rhs.x, y / rhs.y, z / rhs.z); + } + + public Vector3f Divide(float s) + { + return new Vector3f(x / s, y / s, z / s); + } + + public float Dot(Vector3f rhs) + { + return (x * rhs.x + y * rhs.y + z * rhs.z); + } + + public Vector3f Cross(Vector3f rhs) + { + return new Vector3f(y * rhs.z - z * rhs.y, z * rhs.x - x * rhs.z, x * rhs.y - y * rhs.x); + } + + public void Normalize() + { + float len = Length; + if (len != 0.0) + { + x /= len; y /= len; z /= len; + } + } + + public Vector3f Normalized + { + get + { + Vector3f normed = new Vector3f(this); + normed.Normalize(); + return normed; + } + } + + public float SquaredLength + { + get + { + return (x * x + y * y + z * z); + } + } + public float Length + { + get + { + return (float)Math.Sqrt(SquaredLength); + } + } + + + public override string ToString() + { + return String.Format("<{0}, {1}, {2}>", x, y, z); + } + + + public static Vector3f operator -(Vector3f uo) + { + return uo.Negate(); + } + + public static Vector3f operator +(Vector3f lhs, Vector3f rhs) + { + return lhs.Add(rhs); + } + + public static Vector3f operator -(Vector3f lhs, Vector3f rhs) + { + return lhs.Subtract(rhs); + } + + public static Vector3f operator *(Vector3f lhs, Vector3f rhs) + { + return lhs.Multiply(rhs); + } + + public static Vector3f operator *(Vector3f lhs, float rhs) + { + return lhs.Multiply(rhs); + } + public static Vector3f operator *(float lhs, Vector3f rhs) + { + return rhs.Multiply(lhs); + } + + public static Vector3f operator /(Vector3f lhs, Vector3f rhs) + { + return lhs.Divide(rhs); + } + + public static Vector3f operator /(Vector3f lhs, float rhs) + { + return lhs.Divide(rhs); + } + + } // struct Vector3f + + public struct Vector3d + { + + public double x; + public double y; + public double z; + + + public Vector3d(double _x, double _y, double _z) + { + x = _x; y = _y; z = _z; + } + + public Vector3d(Vector3d cpy) + { + x = cpy.x; y = cpy.y; z = cpy.z; + } + + + public Vector3d Negate() + { + return new Vector3d(-x, -y, -z); + } + + public Vector3d Add(Vector3d rhs) + { + return new Vector3d(x + rhs.x, y + rhs.y, z + rhs.z); + } + + public Vector3d Subtract(Vector3d rhs) + { + return new Vector3d(x - rhs.x, y - rhs.y, z - rhs.z); + } + + public Vector3d Multiply(Vector3d rhs) + { + return new Vector3d(x * rhs.x, y * rhs.y, z * rhs.z); + } + + public Vector3d Multiply(double s) + { + return new Vector3d(x * s, y * s, z * s); + } + + public Vector3d Divide(Vector3d rhs) + { + return new Vector3d(x / rhs.x, y / rhs.y, z / rhs.z); + } + + public Vector3d Divide(double s) + { + return new Vector3d(x / s, y / s, z / s); + } + + public double Dot(Vector3d rhs) + { + return (x * rhs.x + y * rhs.y + z * rhs.z); + } + + public Vector3d Cross(Vector3d rhs) + { + return new Vector3d(y * rhs.z - z * rhs.y, z * rhs.x - x * rhs.z, x * rhs.y - y * rhs.x); + } + + public void Normalize() + { + double len = Length; + if (len != 0.0) + { + x /= len; y /= len; z /= len; + } + } + + public Vector3d Normalized + { + get + { + Vector3d normed = new Vector3d(this); + normed.Normalize(); + return normed; + } + } + + public double SquaredLength + { + get + { + return (x * x + y * y + z * z); + } + } + public double Length + { + get + { + return Math.Sqrt(SquaredLength); + } + } + + + public override string ToString() + { + return String.Format("<{0}, {1}, {2}>", x, y, z); + } + + + public static Vector3d operator -(Vector3d uo) + { + return uo.Negate(); + } + + public static Vector3d operator +(Vector3d lhs, Vector3d rhs) + { + return lhs.Add(rhs); + } + + public static Vector3d operator -(Vector3d lhs, Vector3d rhs) + { + return lhs.Subtract(rhs); + } + + public static Vector3d operator *(Vector3d lhs, Vector3d rhs) + { + return lhs.Multiply(rhs); + } + + public static Vector3d operator *(Vector3d lhs, double rhs) + { + return lhs.Multiply(rhs); + } + public static Vector3d operator *(double lhs, Vector3d rhs) + { + return rhs.Multiply(lhs); + } + + public static Vector3d operator /(Vector3d lhs, Vector3d rhs) + { + return lhs.Divide(rhs); + } + + public static Vector3d operator /(Vector3d lhs, double rhs) + { + return lhs.Divide(rhs); + } + + } // struct Vector3d + + public struct Quaternion + { + + public float w; + public float x; + public float y; + public float z; + + + public Quaternion(float _w, float _x, float _y, float _z) + { + w = _w; x = _x; y = _y; z = _z; + } + + public Quaternion(Quaternion cpy) + { + w = cpy.w; x = cpy.x; y = cpy.y; z = cpy.z; + } + + public static readonly Quaternion Identity = new Quaternion((float)1.0, (float)0.0, (float)0.0, (float)0.0); + + public static Quaternion FromAxisAngle(Vector3f axis, float rads) + { + float halfAngle = rads * 0.5f; + float sinHalf = (float)Math.Sin(halfAngle); + float w = (float)Math.Cos(halfAngle); + float x = sinHalf * axis.x; + float y = sinHalf * axis.y; + float z = sinHalf * axis.z; + return new Quaternion(w, x, y, z); + } + + public static Quaternion FromAxisAngle(Vector3d axis, float rads) + { + float halfAngle = rads * 0.5f; + float sinHalf = (float)Math.Sin(halfAngle); + float w = (float)Math.Cos(halfAngle); + float x = (float)(sinHalf * axis.x); + float y = (float)(sinHalf * axis.y); + float z = (float)(sinHalf * axis.z); + return new Quaternion(w, x, y, z); + } + + + public Quaternion Add(Quaternion rhs) + { + return new Quaternion(w + rhs.w, x + rhs.x, y + rhs.y, z + rhs.z); + } + + public Quaternion Subtract(Quaternion rhs) + { + return new Quaternion(w - rhs.w, x - rhs.x, y - rhs.y, z - rhs.z); + } + + public Quaternion Multiply(Quaternion rhs) + { + return new Quaternion( + w * rhs.w - x * rhs.x - y * rhs.y - z * rhs.z, + w * rhs.x + x * rhs.w + y * rhs.z - z * rhs.y, + w * rhs.y + y * rhs.w + z * rhs.x - x * rhs.z, + w * rhs.z + z * rhs.w + x * rhs.y - y * rhs.x + ); + } + + public Vector3f Multiply(Vector3f rhs) + { + Vector3f qvec = new Vector3f(x, y, z); + Vector3f uv = qvec.Cross(rhs); + Vector3f uuv = qvec.Cross(uv); + uv *= 2.0f * w; + uuv *= 2.0f; + + return rhs + uv + uuv; + } + + public Vector3d Multiply(Vector3d rhs) + { + Vector3d qvec = new Vector3d(x, y, z); + Vector3d uv = qvec.Cross(rhs); + Vector3d uuv = qvec.Cross(uv); + uv *= 2.0f * w; + uuv *= 2.0f; + + return rhs + uv + uuv; + } + + public Quaternion Multiply(float rhs) + { + return new Quaternion(w * rhs, x * rhs, y * rhs, z * rhs); + } + + public Quaternion Negate() + { + return new Quaternion(-w, -x, -y, -z); + } + + public float Dot(Quaternion rhs) + { + return (w * rhs.w + x * rhs.x + y * rhs.y + z * rhs.z); + } + + public float Norm + { + get + { + return (float)Math.Sqrt(w * w + x * x + y * y + z * z); + } + } + + public float SquareNorm + { + get + { + return (w * w + x * x + y * y + z * z); + } + } + + public void Normalize() + { + float len = SquareNorm; + if (len == 0.0) return; + float factor = 1.0f / (float)Math.Sqrt(len); + this *= factor; + } + + public Quaternion Normalized + { + get + { + Quaternion q = new Quaternion(this); + q.Normalize(); + return q; + } + } + + public Quaternion Inverse + { + get + { + float norm = SquareNorm; + if (norm > 0.0) + { + double invnorm = 1.0 / norm; + return new Quaternion((float)(w * invnorm), (float)(-x * invnorm), (float)(-y * invnorm), (float)(-z * invnorm)); + } + else + return new Quaternion((float)0.0, 0.0f, 0.0f, 0.0f); + } + } + + + public override string ToString() + { + return String.Format("<{0}, {1}, {2}, {3}>", w, x, y, z); + } + + + + public static Quaternion operator -(Quaternion uo) + { + return uo.Negate(); + } + + public static Quaternion operator +(Quaternion lhs, Quaternion rhs) + { + return lhs.Add(rhs); + } + + public static Quaternion operator -(Quaternion lhs, Quaternion rhs) + { + return lhs.Subtract(rhs); + } + + public static Vector3f operator *(Quaternion lhs, Vector3f rhs) + { + return lhs.Multiply(rhs); + } + + public static Vector3d operator *(Quaternion lhs, Vector3d rhs) + { + return lhs.Multiply(rhs); + } + + public static Quaternion operator *(Quaternion lhs, Quaternion rhs) + { + return lhs.Multiply(rhs); + } + + public static Quaternion operator *(Quaternion lhs, float rhs) + { + return lhs.Multiply(rhs); + } + + public static Quaternion operator *(float lhs, Quaternion rhs) + { + return rhs.Multiply(lhs); + } + + } // struct Quaternion + + + public struct Vector4f + { + + public float x; + public float y; + public float z; + public float w; + + + public Vector4f(float _x, float _y, float _z, float _w) + { + x = _x; y = _y; z = _z; w = _w; + } + + public Vector4f(Vector4f cpy) + { + x = cpy.x; y = cpy.y; z = cpy.z; w = cpy.w; + } + + + public Vector4f Negate() + { + return new Vector4f(-x, -y, -z, -w); + } + + public Vector4f Add(Vector4f rhs) + { + return new Vector4f(x + rhs.x, y + rhs.y, z + rhs.z, w + rhs.w); + } + + public Vector4f Subtract(Vector4f rhs) + { + return new Vector4f(x - rhs.x, y - rhs.y, z - rhs.z, w - rhs.w); + } + + public Vector4f Multiply(Vector4f rhs) + { + return new Vector4f(x * rhs.x, y * rhs.y, z * rhs.z, w * rhs.w); + } + + public Vector4f Multiply(float s) + { + return new Vector4f(x * s, y * s, z * s, w * s); + } + + public Vector4f Divide(Vector4f rhs) + { + return new Vector4f(x / rhs.x, y / rhs.y, z / rhs.z, w / rhs.w); + } + + public Vector4f Divide(float s) + { + return new Vector4f(x / s, y / s, z / s, w / s); + } + + public float Dot(Vector4f rhs) + { + return (x * rhs.x + y * rhs.y + z * rhs.z + w * rhs.w); + } + + public void Normalize() + { + float len = Length; + if (len != 0.0) + { + x /= len; y /= len; z /= len; w /= len; + } + } + + public Vector4f Normalized + { + get + { + Vector4f normed = new Vector4f(this); + normed.Normalize(); + return normed; + } + } + + public float SquaredLength + { + get + { + return (x * x + y * y + z * z + w * w); + } + } + public float Length + { + get + { + return (float)Math.Sqrt(SquaredLength); + } + } + + + public override string ToString() + { + return String.Format("<{0}, {1}, {2}, {3}>", x, y, z, w); + } + + + public static Vector4f operator -(Vector4f uo) + { + return uo.Negate(); + } + + public static Vector4f operator +(Vector4f lhs, Vector4f rhs) + { + return lhs.Add(rhs); + } + + public static Vector4f operator -(Vector4f lhs, Vector4f rhs) + { + return lhs.Subtract(rhs); + } + + public static Vector4f operator *(Vector4f lhs, Vector4f rhs) + { + return lhs.Multiply(rhs); + } + + public static Vector4f operator *(Vector4f lhs, float rhs) + { + return lhs.Multiply(rhs); + } + public static Vector4f operator *(float lhs, Vector4f rhs) + { + return rhs.Multiply(lhs); + } + + public static Vector4f operator /(Vector4f lhs, Vector4f rhs) + { + return lhs.Divide(rhs); + } + + public static Vector4f operator /(Vector4f lhs, float rhs) + { + return lhs.Divide(rhs); + } + + } // struct Vector4f + + + + public struct Vector4d + { + + public double x; + public double y; + public double z; + public double w; + + + public Vector4d(double _x, double _y, double _z, double _w) + { + x = _x; y = _y; z = _z; w = _w; + } + + public Vector4d(Vector4d cpy) + { + x = cpy.x; y = cpy.y; z = cpy.z; w = cpy.w; + } + + + public Vector4d Negate() + { + return new Vector4d(-x, -y, -z, -w); + } + + public Vector4d Add(Vector4d rhs) + { + return new Vector4d(x + rhs.x, y + rhs.y, z + rhs.z, w + rhs.w); + } + + public Vector4d Subtract(Vector4d rhs) + { + return new Vector4d(x - rhs.x, y - rhs.y, z - rhs.z, w - rhs.w); + } + + public Vector4d Multiply(Vector4d rhs) + { + return new Vector4d(x * rhs.x, y * rhs.y, z * rhs.z, w * rhs.w); + } + + public Vector4d Multiply(double s) + { + return new Vector4d(x * s, y * s, z * s, w * s); + } + + public Vector4d Divide(Vector4d rhs) + { + return new Vector4d(x / rhs.x, y / rhs.y, z / rhs.z, w / rhs.w); + } + + public Vector4d Divide(double s) + { + return new Vector4d(x / s, y / s, z / s, w / s); + } + + public double Dot(Vector4d rhs) + { + return (x * rhs.x + y * rhs.y + z * rhs.z + w * rhs.w); + } + + public void Normalize() + { + double len = Length; + if (len != 0.0) + { + x /= len; y /= len; z /= len; w /= len; + } + } + + public Vector4d Normalized + { + get + { + Vector4d normed = new Vector4d(this); + normed.Normalize(); + return normed; + } + } + + public double SquaredLength + { + get + { + return (x * x + y * y + z * z + w * w); + } + } + public double Length + { + get + { + return Math.Sqrt(SquaredLength); + } + } + + + public override string ToString() + { + return String.Format("<{0}, {1}, {2}, {3}>", x, y, z, w); + } + + + public static Vector4d operator -(Vector4d uo) + { + return uo.Negate(); + } + + public static Vector4d operator +(Vector4d lhs, Vector4d rhs) + { + return lhs.Add(rhs); + } + + public static Vector4d operator -(Vector4d lhs, Vector4d rhs) + { + return lhs.Subtract(rhs); + } + + public static Vector4d operator *(Vector4d lhs, Vector4d rhs) + { + return lhs.Multiply(rhs); + } + + public static Vector4d operator *(Vector4d lhs, double rhs) + { + return lhs.Multiply(rhs); + } + public static Vector4d operator *(double lhs, Vector4d rhs) + { + return rhs.Multiply(lhs); + } + + public static Vector4d operator /(Vector4d lhs, Vector4d rhs) + { + return lhs.Divide(rhs); + } + + public static Vector4d operator /(Vector4d lhs, double rhs) + { + return lhs.Divide(rhs); + } + + } // struct Vector4d + + + + public struct BoundingBox3f3f + { + Vector3f mMin; + Vector3f mDiag; + public BoundingBox3f3f(float minx, float miny, float minz, float diagx, float diagy, float diagz) + { + mMin.x = minx; + mMin.y = miny; + mMin.z = minz; + + mDiag.x = diagx; + mDiag.y = diagy; + mDiag.z = diagz; + } + public BoundingBox3f3f(Vector3f min, Vector3f max) + { + mMin = min; + mDiag = (max - min); + } + public BoundingBox3f3f(BoundingBox3f3f cpy, Vector3f scale) + { + mMin.x = (float)(cpy.mMin.x * scale.x); + mMin.y = (float)(cpy.mMin.y * scale.y); + mMin.z = (float)(cpy.mMin.z * scale.z); + + mDiag.x = (float)(cpy.mDiag.x * scale.x); + mDiag.y = (float)(cpy.mDiag.y * scale.y); + mDiag.z = (float)(cpy.mDiag.z * scale.z); + } + public Vector3f Min + { + get + { + return new Vector3f(mMin.x, mMin.y, mMin.z); + } + } + public Vector3f Max + { + get + { + return new Vector3f(mMin.x + mDiag.x, mMin.y + mDiag.y, mMin.z + mDiag.z); + } + } + + public Vector3f Diag + { + get + { + return new Vector3f(mDiag.x, mDiag.y, mDiag.z); + } + } + + + public override string ToString() + { + return "[" + this.Min.ToString() + " - " + this.Max.ToString() + "]"; + } + public BoundingBox3f3f Merge(BoundingBox3f3f other) + { + Vector3f thisMax = Max; + Vector3f otherMax = other.Max; + bool xless = other.mMin.x > mMin.x; + bool yless = other.mMin.y > mMin.y; + bool zless = other.mMin.z > mMin.z; + + bool xmore = otherMax.x < thisMax.x; + bool ymore = otherMax.y < thisMax.y; + bool zmore = otherMax.z < thisMax.z; + return new BoundingBox3f3f(xless ? mMin.x : other.mMin.x, + yless ? mMin.y : other.mMin.y, + zless ? mMin.z : other.mMin.z, + xmore ? (xless ? mDiag.x : otherMax.x - mMin.x) : (xless ? thisMax.x - other.mMin.x : other.mDiag.x), + ymore ? (yless ? mDiag.y : otherMax.y - mMin.y) : (yless ? thisMax.y - other.mMin.y : other.mDiag.y), + zmore ? (zless ? mDiag.z : otherMax.z - mMin.z) : (zless ? thisMax.z - other.mMin.z : other.mDiag.z)); + } + + } // struct BoundingBox + + public struct BoundingBox3d3f + { + Vector3d mMin; + Vector3f mDiag; + public BoundingBox3d3f(double minx, double miny, double minz, float diagx, float diagy, float diagz) + { + mMin.x = minx; + mMin.y = miny; + mMin.z = minz; + + mDiag.x = diagx; + mDiag.y = diagy; + mDiag.z = diagz; + } + public BoundingBox3d3f(Vector3d min, Vector3f max) + { + mMin = min; + + mDiag = new Vector3f((float)(max.x - min.x), + (float)(max.y - min.y), + (float)(max.z - min.z)); + } + public BoundingBox3d3f(BoundingBox3d3f cpy, Vector3d scale) + { + mMin.x = (double)(cpy.mMin.x * scale.x); + mMin.y = (double)(cpy.mMin.y * scale.y); + mMin.z = (double)(cpy.mMin.z * scale.z); + + mDiag.x = (float)(cpy.mDiag.x * scale.x); + mDiag.y = (float)(cpy.mDiag.y * scale.y); + mDiag.z = (float)(cpy.mDiag.z * scale.z); + } + public Vector3d Min + { + get + { + return new Vector3d(mMin.x, mMin.y, mMin.z); + } + } + public Vector3d Max + { + get + { + return new Vector3d(mMin.x + mDiag.x, mMin.y + mDiag.y, mMin.z + mDiag.z); + } + } + + public Vector3d Diag + { + get + { + return new Vector3d(mDiag.x, mDiag.y, mDiag.z); + } + } + + + public override string ToString() + { + return "[" + this.Min.ToString() + " - " + this.Max.ToString() + "]"; + } + public BoundingBox3d3f Merge(BoundingBox3d3f other) + { + Vector3d thisMax = Max; + Vector3d otherMax = other.Max; + bool xless = other.mMin.x > mMin.x; + bool yless = other.mMin.y > mMin.y; + bool zless = other.mMin.z > mMin.z; + + bool xmore = otherMax.x < thisMax.x; + bool ymore = otherMax.y < thisMax.y; + bool zmore = otherMax.z < thisMax.z; + return new BoundingBox3d3f(xless ? mMin.x : other.mMin.x, + yless ? mMin.y : other.mMin.y, + zless ? mMin.z : other.mMin.z, + (float)(xmore ? (xless ? mDiag.x : otherMax.x - mMin.x) : (xless ? thisMax.x - other.mMin.x : other.mDiag.x)), + (float)(ymore ? (yless ? mDiag.y : otherMax.y - mMin.y) : (yless ? thisMax.y - other.mMin.y : other.mDiag.y)), + (float)(zmore ? (zless ? mDiag.z : otherMax.z - mMin.z) : (zless ? thisMax.z - other.mMin.z : other.mDiag.z))); + } + + } // struct BoundingBox + + + + + public struct BoundingSphere3f + { + Vector3f mCenter; + float mRadius; + public BoundingSphere3f(float x, float y, float z, float r) + { + mCenter = new Vector3f(x, y, z); + mRadius = r; + } + public BoundingSphere3f(Vector3f center, float radius) + { + mCenter = center; + mRadius = radius; + } + public BoundingSphere3f(BoundingSphere3f cpy, float scale) + { + mCenter = cpy.mCenter; + mRadius = cpy.mRadius * scale; + } + public Vector3f Center + { + get + { + return new Vector3f(mCenter.x, mCenter.y, mCenter.z); + } + } + public float Radius + { + get + { + return mRadius; + } + } + + public override string ToString() + { + return "[" + this.Center.ToString() + " : " + this.Radius.ToString() + "]"; + } + } // struct BoundingSphere3f + + + + public struct BoundingSphere3d + { + Vector3d mCenter; + float mRadius; + public BoundingSphere3d(double x, double y, double z, float r) + { + mCenter.x = x; + mCenter.y = y; + mCenter.z = z; + mRadius = r; + } + public BoundingSphere3d(Vector3d center, float radius) + { + mCenter = center; + mRadius = radius; + } + public BoundingSphere3d(BoundingSphere3d cpy, float scale) + { + mCenter = cpy.mCenter; + mRadius = cpy.mRadius * scale; + } + public Vector3d Center + { + get + { + return new Vector3d(mCenter.x, mCenter.y, mCenter.z); + } + } + public float Radius + { + get + { + return mRadius; + } + } + + public override string ToString() + { + return "[" + this.Center.ToString() + " : " + this.Radius.ToString() + "]"; + } + } // struct BoundingSphere3f + + public struct UUID + { + ulong mLowOrderBytes; + ulong mHighOrderBytes; + + + static ulong SetUUIDlow(Google.ProtocolBuffers.ByteString data, int offset) + { + ulong LowOrderBytes = 0; + int shiftVal = 0; + for (int i = 0; i < 8; ++i) + { + ulong temp = data[i]; + LowOrderBytes |= (temp << shiftVal); + shiftVal += 8; + } + return LowOrderBytes; + } + static ulong SetUUIDhigh(Google.ProtocolBuffers.ByteString data) + { + return SetUUIDlow(data, 8); + } + static ulong SetUUIDlow(byte[] data, int offset) + { + ulong LowOrderBytes = 0; + int shiftVal = 0; + for (int i = 0; i < 8; ++i) + { + ulong temp = data[i]; + LowOrderBytes |= (temp << shiftVal); + shiftVal += 8; + } + return LowOrderBytes; + } + static ulong SetUUIDhigh(byte[] data) + { + return SetUUIDlow(data, 8); + } + public bool SetUUID(byte[] data) + { + if (data.Length == 16) + { + mLowOrderBytes = 0; + mHighOrderBytes = 0; + mLowOrderBytes = SetUUIDlow(data, 0); + mHighOrderBytes = SetUUIDlow(data, 8); + return true; + } + else + { + return false; + } + } + public byte[] GetUUID() + { + byte[] data = new byte[16]; + int shiftVal = 0; + for (int i = 0; i < 8; ++i) + { + ulong temp = 0xff; + temp = (mLowOrderBytes & (temp << shiftVal)); + temp = (temp >> shiftVal); + data[i] = (byte)temp; + shiftVal += 8; + } + shiftVal = 0; + for (int i = 8; i < 16; ++i) + { + ulong temp = 0xff; + temp = (mHighOrderBytes & (temp << shiftVal)); + temp = (temp >> shiftVal); + data[i] = (byte)temp; + shiftVal += 8; + } + return data; + } + + public static UUID Empty = new UUID(new byte[16]); + public UUID(byte[] data) + { + if (data.Length != 16) + { + throw new System.ArgumentException("UUIDs must be provided 16 bytes"); + } + mLowOrderBytes = SetUUIDlow(data, 0); + mHighOrderBytes = SetUUIDhigh(data); + } + public UUID(Google.ProtocolBuffers.ByteString data) + { + if (data.Length != 16) + { + throw new System.ArgumentException("UUIDs must be provided 16 bytes"); + } + mLowOrderBytes = SetUUIDlow(data, 0); + mHighOrderBytes = SetUUIDhigh(data); + } + + } + + + public struct SHA256 + { + ulong mLowOrderBytes; + ulong mLowMediumOrderBytes; + ulong mMediumHighOrderBytes; + ulong mHighOrderBytes; + + + static ulong SetLMH(Google.ProtocolBuffers.ByteString data, int offset) + { + ulong LowOrderBytes = 0; + int shiftVal = 0; + for (int i = 0; i < 8; ++i) + { + ulong temp = data[i]; + LowOrderBytes |= (temp << shiftVal); + shiftVal += 8; + } + return LowOrderBytes; + } + static ulong SetLow(Google.ProtocolBuffers.ByteString data) + { + return SetLMH(data, 0); + } + static ulong SetLowMedium(Google.ProtocolBuffers.ByteString data) + { + return SetLMH(data, 8); + } + static ulong SetMediumHigh(Google.ProtocolBuffers.ByteString data) + { + return SetLMH(data, 16); + } + static ulong SetHigh(Google.ProtocolBuffers.ByteString data) + { + return SetLMH(data, 24); + } + static ulong SetLMH(byte[] data, int offset) + { + ulong LowOrderBytes = 0; + int shiftVal = 0; + for (int i = 0; i < 8; ++i) + { + ulong temp = data[i]; + LowOrderBytes |= (temp << shiftVal); + shiftVal += 8; + } + return LowOrderBytes; + } + static ulong SetLow(byte[] data) + { + return SetLMH(data, 0); + } + static ulong SetLowMedium(byte[] data) + { + return SetLMH(data, 8); + } + static ulong SetMediumHigh(byte[] data) + { + return SetLMH(data, 16); + } + static ulong SetHigh(byte[] data) + { + return SetLMH(data, 24); + } + public bool SetSHA256(byte[] data) + { + if (data.Length == 32) + { + mLowOrderBytes = SetLow(data); + mLowMediumOrderBytes = SetLowMedium(data); + mMediumHighOrderBytes = SetMediumHigh(data); + mHighOrderBytes = SetHigh(data); + return true; + } + else + { + return false; + } + } + public byte[] GetBinaryData() + { + byte[] data = new byte[32]; + int shiftVal = 0; + for (int i = 0; i < 8; ++i) + { + ulong temp = 0xff; + temp = (mLowOrderBytes & (temp << shiftVal)); + temp = (temp >> shiftVal); + data[i] = (byte)temp; + shiftVal += 8; + } + shiftVal = 0; + for (int i = 8; i < 16; ++i) + { + ulong temp = 0xff; + temp = (mLowMediumOrderBytes & (temp << shiftVal)); + temp = (temp >> shiftVal); + data[i] = (byte)temp; + shiftVal += 8; + } + shiftVal = 0; + for (int i = 16; i < 24; ++i) + { + ulong temp = 0xff; + temp = (mMediumHighOrderBytes & (temp << shiftVal)); + temp = (temp >> shiftVal); + data[i] = (byte)temp; + shiftVal += 8; + } + shiftVal = 0; + for (int i = 24; i < 32; ++i) + { + ulong temp = 0xff; + temp = (mHighOrderBytes & (temp << shiftVal)); + temp = (temp >> shiftVal); + data[i] = (byte)temp; + shiftVal += 8; + } + return data; + } + + public static SHA256 Empty = new SHA256(new byte[32]); + public SHA256(byte[] data) + { + if (data.Length != 32) + { + throw new System.ArgumentException("SHA256s must be provided 32 bytes"); + } + mLowOrderBytes = SetLow(data); + mLowMediumOrderBytes = SetLowMedium(data); + mMediumHighOrderBytes = SetMediumHigh(data); + mHighOrderBytes = SetHigh(data); + } + public SHA256(Google.ProtocolBuffers.ByteString data) + { + if (data.Length != 32) + { + throw new System.ArgumentException("SHA256s must be provided 32 bytes"); + } + mLowOrderBytes = SetLow(data); + mLowMediumOrderBytes = SetLowMedium(data); + mMediumHighOrderBytes = SetMediumHigh(data); + mHighOrderBytes = SetHigh(data); + } + + } + + + + + public struct Time + { + ulong usec; + public Time(ulong usec_since_epoch) + { + usec = usec_since_epoch; + } + public ulong toMicro() + { + return usec; + } + } + public class Duration + { + long usec; + public Duration(long time_since) + { + usec = time_since; + } + public long toMicro() + { + return usec; + } + } + + class _PBJ + { + + public static bool ValidateBool(bool d) + { + return true; + } + public static bool ValidateDouble(double d) + { + return true; + } + public static bool ValidateFloat(float d) + { + return true; + } + public static bool ValidateUint64(ulong d) + { + return true; + } + public static bool ValidateUint32(uint d) + { + return true; + } + public static bool ValidateUint16(ushort d) + { + return true; + } + public static bool ValidateUint8(byte d) + { + return true; + } + public static bool ValidateInt64(long d) + { + return true; + } + public static bool ValidateInt32(int d) + { + return true; + } + public static bool ValidateInt16(short d) + { + return true; + } + public static bool ValidateInt8(sbyte d) + { + return true; + } + public static bool ValidateString(S input) + { + return true; + } + public static bool ValidateBytes(B input) + { + return true; + } + public static bool ValidateUuid(Google.ProtocolBuffers.ByteString input) + { + return input.Length == 16; + } + public static bool ValidateSha256(Google.ProtocolBuffers.ByteString input) + { + return input.Length == 32; + } + public static bool ValidateAngle(float input) + { + return input >= 0 && input <= 3.1415926536 * 2.0; + } + public static bool ValidateTime(ulong input) + { + return true; + } + public static bool ValidateDuration(long input) + { + return true; + } + public static bool ValidateFlags(ulong input, ulong verification) + { + return (input & verification) == input; + } + + + + + public static bool CastBool(bool d) + { + return d; + } + public static double CastDouble(double d) + { + return d; + } + public static float CastFloat(float d) + { + return d; + } + public static ulong CastUint64(ulong d) + { + return d; + } + public static uint CastUint32(uint d) + { + return d; + } + public static ushort CastUint16(ushort d) + { + return d; + } + public static byte CastUint8(byte d) + { + return d; + } + public static long CastInt64(long d) + { + return d; + } + public static int CastInt32(int d) + { + return d; + } + public static short CastInt16(short d) + { + return d; + } + public static sbyte CastInt8(sbyte d) + { + return d; + } + public static S CastString(S input) + { + return input; + } + public static B CastBytes(B input) + { + return input; + } + + + + public static bool CastBool() + { + return false; + } + public static double CastDouble() + { + return 0; + } + public static float CastFloat() + { + return 0; + } + public static ulong CastUint64() + { + return 0; + } + public static uint CastUint32() + { + return 0; + } + public static ushort CastUint16() + { + return 0; + } + public static byte CastUint8() + { + return 0; + } + public static long CastInt64() + { + return 0; + } + public static int CastInt32() + { + return 0; + } + public static short CastInt16() + { + return 0; + } + public static sbyte CastInt8() + { + return 0; + } + public static string CastString() + { + return ""; + } + public static Google.ProtocolBuffers.ByteString CastBytes() + { + return Google.ProtocolBuffers.ByteString.Empty; + } + + + public static ulong CastFlags(ulong data, ulong allFlagsOn) + { + return allFlagsOn & data; + } + public static ulong CastFlags(ulong allFlagsOn) + { + return 0; + } + + public static Vector3f CastNormal(float x, float y) + { + float neg = (x > 1.5f || y > 1.5f) ? -1.0f : 1.0f; + if (x > 1.5) + x -= 3; + if (y > 1.5) + y -= 3; + return new Vector3f(x, y, neg - neg * (float)Math.Sqrt(x * x + y * y)); + } + public static Vector3f CastNormal() + { + return new Vector3f(0, 1, 0); + } + + + public static Vector2f CastVector2f(float x, float y) + { + return new Vector2f(x, y); + } + public static Vector2f CastVector2f() + { + return new Vector2f(0, 0); + } + + public static Vector3f CastVector3f(float x, float y, float z) + { + return new Vector3f(x, y, z); + } + public static Vector3f CastVector3f() + { + return new Vector3f(0, 0, 0); + } + + public static Vector4f CastVector4f(float x, float y, float z, float w) + { + return new Vector4f(x, y, z, w); + } + public static Vector4f CastVector4f() + { + return new Vector4f(0, 0, 0, 0); + } + public static Vector2d CastVector2d(double x, double y) + { + return new Vector2d(x, y); + } + public static Vector2d CastVector2d() + { + return new Vector2d(0, 0); + } + + public static Vector3d CastVector3d(double x, double y, double z) + { + return new Vector3d(x, y, z); + } + public static Vector3d CastVector3d() + { + return new Vector3d(0, 0, 0); + } + + public static Vector4d CastVector4d(double x, double y, double z, double w) + { + return new Vector4d(x, y, z, w); + } + public static Vector4d CastVector4d() + { + return new Vector4d(0, 0, 0, 0); + } + + public static BoundingSphere3f CastBoundingsphere3f(float x, float y, float z, float r) + { + return new BoundingSphere3f(new Vector3f(x, y, z), r); + } + public static BoundingSphere3d CastBoundingsphere3d(double x, double y, double z, double r) + { + return new BoundingSphere3d(new Vector3d(x, y, z), (float)r); + } + + public static BoundingSphere3f CastBoundingsphere3f() + { + return new BoundingSphere3f(new Vector3f(0, 0, 0), 0); + } + public static BoundingSphere3d CastBoundingsphere3d() + { + return new BoundingSphere3d(new Vector3d(0, 0, 0), (float)0); + } + + + public static BoundingBox3f3f CastBoundingbox3f3f(float x, float y, float z, float dx, float dy, float dz) + { + return new BoundingBox3f3f(x, y, z, dx, dy, dz); + } + public static BoundingBox3d3f CastBoundingbox3d3f(double x, double y, double z, double dx, double dy, double dz) + { + return new BoundingBox3d3f(x, y, z, (float)dx, (float)dy, (float)dz); + } + + public static BoundingBox3f3f CastBoundingbox3f3f() + { + return new BoundingBox3f3f(new Vector3f(0, 0, 0), new Vector3f(0, 0, 0)); + } + public static BoundingBox3d3f CastBoundingbox3d3f() + { + return new BoundingBox3d3f(0, 0, 0, 0, 0, 0); + } + + + + public static Quaternion CastQuaternion(float x, float y, float z) + { + float neg = (x > 1.5 || y > 1.5 || z > 1.5) ? -1.0f : 1.0f; + if (x > 1.5) + x -= 3.0f; + if (y > 1.5) + y -= 3.0f; + if (z > 1.5) + z -= 3.0f; + return new Quaternion(neg - neg * (float)Math.Sqrt(x * x + y * y + z * z), x, y, z); + } + public static Quaternion CastQuaternion() + { + return new Quaternion(1, 0, 0, 0); + } + + public static UUID CastUuid(Google.ProtocolBuffers.ByteString input) + { + return new UUID(input); + } + public static SHA256 CastSha256(Google.ProtocolBuffers.ByteString input) + { + return new SHA256(input); + } + public static SHA256 CastSha256() + { + return SHA256.Empty; + } + public static UUID CastUuid() + { + return UUID.Empty; + } + + public static float CastAngle(float d) + { + return d; + } + public static float CastAngle() + { + return 0; + } + + public static Time CastTime(ulong t) + { + return new Time(t); + } + public static Time CastTime() + { + return new Time(0); + } + public static Duration CastDuration(long t) + { + return new Duration(t); + } + public static Duration CastDuration() + { + return new Duration(0); + } + + public static T Construct(T retval) + { + return retval; + } + public static long Construct(Duration d) + { + return d.toMicro(); + } + public static ulong Construct(Time t) + { + return t.toMicro(); + } + public static Google.ProtocolBuffers.ByteString Construct(UUID u) + { + byte[] data = u.GetUUID(); + Google.ProtocolBuffers.ByteString retval = Google.ProtocolBuffers.ByteString.CopyFrom(data, 0, 16); + return retval; + } + public static Google.ProtocolBuffers.ByteString Construct(SHA256 u) + { + byte[] data = u.GetBinaryData(); + Google.ProtocolBuffers.ByteString retval = Google.ProtocolBuffers.ByteString.CopyFrom(data, 0, 16); + return retval; + } + public static float[] ConstructNormal(Vector3f d) + { + return new float[] { d.x + (d.z < 0 ? 3.0f : 0.0f), d.y }; + } + public static float[] ConstructQuaternion(Quaternion d) + { + return new float[] { d.x + (d.w < 0 ? 3.0f : 0.0f), d.y, d.z }; + } + + public static float[] ConstructVector2f(Vector2f d) + { + return new float[] { d.x, d.y }; + } + public static double[] ConstructVector2d(Vector2d d) + { + return new double[] { d.x, d.y }; + } + + public static float[] ConstructVector3f(Vector3f d) + { + return new float[] { d.x, d.y, d.z }; + } + public static double[] ConstructVector3d(Vector3d d) + { + return new double[] { d.x, d.y, d.z }; + } + public static float[] ConstructVector4f(Vector4f d) + { + return new float[] { d.x, d.y, d.z, d.w }; + } + public static double[] ConstructVector4d(Vector4d d) + { + return new double[] { d.x, d.y, d.z, d.w }; + } + + + public static float[] ConstructBoundingsphere3f(BoundingSphere3f d) + { + return new float[] { d.Center.x, d.Center.y, d.Center.z, d.Radius }; + } + public static double[] ConstructBoundingsphere3d(BoundingSphere3d d) + { + return new double[] { d.Center.x, d.Center.y, d.Center.z, d.Radius }; + } + + public static float[] ConstructBoundingbox3f3f(BoundingBox3f3f d) + { + return new float[] { d.Min.x, d.Min.y, d.Min.z, d.Diag.x, d.Diag.y, d.Diag.z }; + } + public static double[] ConstructBoundingbox3d3f(BoundingBox3d3f d) + { + return new double[] { d.Min.x, d.Min.y, d.Min.z, d.Diag.x, d.Diag.y, d.Diag.z }; + } + + + } + +} diff --git a/OpenSim/Client/Sirikata/Protocol/Persistence.cs b/OpenSim/Client/Sirikata/Protocol/Persistence.cs new file mode 100644 index 0000000..d8f8d33 --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Persistence.cs @@ -0,0 +1,3299 @@ +// 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.Persistence.Protocol._PBJ_Internal { + + public static partial class Persistence { + + #region Extension registration + public static void RegisterAllExtensions(pb::ExtensionRegistry registry) { + } + #endregion + #region Static variables + internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__FieldAccessorTable; + #endregion + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbd::FileDescriptor descriptor; + + static Persistence() { + byte[] descriptorData = global::System.Convert.FromBase64String( + "ChFQZXJzaXN0ZW5jZS5wcm90bxIrU2lyaWthdGEuUGVyc2lzdGVuY2UuUHJv" + + "dG9jb2wuX1BCSl9JbnRlcm5hbCJHCgpTdG9yYWdlS2V5EhMKC29iamVjdF91" + + "dWlkGAkgASgMEhAKCGZpZWxkX2lkGAogASgEEhIKCmZpZWxkX25hbWUYCyAB" + + "KAkiHAoMU3RvcmFnZVZhbHVlEgwKBGRhdGEYDCABKAwi/gEKDlN0b3JhZ2VF" + + "bGVtZW50EhMKC29iamVjdF91dWlkGAkgASgMEhAKCGZpZWxkX2lkGAogASgE" + + "EhIKCmZpZWxkX25hbWUYCyABKAkSDAoEZGF0YRgMIAEoDBINCgVpbmRleBgN" + + "IAEoBRJfCg1yZXR1cm5fc3RhdHVzGA8gASgOMkguU2lyaWthdGEuUGVyc2lz" + + "dGVuY2UuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5TdG9yYWdlRWxlbWVudC5S" + + "ZXR1cm5TdGF0dXMiMwoMUmV0dXJuU3RhdHVzEg8KC0tFWV9NSVNTSU5HEAQS" + + "EgoOSU5URVJOQUxfRVJST1IQBiLaAQoOQ29tcGFyZUVsZW1lbnQSEwoLb2Jq" + + "ZWN0X3V1aWQYCSABKAwSEAoIZmllbGRfaWQYCiABKAQSEgoKZmllbGRfbmFt" + + "ZRgLIAEoCRIMCgRkYXRhGAwgASgMEloKCmNvbXBhcmF0b3IYDiABKA4yRi5T" + + "aXJpa2F0YS5QZXJzaXN0ZW5jZS5Qcm90b2NvbC5fUEJKX0ludGVybmFsLkNv" + + "bXBhcmVFbGVtZW50LkNPTVBBUkFUT1IiIwoKQ09NUEFSQVRPUhIJCgVFUVVB" + + "TBAAEgoKBk5FUVVBTBABIlgKClN0b3JhZ2VTZXQSSgoFcmVhZHMYCSADKAsy" + + "Oy5TaXJpa2F0YS5QZXJzaXN0ZW5jZS5Qcm90b2NvbC5fUEJKX0ludGVybmFs" + + "LlN0b3JhZ2VFbGVtZW50IlUKB1JlYWRTZXQSSgoFcmVhZHMYCSADKAsyOy5T" + + "aXJpa2F0YS5QZXJzaXN0ZW5jZS5Qcm90b2NvbC5fUEJKX0ludGVybmFsLlN0" + + "b3JhZ2VFbGVtZW50IlcKCFdyaXRlU2V0EksKBndyaXRlcxgKIAMoCzI7LlNp" + + "cmlrYXRhLlBlcnNpc3RlbmNlLlByb3RvY29sLl9QQkpfSW50ZXJuYWwuU3Rv" + + "cmFnZUVsZW1lbnQi5gEKDFJlYWRXcml0ZVNldBJKCgVyZWFkcxgJIAMoCzI7" + + "LlNpcmlrYXRhLlBlcnNpc3RlbmNlLlByb3RvY29sLl9QQkpfSW50ZXJuYWwu" + + "U3RvcmFnZUVsZW1lbnQSSwoGd3JpdGVzGAogAygLMjsuU2lyaWthdGEuUGVy" + + "c2lzdGVuY2UuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5TdG9yYWdlRWxlbWVu" + + "dBIPCgdvcHRpb25zGA4gASgEIiwKE1JlYWRXcml0ZVNldE9wdGlvbnMSFQoR" + + "UkVUVVJOX1JFQURfTkFNRVMQASK3AgoPTWluaXRyYW5zYWN0aW9uEkoKBXJl" + + "YWRzGAkgAygLMjsuU2lyaWthdGEuUGVyc2lzdGVuY2UuUHJvdG9jb2wuX1BC" + + "Sl9JbnRlcm5hbC5TdG9yYWdlRWxlbWVudBJLCgZ3cml0ZXMYCiADKAsyOy5T" + + "aXJpa2F0YS5QZXJzaXN0ZW5jZS5Qcm90b2NvbC5fUEJKX0ludGVybmFsLlN0" + + "b3JhZ2VFbGVtZW50Ek0KCGNvbXBhcmVzGAsgAygLMjsuU2lyaWthdGEuUGVy" + + "c2lzdGVuY2UuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5Db21wYXJlRWxlbWVu" + + "dBIPCgdvcHRpb25zGA4gASgEIisKElRyYW5zYWN0aW9uT3B0aW9ucxIVChFS" + + "RVRVUk5fUkVBRF9OQU1FUxABIp8CCghSZXNwb25zZRJKCgVyZWFkcxgJIAMo" + + "CzI7LlNpcmlrYXRhLlBlcnNpc3RlbmNlLlByb3RvY29sLl9QQkpfSW50ZXJu" + + "YWwuU3RvcmFnZUVsZW1lbnQSWQoNcmV0dXJuX3N0YXR1cxgPIAEoDjJCLlNp" + + "cmlrYXRhLlBlcnNpc3RlbmNlLlByb3RvY29sLl9QQkpfSW50ZXJuYWwuUmVz" + + "cG9uc2UuUmV0dXJuU3RhdHVzImwKDFJldHVyblN0YXR1cxILCgdTVUNDRVNT" + + "EAASEwoPREFUQUJBU0VfTE9DS0VEEAMSDwoLS0VZX01JU1NJTkcQBBIVChFD" + + "T01QQVJJU09OX0ZBSUxFRBAFEhIKDklOVEVSTkFMX0VSUk9SEAY="); + pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { + descriptor = root; + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__Descriptor = Descriptor.MessageTypes[0]; + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__Descriptor, + new string[] { "ObjectUuid", "FieldId", "FieldName", }); + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__Descriptor = Descriptor.MessageTypes[1]; + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__Descriptor, + new string[] { "Data", }); + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__Descriptor = Descriptor.MessageTypes[2]; + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__Descriptor, + new string[] { "ObjectUuid", "FieldId", "FieldName", "Data", "Index", "ReturnStatus", }); + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__Descriptor = Descriptor.MessageTypes[3]; + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__Descriptor, + new string[] { "ObjectUuid", "FieldId", "FieldName", "Data", "Comparator", }); + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__Descriptor = Descriptor.MessageTypes[4]; + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__Descriptor, + new string[] { "Reads", }); + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__Descriptor = Descriptor.MessageTypes[5]; + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__Descriptor, + new string[] { "Reads", }); + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__Descriptor = Descriptor.MessageTypes[6]; + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__Descriptor, + new string[] { "Writes", }); + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__Descriptor = Descriptor.MessageTypes[7]; + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__Descriptor, + new string[] { "Reads", "Writes", "Options", }); + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__Descriptor = Descriptor.MessageTypes[8]; + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__Descriptor, + new string[] { "Reads", "Writes", "Compares", "Options", }); + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__Descriptor = Descriptor.MessageTypes[9]; + internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__Descriptor, + new string[] { "Reads", "ReturnStatus", }); + return null; + }; + pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, + new pbd::FileDescriptor[] { + }, assigner); + } + #endregion + + } + #region Messages + public sealed partial class StorageKey : pb::GeneratedMessage { + private static readonly StorageKey defaultInstance = new Builder().BuildPartial(); + public static StorageKey DefaultInstance { + get { return defaultInstance; } + } + + public override StorageKey DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override StorageKey ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__FieldAccessorTable; } + } + + public const int ObjectUuidFieldNumber = 9; + private bool hasObjectUuid; + private pb::ByteString objectUuid_ = pb::ByteString.Empty; + public bool HasObjectUuid { + get { return hasObjectUuid; } + } + public pb::ByteString ObjectUuid { + get { return objectUuid_; } + } + + public const int FieldIdFieldNumber = 10; + private bool hasFieldId; + private ulong fieldId_ = 0UL; + public bool HasFieldId { + get { return hasFieldId; } + } + [global::System.CLSCompliant(false)] + public ulong FieldId { + get { return fieldId_; } + } + + public const int FieldNameFieldNumber = 11; + private bool hasFieldName; + private string fieldName_ = ""; + public bool HasFieldName { + get { return hasFieldName; } + } + public string FieldName { + get { return fieldName_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasObjectUuid) { + output.WriteBytes(9, ObjectUuid); + } + if (HasFieldId) { + output.WriteUInt64(10, FieldId); + } + if (HasFieldName) { + output.WriteString(11, FieldName); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasObjectUuid) { + size += pb::CodedOutputStream.ComputeBytesSize(9, ObjectUuid); + } + if (HasFieldId) { + size += pb::CodedOutputStream.ComputeUInt64Size(10, FieldId); + } + if (HasFieldName) { + size += pb::CodedOutputStream.ComputeStringSize(11, FieldName); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static StorageKey ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StorageKey ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StorageKey ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StorageKey ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StorageKey ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StorageKey ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static StorageKey ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static StorageKey ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static StorageKey ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StorageKey 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(StorageKey prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + StorageKey result = new StorageKey(); + + protected override StorageKey MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new StorageKey(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageKey.Descriptor; } + } + + public override StorageKey DefaultInstanceForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageKey.DefaultInstance; } + } + + public override StorageKey BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + StorageKey returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is StorageKey) { + return MergeFrom((StorageKey) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(StorageKey other) { + if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageKey.DefaultInstance) return this; + if (other.HasObjectUuid) { + ObjectUuid = other.ObjectUuid; + } + if (other.HasFieldId) { + FieldId = other.FieldId; + } + if (other.HasFieldName) { + FieldName = other.FieldName; + } + 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 74: { + ObjectUuid = input.ReadBytes(); + break; + } + case 80: { + FieldId = input.ReadUInt64(); + break; + } + case 90: { + FieldName = input.ReadString(); + break; + } + } + } + } + + + public bool HasObjectUuid { + get { return result.HasObjectUuid; } + } + public pb::ByteString ObjectUuid { + get { return result.ObjectUuid; } + set { SetObjectUuid(value); } + } + public Builder SetObjectUuid(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectUuid = true; + result.objectUuid_ = value; + return this; + } + public Builder ClearObjectUuid() { + result.hasObjectUuid = false; + result.objectUuid_ = pb::ByteString.Empty; + return this; + } + + public bool HasFieldId { + get { return result.HasFieldId; } + } + [global::System.CLSCompliant(false)] + public ulong FieldId { + get { return result.FieldId; } + set { SetFieldId(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetFieldId(ulong value) { + result.hasFieldId = true; + result.fieldId_ = value; + return this; + } + public Builder ClearFieldId() { + result.hasFieldId = false; + result.fieldId_ = 0UL; + return this; + } + + public bool HasFieldName { + get { return result.HasFieldName; } + } + public string FieldName { + get { return result.FieldName; } + set { SetFieldName(value); } + } + public Builder SetFieldName(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasFieldName = true; + result.fieldName_ = value; + return this; + } + public Builder ClearFieldName() { + result.hasFieldName = false; + result.fieldName_ = ""; + return this; + } + } + static StorageKey() { + object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); + } + } + + public sealed partial class StorageValue : pb::GeneratedMessage { + private static readonly StorageValue defaultInstance = new Builder().BuildPartial(); + public static StorageValue DefaultInstance { + get { return defaultInstance; } + } + + public override StorageValue DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override StorageValue ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__FieldAccessorTable; } + } + + public const int DataFieldNumber = 12; + private bool hasData; + private pb::ByteString data_ = pb::ByteString.Empty; + public bool HasData { + get { return hasData; } + } + public pb::ByteString Data { + get { return data_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasData) { + output.WriteBytes(12, Data); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasData) { + size += pb::CodedOutputStream.ComputeBytesSize(12, Data); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static StorageValue ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StorageValue ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StorageValue ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StorageValue ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StorageValue ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StorageValue ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static StorageValue ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static StorageValue ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static StorageValue ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StorageValue 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(StorageValue prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + StorageValue result = new StorageValue(); + + protected override StorageValue MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new StorageValue(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageValue.Descriptor; } + } + + public override StorageValue DefaultInstanceForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageValue.DefaultInstance; } + } + + public override StorageValue BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + StorageValue returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is StorageValue) { + return MergeFrom((StorageValue) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(StorageValue other) { + if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageValue.DefaultInstance) return this; + if (other.HasData) { + Data = other.Data; + } + 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 98: { + Data = input.ReadBytes(); + break; + } + } + } + } + + + public bool HasData { + get { return result.HasData; } + } + public pb::ByteString Data { + get { return result.Data; } + set { SetData(value); } + } + public Builder SetData(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasData = true; + result.data_ = value; + return this; + } + public Builder ClearData() { + result.hasData = false; + result.data_ = pb::ByteString.Empty; + return this; + } + } + static StorageValue() { + object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); + } + } + + public sealed partial class StorageElement : pb::GeneratedMessage { + private static readonly StorageElement defaultInstance = new Builder().BuildPartial(); + public static StorageElement DefaultInstance { + get { return defaultInstance; } + } + + public override StorageElement DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override StorageElement ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum ReturnStatus { + KEY_MISSING = 4, + INTERNAL_ERROR = 6, + } + + } + #endregion + + public const int ObjectUuidFieldNumber = 9; + private bool hasObjectUuid; + private pb::ByteString objectUuid_ = pb::ByteString.Empty; + public bool HasObjectUuid { + get { return hasObjectUuid; } + } + public pb::ByteString ObjectUuid { + get { return objectUuid_; } + } + + public const int FieldIdFieldNumber = 10; + private bool hasFieldId; + private ulong fieldId_ = 0UL; + public bool HasFieldId { + get { return hasFieldId; } + } + [global::System.CLSCompliant(false)] + public ulong FieldId { + get { return fieldId_; } + } + + public const int FieldNameFieldNumber = 11; + private bool hasFieldName; + private string fieldName_ = ""; + public bool HasFieldName { + get { return hasFieldName; } + } + public string FieldName { + get { return fieldName_; } + } + + public const int DataFieldNumber = 12; + private bool hasData; + private pb::ByteString data_ = pb::ByteString.Empty; + public bool HasData { + get { return hasData; } + } + public pb::ByteString Data { + get { return data_; } + } + + public const int IndexFieldNumber = 13; + private bool hasIndex; + private int index_ = 0; + public bool HasIndex { + get { return hasIndex; } + } + public int Index { + get { return index_; } + } + + public const int ReturnStatusFieldNumber = 15; + private bool hasReturnStatus; + private global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus returnStatus_ = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus.KEY_MISSING; + public bool HasReturnStatus { + get { return hasReturnStatus; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus ReturnStatus { + get { return returnStatus_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasObjectUuid) { + output.WriteBytes(9, ObjectUuid); + } + if (HasFieldId) { + output.WriteUInt64(10, FieldId); + } + if (HasFieldName) { + output.WriteString(11, FieldName); + } + if (HasData) { + output.WriteBytes(12, Data); + } + if (HasIndex) { + output.WriteInt32(13, Index); + } + if (HasReturnStatus) { + output.WriteEnum(15, (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 (HasObjectUuid) { + size += pb::CodedOutputStream.ComputeBytesSize(9, ObjectUuid); + } + if (HasFieldId) { + size += pb::CodedOutputStream.ComputeUInt64Size(10, FieldId); + } + if (HasFieldName) { + size += pb::CodedOutputStream.ComputeStringSize(11, FieldName); + } + if (HasData) { + size += pb::CodedOutputStream.ComputeBytesSize(12, Data); + } + if (HasIndex) { + size += pb::CodedOutputStream.ComputeInt32Size(13, Index); + } + if (HasReturnStatus) { + size += pb::CodedOutputStream.ComputeEnumSize(15, (int) ReturnStatus); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static StorageElement ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StorageElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StorageElement ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StorageElement ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StorageElement ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StorageElement ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static StorageElement ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static StorageElement ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static StorageElement ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StorageElement 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(StorageElement prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + StorageElement result = new StorageElement(); + + protected override StorageElement MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new StorageElement(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Descriptor; } + } + + public override StorageElement DefaultInstanceForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.DefaultInstance; } + } + + public override StorageElement BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + StorageElement returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is StorageElement) { + return MergeFrom((StorageElement) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(StorageElement other) { + if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.DefaultInstance) return this; + if (other.HasObjectUuid) { + ObjectUuid = other.ObjectUuid; + } + if (other.HasFieldId) { + FieldId = other.FieldId; + } + if (other.HasFieldName) { + FieldName = other.FieldName; + } + if (other.HasData) { + Data = other.Data; + } + if (other.HasIndex) { + Index = other.Index; + } + 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 74: { + ObjectUuid = input.ReadBytes(); + break; + } + case 80: { + FieldId = input.ReadUInt64(); + break; + } + case 90: { + FieldName = input.ReadString(); + break; + } + case 98: { + Data = input.ReadBytes(); + break; + } + case 104: { + Index = input.ReadInt32(); + break; + } + case 120: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus), rawValue)) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(15, (ulong) rawValue); + } else { + ReturnStatus = (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus) rawValue; + } + break; + } + } + } + } + + + public bool HasObjectUuid { + get { return result.HasObjectUuid; } + } + public pb::ByteString ObjectUuid { + get { return result.ObjectUuid; } + set { SetObjectUuid(value); } + } + public Builder SetObjectUuid(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectUuid = true; + result.objectUuid_ = value; + return this; + } + public Builder ClearObjectUuid() { + result.hasObjectUuid = false; + result.objectUuid_ = pb::ByteString.Empty; + return this; + } + + public bool HasFieldId { + get { return result.HasFieldId; } + } + [global::System.CLSCompliant(false)] + public ulong FieldId { + get { return result.FieldId; } + set { SetFieldId(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetFieldId(ulong value) { + result.hasFieldId = true; + result.fieldId_ = value; + return this; + } + public Builder ClearFieldId() { + result.hasFieldId = false; + result.fieldId_ = 0UL; + return this; + } + + public bool HasFieldName { + get { return result.HasFieldName; } + } + public string FieldName { + get { return result.FieldName; } + set { SetFieldName(value); } + } + public Builder SetFieldName(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasFieldName = true; + result.fieldName_ = value; + return this; + } + public Builder ClearFieldName() { + result.hasFieldName = false; + result.fieldName_ = ""; + return this; + } + + public bool HasData { + get { return result.HasData; } + } + public pb::ByteString Data { + get { return result.Data; } + set { SetData(value); } + } + public Builder SetData(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasData = true; + result.data_ = value; + return this; + } + public Builder ClearData() { + result.hasData = false; + result.data_ = pb::ByteString.Empty; + return this; + } + + public bool HasIndex { + get { return result.HasIndex; } + } + public int Index { + get { return result.Index; } + set { SetIndex(value); } + } + public Builder SetIndex(int value) { + result.hasIndex = true; + result.index_ = value; + return this; + } + public Builder ClearIndex() { + result.hasIndex = false; + result.index_ = 0; + return this; + } + + public bool HasReturnStatus { + get { return result.HasReturnStatus; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus ReturnStatus { + get { return result.ReturnStatus; } + set { SetReturnStatus(value); } + } + public Builder SetReturnStatus(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus value) { + result.hasReturnStatus = true; + result.returnStatus_ = value; + return this; + } + public Builder ClearReturnStatus() { + result.hasReturnStatus = false; + result.returnStatus_ = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus.KEY_MISSING; + return this; + } + } + static StorageElement() { + object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); + } + } + + public sealed partial class CompareElement : pb::GeneratedMessage { + private static readonly CompareElement defaultInstance = new Builder().BuildPartial(); + public static CompareElement DefaultInstance { + get { return defaultInstance; } + } + + public override CompareElement DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CompareElement ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum COMPARATOR { + EQUAL = 0, + NEQUAL = 1, + } + + } + #endregion + + public const int ObjectUuidFieldNumber = 9; + private bool hasObjectUuid; + private pb::ByteString objectUuid_ = pb::ByteString.Empty; + public bool HasObjectUuid { + get { return hasObjectUuid; } + } + public pb::ByteString ObjectUuid { + get { return objectUuid_; } + } + + public const int FieldIdFieldNumber = 10; + private bool hasFieldId; + private ulong fieldId_ = 0UL; + public bool HasFieldId { + get { return hasFieldId; } + } + [global::System.CLSCompliant(false)] + public ulong FieldId { + get { return fieldId_; } + } + + public const int FieldNameFieldNumber = 11; + private bool hasFieldName; + private string fieldName_ = ""; + public bool HasFieldName { + get { return hasFieldName; } + } + public string FieldName { + get { return fieldName_; } + } + + public const int DataFieldNumber = 12; + private bool hasData; + private pb::ByteString data_ = pb::ByteString.Empty; + public bool HasData { + get { return hasData; } + } + public pb::ByteString Data { + get { return data_; } + } + + public const int ComparatorFieldNumber = 14; + private bool hasComparator; + private global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR comparator_ = global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR.EQUAL; + public bool HasComparator { + get { return hasComparator; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR Comparator { + get { return comparator_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasObjectUuid) { + output.WriteBytes(9, ObjectUuid); + } + if (HasFieldId) { + output.WriteUInt64(10, FieldId); + } + if (HasFieldName) { + output.WriteString(11, FieldName); + } + if (HasData) { + output.WriteBytes(12, Data); + } + if (HasComparator) { + output.WriteEnum(14, (int) Comparator); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasObjectUuid) { + size += pb::CodedOutputStream.ComputeBytesSize(9, ObjectUuid); + } + if (HasFieldId) { + size += pb::CodedOutputStream.ComputeUInt64Size(10, FieldId); + } + if (HasFieldName) { + size += pb::CodedOutputStream.ComputeStringSize(11, FieldName); + } + if (HasData) { + size += pb::CodedOutputStream.ComputeBytesSize(12, Data); + } + if (HasComparator) { + size += pb::CodedOutputStream.ComputeEnumSize(14, (int) Comparator); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static CompareElement ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CompareElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CompareElement ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CompareElement ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CompareElement ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CompareElement ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CompareElement ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static CompareElement ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static CompareElement ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CompareElement 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(CompareElement prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CompareElement result = new CompareElement(); + + protected override CompareElement MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CompareElement(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Descriptor; } + } + + public override CompareElement DefaultInstanceForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.DefaultInstance; } + } + + public override CompareElement BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + CompareElement returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is CompareElement) { + return MergeFrom((CompareElement) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(CompareElement other) { + if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.DefaultInstance) return this; + if (other.HasObjectUuid) { + ObjectUuid = other.ObjectUuid; + } + if (other.HasFieldId) { + FieldId = other.FieldId; + } + if (other.HasFieldName) { + FieldName = other.FieldName; + } + if (other.HasData) { + Data = other.Data; + } + if (other.HasComparator) { + Comparator = other.Comparator; + } + 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 74: { + ObjectUuid = input.ReadBytes(); + break; + } + case 80: { + FieldId = input.ReadUInt64(); + break; + } + case 90: { + FieldName = input.ReadString(); + break; + } + case 98: { + Data = input.ReadBytes(); + break; + } + case 112: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR), rawValue)) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(14, (ulong) rawValue); + } else { + Comparator = (global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR) rawValue; + } + break; + } + } + } + } + + + public bool HasObjectUuid { + get { return result.HasObjectUuid; } + } + public pb::ByteString ObjectUuid { + get { return result.ObjectUuid; } + set { SetObjectUuid(value); } + } + public Builder SetObjectUuid(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectUuid = true; + result.objectUuid_ = value; + return this; + } + public Builder ClearObjectUuid() { + result.hasObjectUuid = false; + result.objectUuid_ = pb::ByteString.Empty; + return this; + } + + public bool HasFieldId { + get { return result.HasFieldId; } + } + [global::System.CLSCompliant(false)] + public ulong FieldId { + get { return result.FieldId; } + set { SetFieldId(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetFieldId(ulong value) { + result.hasFieldId = true; + result.fieldId_ = value; + return this; + } + public Builder ClearFieldId() { + result.hasFieldId = false; + result.fieldId_ = 0UL; + return this; + } + + public bool HasFieldName { + get { return result.HasFieldName; } + } + public string FieldName { + get { return result.FieldName; } + set { SetFieldName(value); } + } + public Builder SetFieldName(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasFieldName = true; + result.fieldName_ = value; + return this; + } + public Builder ClearFieldName() { + result.hasFieldName = false; + result.fieldName_ = ""; + return this; + } + + public bool HasData { + get { return result.HasData; } + } + public pb::ByteString Data { + get { return result.Data; } + set { SetData(value); } + } + public Builder SetData(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasData = true; + result.data_ = value; + return this; + } + public Builder ClearData() { + result.hasData = false; + result.data_ = pb::ByteString.Empty; + return this; + } + + public bool HasComparator { + get { return result.HasComparator; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR Comparator { + get { return result.Comparator; } + set { SetComparator(value); } + } + public Builder SetComparator(global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR value) { + result.hasComparator = true; + result.comparator_ = value; + return this; + } + public Builder ClearComparator() { + result.hasComparator = false; + result.comparator_ = global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR.EQUAL; + return this; + } + } + static CompareElement() { + object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); + } + } + + public sealed partial class StorageSet : pb::GeneratedMessage { + private static readonly StorageSet defaultInstance = new Builder().BuildPartial(); + public static StorageSet DefaultInstance { + get { return defaultInstance; } + } + + public override StorageSet DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override StorageSet ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__FieldAccessorTable; } + } + + public const int ReadsFieldNumber = 9; + private pbc::PopsicleList reads_ = new pbc::PopsicleList(); + public scg::IList ReadsList { + get { return reads_; } + } + public int ReadsCount { + get { return reads_.Count; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { + return reads_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { + output.WriteMessage(9, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { + size += pb::CodedOutputStream.ComputeMessageSize(9, element); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static StorageSet ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StorageSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StorageSet ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StorageSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StorageSet ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StorageSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static StorageSet ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static StorageSet ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static StorageSet ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StorageSet 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(StorageSet prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + StorageSet result = new StorageSet(); + + protected override StorageSet MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new StorageSet(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageSet.Descriptor; } + } + + public override StorageSet DefaultInstanceForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageSet.DefaultInstance; } + } + + public override StorageSet BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.reads_.MakeReadOnly(); + StorageSet returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is StorageSet) { + return MergeFrom((StorageSet) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(StorageSet other) { + if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageSet.DefaultInstance) return this; + if (other.reads_.Count != 0) { + base.AddRange(other.reads_, result.reads_); + } + 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 74: { + global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddReads(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public pbc::IPopsicleList ReadsList { + get { return result.reads_; } + } + public int ReadsCount { + get { return result.ReadsCount; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { + return result.GetReads(index); + } + public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.reads_[index] = value; + return this; + } + public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.reads_[index] = builderForValue.Build(); + return this; + } + public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.reads_.Add(value); + return this; + } + public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.reads_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeReads(scg::IEnumerable values) { + base.AddRange(values, result.reads_); + return this; + } + public Builder ClearReads() { + result.reads_.Clear(); + return this; + } + } + static StorageSet() { + object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); + } + } + + public sealed partial class ReadSet : pb::GeneratedMessage { + private static readonly ReadSet defaultInstance = new Builder().BuildPartial(); + public static ReadSet DefaultInstance { + get { return defaultInstance; } + } + + public override ReadSet DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ReadSet ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__FieldAccessorTable; } + } + + public const int ReadsFieldNumber = 9; + private pbc::PopsicleList reads_ = new pbc::PopsicleList(); + public scg::IList ReadsList { + get { return reads_; } + } + public int ReadsCount { + get { return reads_.Count; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { + return reads_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { + output.WriteMessage(9, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { + size += pb::CodedOutputStream.ComputeMessageSize(9, element); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ReadSet ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ReadSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ReadSet ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ReadSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ReadSet ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ReadSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ReadSet ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ReadSet ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ReadSet ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ReadSet 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(ReadSet prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ReadSet result = new ReadSet(); + + protected override ReadSet MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ReadSet(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadSet.Descriptor; } + } + + public override ReadSet DefaultInstanceForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadSet.DefaultInstance; } + } + + public override ReadSet BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.reads_.MakeReadOnly(); + ReadSet returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ReadSet) { + return MergeFrom((ReadSet) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ReadSet other) { + if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadSet.DefaultInstance) return this; + if (other.reads_.Count != 0) { + base.AddRange(other.reads_, result.reads_); + } + 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 74: { + global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddReads(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public pbc::IPopsicleList ReadsList { + get { return result.reads_; } + } + public int ReadsCount { + get { return result.ReadsCount; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { + return result.GetReads(index); + } + public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.reads_[index] = value; + return this; + } + public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.reads_[index] = builderForValue.Build(); + return this; + } + public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.reads_.Add(value); + return this; + } + public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.reads_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeReads(scg::IEnumerable values) { + base.AddRange(values, result.reads_); + return this; + } + public Builder ClearReads() { + result.reads_.Clear(); + return this; + } + } + static ReadSet() { + object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); + } + } + + public sealed partial class WriteSet : pb::GeneratedMessage { + private static readonly WriteSet defaultInstance = new Builder().BuildPartial(); + public static WriteSet DefaultInstance { + get { return defaultInstance; } + } + + public override WriteSet DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override WriteSet ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__FieldAccessorTable; } + } + + public const int WritesFieldNumber = 10; + private pbc::PopsicleList writes_ = new pbc::PopsicleList(); + public scg::IList WritesList { + get { return writes_; } + } + public int WritesCount { + get { return writes_.Count; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetWrites(int index) { + return writes_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in WritesList) { + output.WriteMessage(10, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in WritesList) { + size += pb::CodedOutputStream.ComputeMessageSize(10, element); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static WriteSet ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static WriteSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static WriteSet ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static WriteSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static WriteSet ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static WriteSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static WriteSet ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static WriteSet ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static WriteSet ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static WriteSet 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(WriteSet prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + WriteSet result = new WriteSet(); + + protected override WriteSet MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new WriteSet(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.WriteSet.Descriptor; } + } + + public override WriteSet DefaultInstanceForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.WriteSet.DefaultInstance; } + } + + public override WriteSet BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.writes_.MakeReadOnly(); + WriteSet returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is WriteSet) { + return MergeFrom((WriteSet) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(WriteSet other) { + if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.WriteSet.DefaultInstance) return this; + if (other.writes_.Count != 0) { + base.AddRange(other.writes_, result.writes_); + } + 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 82: { + global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddWrites(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public pbc::IPopsicleList WritesList { + get { return result.writes_; } + } + public int WritesCount { + get { return result.WritesCount; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetWrites(int index) { + return result.GetWrites(index); + } + public Builder SetWrites(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.writes_[index] = value; + return this; + } + public Builder SetWrites(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.writes_[index] = builderForValue.Build(); + return this; + } + public Builder AddWrites(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.writes_.Add(value); + return this; + } + public Builder AddWrites(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.writes_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeWrites(scg::IEnumerable values) { + base.AddRange(values, result.writes_); + return this; + } + public Builder ClearWrites() { + result.writes_.Clear(); + return this; + } + } + static WriteSet() { + object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); + } + } + + public sealed partial class ReadWriteSet : pb::GeneratedMessage { + private static readonly ReadWriteSet defaultInstance = new Builder().BuildPartial(); + public static ReadWriteSet DefaultInstance { + get { return defaultInstance; } + } + + public override ReadWriteSet DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ReadWriteSet ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum ReadWriteSetOptions { + RETURN_READ_NAMES = 1, + } + + } + #endregion + + public const int ReadsFieldNumber = 9; + private pbc::PopsicleList reads_ = new pbc::PopsicleList(); + public scg::IList ReadsList { + get { return reads_; } + } + public int ReadsCount { + get { return reads_.Count; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { + return reads_[index]; + } + + public const int WritesFieldNumber = 10; + private pbc::PopsicleList writes_ = new pbc::PopsicleList(); + public scg::IList WritesList { + get { return writes_; } + } + public int WritesCount { + get { return writes_.Count; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetWrites(int index) { + return writes_[index]; + } + + public const int OptionsFieldNumber = 14; + private bool hasOptions; + private ulong options_ = 0UL; + public bool HasOptions { + get { return hasOptions; } + } + [global::System.CLSCompliant(false)] + public ulong Options { + get { return options_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { + output.WriteMessage(9, element); + } + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in WritesList) { + output.WriteMessage(10, element); + } + if (HasOptions) { + output.WriteUInt64(14, Options); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { + size += pb::CodedOutputStream.ComputeMessageSize(9, element); + } + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in WritesList) { + size += pb::CodedOutputStream.ComputeMessageSize(10, element); + } + if (HasOptions) { + size += pb::CodedOutputStream.ComputeUInt64Size(14, Options); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ReadWriteSet ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ReadWriteSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ReadWriteSet ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ReadWriteSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ReadWriteSet ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ReadWriteSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ReadWriteSet ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ReadWriteSet ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ReadWriteSet ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ReadWriteSet 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(ReadWriteSet prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ReadWriteSet result = new ReadWriteSet(); + + protected override ReadWriteSet MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ReadWriteSet(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadWriteSet.Descriptor; } + } + + public override ReadWriteSet DefaultInstanceForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadWriteSet.DefaultInstance; } + } + + public override ReadWriteSet BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.reads_.MakeReadOnly(); + result.writes_.MakeReadOnly(); + ReadWriteSet returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ReadWriteSet) { + return MergeFrom((ReadWriteSet) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ReadWriteSet other) { + if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadWriteSet.DefaultInstance) return this; + if (other.reads_.Count != 0) { + base.AddRange(other.reads_, result.reads_); + } + if (other.writes_.Count != 0) { + base.AddRange(other.writes_, result.writes_); + } + if (other.HasOptions) { + Options = other.Options; + } + 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 74: { + global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddReads(subBuilder.BuildPartial()); + break; + } + case 82: { + global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddWrites(subBuilder.BuildPartial()); + break; + } + case 112: { + Options = input.ReadUInt64(); + break; + } + } + } + } + + + public pbc::IPopsicleList ReadsList { + get { return result.reads_; } + } + public int ReadsCount { + get { return result.ReadsCount; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { + return result.GetReads(index); + } + public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.reads_[index] = value; + return this; + } + public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.reads_[index] = builderForValue.Build(); + return this; + } + public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.reads_.Add(value); + return this; + } + public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.reads_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeReads(scg::IEnumerable values) { + base.AddRange(values, result.reads_); + return this; + } + public Builder ClearReads() { + result.reads_.Clear(); + return this; + } + + public pbc::IPopsicleList WritesList { + get { return result.writes_; } + } + public int WritesCount { + get { return result.WritesCount; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetWrites(int index) { + return result.GetWrites(index); + } + public Builder SetWrites(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.writes_[index] = value; + return this; + } + public Builder SetWrites(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.writes_[index] = builderForValue.Build(); + return this; + } + public Builder AddWrites(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.writes_.Add(value); + return this; + } + public Builder AddWrites(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.writes_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeWrites(scg::IEnumerable values) { + base.AddRange(values, result.writes_); + return this; + } + public Builder ClearWrites() { + result.writes_.Clear(); + return this; + } + + public bool HasOptions { + get { return result.HasOptions; } + } + [global::System.CLSCompliant(false)] + public ulong Options { + get { return result.Options; } + set { SetOptions(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetOptions(ulong value) { + result.hasOptions = true; + result.options_ = value; + return this; + } + public Builder ClearOptions() { + result.hasOptions = false; + result.options_ = 0UL; + return this; + } + } + static ReadWriteSet() { + object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); + } + } + + public sealed partial class Minitransaction : pb::GeneratedMessage { + private static readonly Minitransaction defaultInstance = new Builder().BuildPartial(); + public static Minitransaction DefaultInstance { + get { return defaultInstance; } + } + + public override Minitransaction DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Minitransaction ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum TransactionOptions { + RETURN_READ_NAMES = 1, + } + + } + #endregion + + public const int ReadsFieldNumber = 9; + private pbc::PopsicleList reads_ = new pbc::PopsicleList(); + public scg::IList ReadsList { + get { return reads_; } + } + public int ReadsCount { + get { return reads_.Count; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { + return reads_[index]; + } + + public const int WritesFieldNumber = 10; + private pbc::PopsicleList writes_ = new pbc::PopsicleList(); + public scg::IList WritesList { + get { return writes_; } + } + public int WritesCount { + get { return writes_.Count; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetWrites(int index) { + return writes_[index]; + } + + public const int ComparesFieldNumber = 11; + private pbc::PopsicleList compares_ = new pbc::PopsicleList(); + public scg::IList ComparesList { + get { return compares_; } + } + public int ComparesCount { + get { return compares_.Count; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement GetCompares(int index) { + return compares_[index]; + } + + public const int OptionsFieldNumber = 14; + private bool hasOptions; + private ulong options_ = 0UL; + public bool HasOptions { + get { return hasOptions; } + } + [global::System.CLSCompliant(false)] + public ulong Options { + get { return options_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { + output.WriteMessage(9, element); + } + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in WritesList) { + output.WriteMessage(10, element); + } + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement element in ComparesList) { + output.WriteMessage(11, element); + } + if (HasOptions) { + output.WriteUInt64(14, Options); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { + size += pb::CodedOutputStream.ComputeMessageSize(9, element); + } + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in WritesList) { + size += pb::CodedOutputStream.ComputeMessageSize(10, element); + } + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement element in ComparesList) { + size += pb::CodedOutputStream.ComputeMessageSize(11, element); + } + if (HasOptions) { + size += pb::CodedOutputStream.ComputeUInt64Size(14, Options); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Minitransaction ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Minitransaction ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Minitransaction ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Minitransaction ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Minitransaction ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Minitransaction ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Minitransaction ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static Minitransaction ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static Minitransaction ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Minitransaction 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(Minitransaction prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Minitransaction result = new Minitransaction(); + + protected override Minitransaction MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Minitransaction(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Minitransaction.Descriptor; } + } + + public override Minitransaction DefaultInstanceForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Minitransaction.DefaultInstance; } + } + + public override Minitransaction BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.reads_.MakeReadOnly(); + result.writes_.MakeReadOnly(); + result.compares_.MakeReadOnly(); + Minitransaction returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Minitransaction) { + return MergeFrom((Minitransaction) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Minitransaction other) { + if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.Minitransaction.DefaultInstance) return this; + if (other.reads_.Count != 0) { + base.AddRange(other.reads_, result.reads_); + } + if (other.writes_.Count != 0) { + base.AddRange(other.writes_, result.writes_); + } + if (other.compares_.Count != 0) { + base.AddRange(other.compares_, result.compares_); + } + if (other.HasOptions) { + Options = other.Options; + } + 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 74: { + global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddReads(subBuilder.BuildPartial()); + break; + } + case 82: { + global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddWrites(subBuilder.BuildPartial()); + break; + } + case 90: { + global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddCompares(subBuilder.BuildPartial()); + break; + } + case 112: { + Options = input.ReadUInt64(); + break; + } + } + } + } + + + public pbc::IPopsicleList ReadsList { + get { return result.reads_; } + } + public int ReadsCount { + get { return result.ReadsCount; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { + return result.GetReads(index); + } + public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.reads_[index] = value; + return this; + } + public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.reads_[index] = builderForValue.Build(); + return this; + } + public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.reads_.Add(value); + return this; + } + public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.reads_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeReads(scg::IEnumerable values) { + base.AddRange(values, result.reads_); + return this; + } + public Builder ClearReads() { + result.reads_.Clear(); + return this; + } + + public pbc::IPopsicleList WritesList { + get { return result.writes_; } + } + public int WritesCount { + get { return result.WritesCount; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetWrites(int index) { + return result.GetWrites(index); + } + public Builder SetWrites(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.writes_[index] = value; + return this; + } + public Builder SetWrites(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.writes_[index] = builderForValue.Build(); + return this; + } + public Builder AddWrites(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.writes_.Add(value); + return this; + } + public Builder AddWrites(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.writes_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeWrites(scg::IEnumerable values) { + base.AddRange(values, result.writes_); + return this; + } + public Builder ClearWrites() { + result.writes_.Clear(); + return this; + } + + public pbc::IPopsicleList ComparesList { + get { return result.compares_; } + } + public int ComparesCount { + get { return result.ComparesCount; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement GetCompares(int index) { + return result.GetCompares(index); + } + public Builder SetCompares(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.compares_[index] = value; + return this; + } + public Builder SetCompares(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.compares_[index] = builderForValue.Build(); + return this; + } + public Builder AddCompares(global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.compares_.Add(value); + return this; + } + public Builder AddCompares(global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.compares_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeCompares(scg::IEnumerable values) { + base.AddRange(values, result.compares_); + return this; + } + public Builder ClearCompares() { + result.compares_.Clear(); + return this; + } + + public bool HasOptions { + get { return result.HasOptions; } + } + [global::System.CLSCompliant(false)] + public ulong Options { + get { return result.Options; } + set { SetOptions(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetOptions(ulong value) { + result.hasOptions = true; + result.options_ = value; + return this; + } + public Builder ClearOptions() { + result.hasOptions = false; + result.options_ = 0UL; + return this; + } + } + static Minitransaction() { + object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); + } + } + + public sealed partial class Response : pb::GeneratedMessage { + private static readonly Response defaultInstance = new Builder().BuildPartial(); + public static Response DefaultInstance { + get { return defaultInstance; } + } + + public override Response DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Response ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum ReturnStatus { + SUCCESS = 0, + DATABASE_LOCKED = 3, + KEY_MISSING = 4, + COMPARISON_FAILED = 5, + INTERNAL_ERROR = 6, + } + + } + #endregion + + public const int ReadsFieldNumber = 9; + private pbc::PopsicleList reads_ = new pbc::PopsicleList(); + public scg::IList ReadsList { + get { return reads_; } + } + public int ReadsCount { + get { return reads_.Count; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { + return reads_[index]; + } + + public const int ReturnStatusFieldNumber = 15; + private bool hasReturnStatus; + private global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus returnStatus_ = global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus.SUCCESS; + public bool HasReturnStatus { + get { return hasReturnStatus; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus ReturnStatus { + get { return returnStatus_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { + output.WriteMessage(9, element); + } + if (HasReturnStatus) { + output.WriteEnum(15, (int) ReturnStatus); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { + size += pb::CodedOutputStream.ComputeMessageSize(9, element); + } + if (HasReturnStatus) { + size += pb::CodedOutputStream.ComputeEnumSize(15, (int) ReturnStatus); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Response ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Response ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Response ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Response ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Response ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Response ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Response ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static Response ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static Response ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Response 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(Response prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Response result = new Response(); + + protected override Response MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Response(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Descriptor; } + } + + public override Response DefaultInstanceForType { + get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.DefaultInstance; } + } + + public override Response BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.reads_.MakeReadOnly(); + Response returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Response) { + return MergeFrom((Response) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Response other) { + if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.DefaultInstance) return this; + if (other.reads_.Count != 0) { + base.AddRange(other.reads_, result.reads_); + } + 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 74: { + global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddReads(subBuilder.BuildPartial()); + break; + } + case 120: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus), rawValue)) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(15, (ulong) rawValue); + } else { + ReturnStatus = (global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus) rawValue; + } + break; + } + } + } + } + + + public pbc::IPopsicleList ReadsList { + get { return result.reads_; } + } + public int ReadsCount { + get { return result.ReadsCount; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { + return result.GetReads(index); + } + public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.reads_[index] = value; + return this; + } + public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.reads_[index] = builderForValue.Build(); + return this; + } + public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.reads_.Add(value); + return this; + } + public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.reads_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeReads(scg::IEnumerable values) { + base.AddRange(values, result.reads_); + return this; + } + public Builder ClearReads() { + result.reads_.Clear(); + return this; + } + + public bool HasReturnStatus { + get { return result.HasReturnStatus; } + } + public global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus ReturnStatus { + get { return result.ReturnStatus; } + set { SetReturnStatus(value); } + } + public Builder SetReturnStatus(global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus value) { + result.hasReturnStatus = true; + result.returnStatus_ = value; + return this; + } + public Builder ClearReturnStatus() { + result.hasReturnStatus = false; + result.returnStatus_ = global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus.SUCCESS; + return this; + } + } + static Response() { + object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); + } + } + + #endregion + +} diff --git a/OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs new file mode 100644 index 0000000..54ca1f4 --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs @@ -0,0 +1,1516 @@ +using pbd = global::Google.ProtocolBuffers.Descriptors; +using pb = global::Google.ProtocolBuffers; +namespace Sirikata.Persistence.Protocol { + public class StorageKey : PBJ.IMessage { + protected _PBJ_Internal.StorageKey super; + public _PBJ_Internal.StorageKey _PBJSuper{ get { return super;} } + public StorageKey() { + super=new _PBJ_Internal.StorageKey(); + } + public StorageKey(_PBJ_Internal.StorageKey reference) { + super=reference; + } + public static StorageKey defaultInstance= new StorageKey (_PBJ_Internal.StorageKey.DefaultInstance); + public static StorageKey DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.StorageKey.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ObjectUuidFieldTag=9; + public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } + public PBJ.UUID ObjectUuid{ get { + if (HasObjectUuid) { + return PBJ._PBJ.CastUuid(super.ObjectUuid); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int FieldIdFieldTag=10; + public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} } + public ulong FieldId{ get { + if (HasFieldId) { + return PBJ._PBJ.CastUint64(super.FieldId); + } else { + return PBJ._PBJ.CastUint64(); + } + } + } + public const int FieldNameFieldTag=11; + public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} } + public string FieldName{ get { + if (HasFieldName) { + return PBJ._PBJ.CastString(super.FieldName); + } else { + return PBJ._PBJ.CastString(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(StorageKey prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static StorageKey ParseFrom(pb::ByteString data) { + return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data)); + } + public static StorageKey ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er)); + } + public static StorageKey ParseFrom(byte[] data) { + return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data)); + } + public static StorageKey ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er)); + } + public static StorageKey ParseFrom(global::System.IO.Stream data) { + return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data)); + } + public static StorageKey ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er)); + } + public static StorageKey ParseFrom(pb::CodedInputStream data) { + return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data)); + } + public static StorageKey ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.StorageKey.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.StorageKey.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.StorageKey.Builder();} + public Builder(_PBJ_Internal.StorageKey.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(StorageKey prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public StorageKey BuildPartial() {return new StorageKey(super.BuildPartial());} + public StorageKey Build() {if (_HasAllPBJFields) return new StorageKey(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return StorageKey.Descriptor; } } + public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;} + public const int ObjectUuidFieldTag=9; + public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } + public PBJ.UUID ObjectUuid{ get { + if (HasObjectUuid) { + return PBJ._PBJ.CastUuid(super.ObjectUuid); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.ObjectUuid=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearFieldId() { super.ClearFieldId();return this;} + public const int FieldIdFieldTag=10; + public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} } + public ulong FieldId{ get { + if (HasFieldId) { + return PBJ._PBJ.CastUint64(super.FieldId); + } else { + return PBJ._PBJ.CastUint64(); + } + } + set { + super.FieldId=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearFieldName() { super.ClearFieldName();return this;} + public const int FieldNameFieldTag=11; + public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} } + public string FieldName{ get { + if (HasFieldName) { + return PBJ._PBJ.CastString(super.FieldName); + } else { + return PBJ._PBJ.CastString(); + } + } + set { + super.FieldName=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Persistence.Protocol { + public class StorageValue : PBJ.IMessage { + protected _PBJ_Internal.StorageValue super; + public _PBJ_Internal.StorageValue _PBJSuper{ get { return super;} } + public StorageValue() { + super=new _PBJ_Internal.StorageValue(); + } + public StorageValue(_PBJ_Internal.StorageValue reference) { + super=reference; + } + public static StorageValue defaultInstance= new StorageValue (_PBJ_Internal.StorageValue.DefaultInstance); + public static StorageValue DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.StorageValue.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int DataFieldTag=12; + public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} } + public pb::ByteString Data{ get { + if (HasData) { + return PBJ._PBJ.CastBytes(super.Data); + } else { + return PBJ._PBJ.CastBytes(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(StorageValue prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static StorageValue ParseFrom(pb::ByteString data) { + return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data)); + } + public static StorageValue ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er)); + } + public static StorageValue ParseFrom(byte[] data) { + return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data)); + } + public static StorageValue ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er)); + } + public static StorageValue ParseFrom(global::System.IO.Stream data) { + return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data)); + } + public static StorageValue ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er)); + } + public static StorageValue ParseFrom(pb::CodedInputStream data) { + return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data)); + } + public static StorageValue ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.StorageValue.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.StorageValue.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.StorageValue.Builder();} + public Builder(_PBJ_Internal.StorageValue.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(StorageValue prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public StorageValue BuildPartial() {return new StorageValue(super.BuildPartial());} + public StorageValue Build() {if (_HasAllPBJFields) return new StorageValue(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return StorageValue.Descriptor; } } + public Builder ClearData() { super.ClearData();return this;} + public const int DataFieldTag=12; + public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} } + public pb::ByteString Data{ get { + if (HasData) { + return PBJ._PBJ.CastBytes(super.Data); + } else { + return PBJ._PBJ.CastBytes(); + } + } + set { + super.Data=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Persistence.Protocol { + public class StorageElement : PBJ.IMessage { + protected _PBJ_Internal.StorageElement super; + public _PBJ_Internal.StorageElement _PBJSuper{ get { return super;} } + public StorageElement() { + super=new _PBJ_Internal.StorageElement(); + } + public StorageElement(_PBJ_Internal.StorageElement reference) { + super=reference; + } + public static StorageElement defaultInstance= new StorageElement (_PBJ_Internal.StorageElement.DefaultInstance); + public static StorageElement DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.StorageElement.Descriptor; } } + public static class Types { + public enum ReturnStatus { + KEY_MISSING=_PBJ_Internal.StorageElement.Types.ReturnStatus.KEY_MISSING, + INTERNAL_ERROR=_PBJ_Internal.StorageElement.Types.ReturnStatus.INTERNAL_ERROR + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ObjectUuidFieldTag=9; + public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } + public PBJ.UUID ObjectUuid{ get { + if (HasObjectUuid) { + return PBJ._PBJ.CastUuid(super.ObjectUuid); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int FieldIdFieldTag=10; + public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} } + public ulong FieldId{ get { + if (HasFieldId) { + return PBJ._PBJ.CastUint64(super.FieldId); + } else { + return PBJ._PBJ.CastUint64(); + } + } + } + public const int FieldNameFieldTag=11; + public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} } + public string FieldName{ get { + if (HasFieldName) { + return PBJ._PBJ.CastString(super.FieldName); + } else { + return PBJ._PBJ.CastString(); + } + } + } + public const int DataFieldTag=12; + public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} } + public pb::ByteString Data{ get { + if (HasData) { + return PBJ._PBJ.CastBytes(super.Data); + } else { + return PBJ._PBJ.CastBytes(); + } + } + } + public const int IndexFieldTag=13; + public bool HasIndex{ get {return super.HasIndex&&PBJ._PBJ.ValidateInt32(super.Index);} } + public int Index{ get { + if (HasIndex) { + return PBJ._PBJ.CastInt32(super.Index); + } else { + return PBJ._PBJ.CastInt32(); + } + } + } + public const int ReturnStatusFieldTag=15; + public bool HasReturnStatus{ get {return super.HasReturnStatus;} } + public Types.ReturnStatus ReturnStatus{ get { + if (HasReturnStatus) { + return (Types.ReturnStatus)super.ReturnStatus; + } else { + return new Types.ReturnStatus(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(StorageElement prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static StorageElement ParseFrom(pb::ByteString data) { + return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data)); + } + public static StorageElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er)); + } + public static StorageElement ParseFrom(byte[] data) { + return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data)); + } + public static StorageElement ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er)); + } + public static StorageElement ParseFrom(global::System.IO.Stream data) { + return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data)); + } + public static StorageElement ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er)); + } + public static StorageElement ParseFrom(pb::CodedInputStream data) { + return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data)); + } + public static StorageElement ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.StorageElement.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.StorageElement.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.StorageElement.Builder();} + public Builder(_PBJ_Internal.StorageElement.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(StorageElement prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public StorageElement BuildPartial() {return new StorageElement(super.BuildPartial());} + public StorageElement Build() {if (_HasAllPBJFields) return new StorageElement(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return StorageElement.Descriptor; } } + public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;} + public const int ObjectUuidFieldTag=9; + public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } + public PBJ.UUID ObjectUuid{ get { + if (HasObjectUuid) { + return PBJ._PBJ.CastUuid(super.ObjectUuid); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.ObjectUuid=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearFieldId() { super.ClearFieldId();return this;} + public const int FieldIdFieldTag=10; + public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} } + public ulong FieldId{ get { + if (HasFieldId) { + return PBJ._PBJ.CastUint64(super.FieldId); + } else { + return PBJ._PBJ.CastUint64(); + } + } + set { + super.FieldId=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearFieldName() { super.ClearFieldName();return this;} + public const int FieldNameFieldTag=11; + public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} } + public string FieldName{ get { + if (HasFieldName) { + return PBJ._PBJ.CastString(super.FieldName); + } else { + return PBJ._PBJ.CastString(); + } + } + set { + super.FieldName=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearData() { super.ClearData();return this;} + public const int DataFieldTag=12; + public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} } + public pb::ByteString Data{ get { + if (HasData) { + return PBJ._PBJ.CastBytes(super.Data); + } else { + return PBJ._PBJ.CastBytes(); + } + } + set { + super.Data=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearIndex() { super.ClearIndex();return this;} + public const int IndexFieldTag=13; + public bool HasIndex{ get {return super.HasIndex&&PBJ._PBJ.ValidateInt32(super.Index);} } + public int Index{ get { + if (HasIndex) { + return PBJ._PBJ.CastInt32(super.Index); + } else { + return PBJ._PBJ.CastInt32(); + } + } + set { + super.Index=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;} + public const int ReturnStatusFieldTag=15; + public bool HasReturnStatus{ get {return super.HasReturnStatus;} } + public Types.ReturnStatus ReturnStatus{ get { + if (HasReturnStatus) { + return (Types.ReturnStatus)super.ReturnStatus; + } else { + return new Types.ReturnStatus(); + } + } + set { + super.ReturnStatus=((_PBJ_Internal.StorageElement.Types.ReturnStatus)value); + } + } + } + } +} +namespace Sirikata.Persistence.Protocol { + public class CompareElement : PBJ.IMessage { + protected _PBJ_Internal.CompareElement super; + public _PBJ_Internal.CompareElement _PBJSuper{ get { return super;} } + public CompareElement() { + super=new _PBJ_Internal.CompareElement(); + } + public CompareElement(_PBJ_Internal.CompareElement reference) { + super=reference; + } + public static CompareElement defaultInstance= new CompareElement (_PBJ_Internal.CompareElement.DefaultInstance); + public static CompareElement DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.CompareElement.Descriptor; } } + public static class Types { + public enum COMPARATOR { + EQUAL=_PBJ_Internal.CompareElement.Types.COMPARATOR.EQUAL, + NEQUAL=_PBJ_Internal.CompareElement.Types.COMPARATOR.NEQUAL + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ObjectUuidFieldTag=9; + public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } + public PBJ.UUID ObjectUuid{ get { + if (HasObjectUuid) { + return PBJ._PBJ.CastUuid(super.ObjectUuid); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int FieldIdFieldTag=10; + public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} } + public ulong FieldId{ get { + if (HasFieldId) { + return PBJ._PBJ.CastUint64(super.FieldId); + } else { + return PBJ._PBJ.CastUint64(); + } + } + } + public const int FieldNameFieldTag=11; + public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} } + public string FieldName{ get { + if (HasFieldName) { + return PBJ._PBJ.CastString(super.FieldName); + } else { + return PBJ._PBJ.CastString(); + } + } + } + public const int DataFieldTag=12; + public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} } + public pb::ByteString Data{ get { + if (HasData) { + return PBJ._PBJ.CastBytes(super.Data); + } else { + return PBJ._PBJ.CastBytes(); + } + } + } + public const int ComparatorFieldTag=14; + public bool HasComparator{ get {return super.HasComparator;} } + public Types.COMPARATOR Comparator{ get { + if (HasComparator) { + return (Types.COMPARATOR)super.Comparator; + } else { + return new Types.COMPARATOR(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(CompareElement prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static CompareElement ParseFrom(pb::ByteString data) { + return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data)); + } + public static CompareElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er)); + } + public static CompareElement ParseFrom(byte[] data) { + return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data)); + } + public static CompareElement ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er)); + } + public static CompareElement ParseFrom(global::System.IO.Stream data) { + return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data)); + } + public static CompareElement ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er)); + } + public static CompareElement ParseFrom(pb::CodedInputStream data) { + return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data)); + } + public static CompareElement ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.CompareElement.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.CompareElement.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.CompareElement.Builder();} + public Builder(_PBJ_Internal.CompareElement.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(CompareElement prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public CompareElement BuildPartial() {return new CompareElement(super.BuildPartial());} + public CompareElement Build() {if (_HasAllPBJFields) return new CompareElement(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return CompareElement.Descriptor; } } + public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;} + public const int ObjectUuidFieldTag=9; + public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } + public PBJ.UUID ObjectUuid{ get { + if (HasObjectUuid) { + return PBJ._PBJ.CastUuid(super.ObjectUuid); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.ObjectUuid=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearFieldId() { super.ClearFieldId();return this;} + public const int FieldIdFieldTag=10; + public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} } + public ulong FieldId{ get { + if (HasFieldId) { + return PBJ._PBJ.CastUint64(super.FieldId); + } else { + return PBJ._PBJ.CastUint64(); + } + } + set { + super.FieldId=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearFieldName() { super.ClearFieldName();return this;} + public const int FieldNameFieldTag=11; + public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} } + public string FieldName{ get { + if (HasFieldName) { + return PBJ._PBJ.CastString(super.FieldName); + } else { + return PBJ._PBJ.CastString(); + } + } + set { + super.FieldName=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearData() { super.ClearData();return this;} + public const int DataFieldTag=12; + public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} } + public pb::ByteString Data{ get { + if (HasData) { + return PBJ._PBJ.CastBytes(super.Data); + } else { + return PBJ._PBJ.CastBytes(); + } + } + set { + super.Data=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearComparator() { super.ClearComparator();return this;} + public const int ComparatorFieldTag=14; + public bool HasComparator{ get {return super.HasComparator;} } + public Types.COMPARATOR Comparator{ get { + if (HasComparator) { + return (Types.COMPARATOR)super.Comparator; + } else { + return new Types.COMPARATOR(); + } + } + set { + super.Comparator=((_PBJ_Internal.CompareElement.Types.COMPARATOR)value); + } + } + } + } +} +namespace Sirikata.Persistence.Protocol { + public class StorageSet : PBJ.IMessage { + protected _PBJ_Internal.StorageSet super; + public _PBJ_Internal.StorageSet _PBJSuper{ get { return super;} } + public StorageSet() { + super=new _PBJ_Internal.StorageSet(); + } + public StorageSet(_PBJ_Internal.StorageSet reference) { + super=reference; + } + public static StorageSet defaultInstance= new StorageSet (_PBJ_Internal.StorageSet.DefaultInstance); + public static StorageSet DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.StorageSet.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ReadsFieldTag=9; + public int ReadsCount { get { return super.ReadsCount;} } + public bool HasReads(int index) {return true;} + public StorageElement Reads(int index) { + return new StorageElement(super.GetReads(index)); + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(StorageSet prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static StorageSet ParseFrom(pb::ByteString data) { + return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data)); + } + public static StorageSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er)); + } + public static StorageSet ParseFrom(byte[] data) { + return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data)); + } + public static StorageSet ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er)); + } + public static StorageSet ParseFrom(global::System.IO.Stream data) { + return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data)); + } + public static StorageSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er)); + } + public static StorageSet ParseFrom(pb::CodedInputStream data) { + return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data)); + } + public static StorageSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.StorageSet.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.StorageSet.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.StorageSet.Builder();} + public Builder(_PBJ_Internal.StorageSet.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(StorageSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public StorageSet BuildPartial() {return new StorageSet(super.BuildPartial());} + public StorageSet Build() {if (_HasAllPBJFields) return new StorageSet(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return StorageSet.Descriptor; } } + public Builder ClearReads() { super.ClearReads();return this;} + public Builder SetReads(int index,StorageElement value) { + super.SetReads(index,value._PBJSuper); + return this; + } + public const int ReadsFieldTag=9; + public int ReadsCount { get { return super.ReadsCount;} } + public bool HasReads(int index) {return true;} + public StorageElement Reads(int index) { + return new StorageElement(super.GetReads(index)); + } + public Builder AddReads(StorageElement value ) { + super.AddReads(value._PBJSuper); + return this; + } + } + } +} +namespace Sirikata.Persistence.Protocol { + public class ReadSet : PBJ.IMessage { + protected _PBJ_Internal.ReadSet super; + public _PBJ_Internal.ReadSet _PBJSuper{ get { return super;} } + public ReadSet() { + super=new _PBJ_Internal.ReadSet(); + } + public ReadSet(_PBJ_Internal.ReadSet reference) { + super=reference; + } + public static ReadSet defaultInstance= new ReadSet (_PBJ_Internal.ReadSet.DefaultInstance); + public static ReadSet DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.ReadSet.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ReadsFieldTag=9; + public int ReadsCount { get { return super.ReadsCount;} } + public bool HasReads(int index) {return true;} + public StorageElement Reads(int index) { + return new StorageElement(super.GetReads(index)); + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(ReadSet prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static ReadSet ParseFrom(pb::ByteString data) { + return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data)); + } + public static ReadSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er)); + } + public static ReadSet ParseFrom(byte[] data) { + return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data)); + } + public static ReadSet ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er)); + } + public static ReadSet ParseFrom(global::System.IO.Stream data) { + return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data)); + } + public static ReadSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er)); + } + public static ReadSet ParseFrom(pb::CodedInputStream data) { + return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data)); + } + public static ReadSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.ReadSet.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.ReadSet.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.ReadSet.Builder();} + public Builder(_PBJ_Internal.ReadSet.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(ReadSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public ReadSet BuildPartial() {return new ReadSet(super.BuildPartial());} + public ReadSet Build() {if (_HasAllPBJFields) return new ReadSet(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return ReadSet.Descriptor; } } + public Builder ClearReads() { super.ClearReads();return this;} + public Builder SetReads(int index,StorageElement value) { + super.SetReads(index,value._PBJSuper); + return this; + } + public const int ReadsFieldTag=9; + public int ReadsCount { get { return super.ReadsCount;} } + public bool HasReads(int index) {return true;} + public StorageElement Reads(int index) { + return new StorageElement(super.GetReads(index)); + } + public Builder AddReads(StorageElement value ) { + super.AddReads(value._PBJSuper); + return this; + } + } + } +} +namespace Sirikata.Persistence.Protocol { + public class WriteSet : PBJ.IMessage { + protected _PBJ_Internal.WriteSet super; + public _PBJ_Internal.WriteSet _PBJSuper{ get { return super;} } + public WriteSet() { + super=new _PBJ_Internal.WriteSet(); + } + public WriteSet(_PBJ_Internal.WriteSet reference) { + super=reference; + } + public static WriteSet defaultInstance= new WriteSet (_PBJ_Internal.WriteSet.DefaultInstance); + public static WriteSet DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.WriteSet.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int WritesFieldTag=10; + public int WritesCount { get { return super.WritesCount;} } + public bool HasWrites(int index) {return true;} + public StorageElement Writes(int index) { + return new StorageElement(super.GetWrites(index)); + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(WriteSet prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static WriteSet ParseFrom(pb::ByteString data) { + return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data)); + } + public static WriteSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er)); + } + public static WriteSet ParseFrom(byte[] data) { + return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data)); + } + public static WriteSet ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er)); + } + public static WriteSet ParseFrom(global::System.IO.Stream data) { + return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data)); + } + public static WriteSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er)); + } + public static WriteSet ParseFrom(pb::CodedInputStream data) { + return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data)); + } + public static WriteSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.WriteSet.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.WriteSet.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.WriteSet.Builder();} + public Builder(_PBJ_Internal.WriteSet.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(WriteSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public WriteSet BuildPartial() {return new WriteSet(super.BuildPartial());} + public WriteSet Build() {if (_HasAllPBJFields) return new WriteSet(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return WriteSet.Descriptor; } } + public Builder ClearWrites() { super.ClearWrites();return this;} + public Builder SetWrites(int index,StorageElement value) { + super.SetWrites(index,value._PBJSuper); + return this; + } + public const int WritesFieldTag=10; + public int WritesCount { get { return super.WritesCount;} } + public bool HasWrites(int index) {return true;} + public StorageElement Writes(int index) { + return new StorageElement(super.GetWrites(index)); + } + public Builder AddWrites(StorageElement value ) { + super.AddWrites(value._PBJSuper); + return this; + } + } + } +} +namespace Sirikata.Persistence.Protocol { + public class ReadWriteSet : PBJ.IMessage { + protected _PBJ_Internal.ReadWriteSet super; + public _PBJ_Internal.ReadWriteSet _PBJSuper{ get { return super;} } + public ReadWriteSet() { + super=new _PBJ_Internal.ReadWriteSet(); + } + public ReadWriteSet(_PBJ_Internal.ReadWriteSet reference) { + super=reference; + } + public static ReadWriteSet defaultInstance= new ReadWriteSet (_PBJ_Internal.ReadWriteSet.DefaultInstance); + public static ReadWriteSet DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.ReadWriteSet.Descriptor; } } + public static class Types { + public enum ReadWriteSetOptions { + RETURN_READ_NAMES=_PBJ_Internal.ReadWriteSet.Types.ReadWriteSetOptions.RETURN_READ_NAMES + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ReadsFieldTag=9; + public int ReadsCount { get { return super.ReadsCount;} } + public bool HasReads(int index) {return true;} + public StorageElement Reads(int index) { + return new StorageElement(super.GetReads(index)); + } + public const int WritesFieldTag=10; + public int WritesCount { get { return super.WritesCount;} } + public bool HasWrites(int index) {return true;} + public StorageElement Writes(int index) { + return new StorageElement(super.GetWrites(index)); + } + public const int OptionsFieldTag=14; + public bool HasOptions { get { + if (!super.HasOptions) return false; + return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES); + } } + public ulong Options{ get { + if (HasOptions) { + return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES); + } else { + return (ulong)PBJ._PBJ.CastFlags((ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(ReadWriteSet prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static ReadWriteSet ParseFrom(pb::ByteString data) { + return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data)); + } + public static ReadWriteSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er)); + } + public static ReadWriteSet ParseFrom(byte[] data) { + return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data)); + } + public static ReadWriteSet ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er)); + } + public static ReadWriteSet ParseFrom(global::System.IO.Stream data) { + return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data)); + } + public static ReadWriteSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er)); + } + public static ReadWriteSet ParseFrom(pb::CodedInputStream data) { + return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data)); + } + public static ReadWriteSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.ReadWriteSet.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.ReadWriteSet.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.ReadWriteSet.Builder();} + public Builder(_PBJ_Internal.ReadWriteSet.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(ReadWriteSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public ReadWriteSet BuildPartial() {return new ReadWriteSet(super.BuildPartial());} + public ReadWriteSet Build() {if (_HasAllPBJFields) return new ReadWriteSet(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return ReadWriteSet.Descriptor; } } + public Builder ClearReads() { super.ClearReads();return this;} + public Builder SetReads(int index,StorageElement value) { + super.SetReads(index,value._PBJSuper); + return this; + } + public const int ReadsFieldTag=9; + public int ReadsCount { get { return super.ReadsCount;} } + public bool HasReads(int index) {return true;} + public StorageElement Reads(int index) { + return new StorageElement(super.GetReads(index)); + } + public Builder AddReads(StorageElement value ) { + super.AddReads(value._PBJSuper); + return this; + } + public Builder ClearWrites() { super.ClearWrites();return this;} + public Builder SetWrites(int index,StorageElement value) { + super.SetWrites(index,value._PBJSuper); + return this; + } + public const int WritesFieldTag=10; + public int WritesCount { get { return super.WritesCount;} } + public bool HasWrites(int index) {return true;} + public StorageElement Writes(int index) { + return new StorageElement(super.GetWrites(index)); + } + public Builder AddWrites(StorageElement value ) { + super.AddWrites(value._PBJSuper); + return this; + } + public Builder ClearOptions() { super.ClearOptions();return this;} + public const int OptionsFieldTag=14; + public bool HasOptions { get { + if (!super.HasOptions) return false; + return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES); + } } + public ulong Options{ get { + if (HasOptions) { + return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES); + } else { + return (ulong)PBJ._PBJ.CastFlags((ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES); + } + } + set { + super.Options=((value)); + } + } + } + } +} +namespace Sirikata.Persistence.Protocol { + public class Minitransaction : PBJ.IMessage { + protected _PBJ_Internal.Minitransaction super; + public _PBJ_Internal.Minitransaction _PBJSuper{ get { return super;} } + public Minitransaction() { + super=new _PBJ_Internal.Minitransaction(); + } + public Minitransaction(_PBJ_Internal.Minitransaction reference) { + super=reference; + } + public static Minitransaction defaultInstance= new Minitransaction (_PBJ_Internal.Minitransaction.DefaultInstance); + public static Minitransaction DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.Minitransaction.Descriptor; } } + public static class Types { + public enum TransactionOptions { + RETURN_READ_NAMES=_PBJ_Internal.Minitransaction.Types.TransactionOptions.RETURN_READ_NAMES + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ReadsFieldTag=9; + public int ReadsCount { get { return super.ReadsCount;} } + public bool HasReads(int index) {return true;} + public StorageElement Reads(int index) { + return new StorageElement(super.GetReads(index)); + } + public const int WritesFieldTag=10; + public int WritesCount { get { return super.WritesCount;} } + public bool HasWrites(int index) {return true;} + public StorageElement Writes(int index) { + return new StorageElement(super.GetWrites(index)); + } + public const int ComparesFieldTag=11; + public int ComparesCount { get { return super.ComparesCount;} } + public bool HasCompares(int index) {return true;} + public CompareElement Compares(int index) { + return new CompareElement(super.GetCompares(index)); + } + public const int OptionsFieldTag=14; + public bool HasOptions { get { + if (!super.HasOptions) return false; + return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES); + } } + public ulong Options{ get { + if (HasOptions) { + return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES); + } else { + return (ulong)PBJ._PBJ.CastFlags((ulong)Types.TransactionOptions.RETURN_READ_NAMES); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(Minitransaction prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static Minitransaction ParseFrom(pb::ByteString data) { + return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data)); + } + public static Minitransaction ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er)); + } + public static Minitransaction ParseFrom(byte[] data) { + return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data)); + } + public static Minitransaction ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er)); + } + public static Minitransaction ParseFrom(global::System.IO.Stream data) { + return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data)); + } + public static Minitransaction ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er)); + } + public static Minitransaction ParseFrom(pb::CodedInputStream data) { + return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data)); + } + public static Minitransaction ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.Minitransaction.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.Minitransaction.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.Minitransaction.Builder();} + public Builder(_PBJ_Internal.Minitransaction.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(Minitransaction prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public Minitransaction BuildPartial() {return new Minitransaction(super.BuildPartial());} + public Minitransaction Build() {if (_HasAllPBJFields) return new Minitransaction(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return Minitransaction.Descriptor; } } + public Builder ClearReads() { super.ClearReads();return this;} + public Builder SetReads(int index,StorageElement value) { + super.SetReads(index,value._PBJSuper); + return this; + } + public const int ReadsFieldTag=9; + public int ReadsCount { get { return super.ReadsCount;} } + public bool HasReads(int index) {return true;} + public StorageElement Reads(int index) { + return new StorageElement(super.GetReads(index)); + } + public Builder AddReads(StorageElement value ) { + super.AddReads(value._PBJSuper); + return this; + } + public Builder ClearWrites() { super.ClearWrites();return this;} + public Builder SetWrites(int index,StorageElement value) { + super.SetWrites(index,value._PBJSuper); + return this; + } + public const int WritesFieldTag=10; + public int WritesCount { get { return super.WritesCount;} } + public bool HasWrites(int index) {return true;} + public StorageElement Writes(int index) { + return new StorageElement(super.GetWrites(index)); + } + public Builder AddWrites(StorageElement value ) { + super.AddWrites(value._PBJSuper); + return this; + } + public Builder ClearCompares() { super.ClearCompares();return this;} + public Builder SetCompares(int index,CompareElement value) { + super.SetCompares(index,value._PBJSuper); + return this; + } + public const int ComparesFieldTag=11; + public int ComparesCount { get { return super.ComparesCount;} } + public bool HasCompares(int index) {return true;} + public CompareElement Compares(int index) { + return new CompareElement(super.GetCompares(index)); + } + public Builder AddCompares(CompareElement value ) { + super.AddCompares(value._PBJSuper); + return this; + } + public Builder ClearOptions() { super.ClearOptions();return this;} + public const int OptionsFieldTag=14; + public bool HasOptions { get { + if (!super.HasOptions) return false; + return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES); + } } + public ulong Options{ get { + if (HasOptions) { + return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES); + } else { + return (ulong)PBJ._PBJ.CastFlags((ulong)Types.TransactionOptions.RETURN_READ_NAMES); + } + } + set { + super.Options=((value)); + } + } + } + } +} +namespace Sirikata.Persistence.Protocol { + public class Response : PBJ.IMessage { + protected _PBJ_Internal.Response super; + public _PBJ_Internal.Response _PBJSuper{ get { return super;} } + public Response() { + super=new _PBJ_Internal.Response(); + } + public Response(_PBJ_Internal.Response reference) { + super=reference; + } + public static Response defaultInstance= new Response (_PBJ_Internal.Response.DefaultInstance); + public static Response DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.Response.Descriptor; } } + public static class Types { + public enum ReturnStatus { + SUCCESS=_PBJ_Internal.Response.Types.ReturnStatus.SUCCESS, + DATABASE_LOCKED=_PBJ_Internal.Response.Types.ReturnStatus.DATABASE_LOCKED, + KEY_MISSING=_PBJ_Internal.Response.Types.ReturnStatus.KEY_MISSING, + COMPARISON_FAILED=_PBJ_Internal.Response.Types.ReturnStatus.COMPARISON_FAILED, + INTERNAL_ERROR=_PBJ_Internal.Response.Types.ReturnStatus.INTERNAL_ERROR + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ReadsFieldTag=9; + public int ReadsCount { get { return super.ReadsCount;} } + public bool HasReads(int index) {return true;} + public StorageElement Reads(int index) { + return new StorageElement(super.GetReads(index)); + } + public const int ReturnStatusFieldTag=15; + public bool HasReturnStatus{ get {return super.HasReturnStatus;} } + public Types.ReturnStatus ReturnStatus{ get { + if (HasReturnStatus) { + return (Types.ReturnStatus)super.ReturnStatus; + } else { + return new Types.ReturnStatus(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(Response prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static Response ParseFrom(pb::ByteString data) { + return new Response(_PBJ_Internal.Response.ParseFrom(data)); + } + public static Response ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new Response(_PBJ_Internal.Response.ParseFrom(data,er)); + } + public static Response ParseFrom(byte[] data) { + return new Response(_PBJ_Internal.Response.ParseFrom(data)); + } + public static Response ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new Response(_PBJ_Internal.Response.ParseFrom(data,er)); + } + public static Response ParseFrom(global::System.IO.Stream data) { + return new Response(_PBJ_Internal.Response.ParseFrom(data)); + } + public static Response ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new Response(_PBJ_Internal.Response.ParseFrom(data,er)); + } + public static Response ParseFrom(pb::CodedInputStream data) { + return new Response(_PBJ_Internal.Response.ParseFrom(data)); + } + public static Response ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new Response(_PBJ_Internal.Response.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.Response.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.Response.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.Response.Builder();} + public Builder(_PBJ_Internal.Response.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(Response prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public Response BuildPartial() {return new Response(super.BuildPartial());} + public Response Build() {if (_HasAllPBJFields) return new Response(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return Response.Descriptor; } } + public Builder ClearReads() { super.ClearReads();return this;} + public Builder SetReads(int index,StorageElement value) { + super.SetReads(index,value._PBJSuper); + return this; + } + public const int ReadsFieldTag=9; + public int ReadsCount { get { return super.ReadsCount;} } + public bool HasReads(int index) {return true;} + public StorageElement Reads(int index) { + return new StorageElement(super.GetReads(index)); + } + public Builder AddReads(StorageElement value ) { + super.AddReads(value._PBJSuper); + return this; + } + public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;} + public const int ReturnStatusFieldTag=15; + public bool HasReturnStatus{ get {return super.HasReturnStatus;} } + public Types.ReturnStatus ReturnStatus{ get { + if (HasReturnStatus) { + return (Types.ReturnStatus)super.ReturnStatus; + } else { + return new Types.ReturnStatus(); + } + } + set { + super.ReturnStatus=((_PBJ_Internal.Response.Types.ReturnStatus)value); + } + } + } + } +} diff --git a/OpenSim/Client/Sirikata/Protocol/Physics.cs b/OpenSim/Client/Sirikata/Protocol/Physics.cs new file mode 100644 index 0000000..a81a6fd --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Physics.cs @@ -0,0 +1,840 @@ +// 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.Physics.Protocol._PBJ_Internal { + + public static partial class Physics { + + #region Extension registration + public static void RegisterAllExtensions(pb::ExtensionRegistry registry) { + } + #endregion + #region Static variables + internal static pbd::MessageDescriptor internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__FieldAccessorTable; + #endregion + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbd::FileDescriptor descriptor; + + static Physics() { + byte[] descriptorData = global::System.Convert.FromBase64String( + "Cg1QaHlzaWNzLnByb3RvEidTaXJpa2F0YS5QaHlzaWNzLlByb3RvY29sLl9Q" + + "QkpfSW50ZXJuYWwiqAEKDkNvbGxpc2lvbkJlZ2luEhEKCXRpbWVzdGFtcBgC" + + "IAEoBhIZCg10aGlzX3Bvc2l0aW9uGAMgAygBQgIQARIaCg5vdGhlcl9wb3Np" + + "dGlvbhgEIAMoAUICEAESFwoLdGhpc19ub3JtYWwYBSADKAJCAhABEhMKB2lt" + + "cHVsc2UYBiADKAJCAhABEh4KFm90aGVyX29iamVjdF9yZWZlcmVuY2UYByAB" + + "KAwiQQoMQ29sbGlzaW9uRW5kEhEKCXRpbWVzdGFtcBgCIAEoBhIeChZvdGhl" + + "cl9vYmplY3RfcmVmZXJlbmNlGAYgASgM"); + pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { + descriptor = root; + internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__Descriptor = Descriptor.MessageTypes[0]; + internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__Descriptor, + new string[] { "Timestamp", "ThisPosition", "OtherPosition", "ThisNormal", "Impulse", "OtherObjectReference", }); + internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__Descriptor = Descriptor.MessageTypes[1]; + internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__Descriptor, + new string[] { "Timestamp", "OtherObjectReference", }); + return null; + }; + pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, + new pbd::FileDescriptor[] { + }, assigner); + } + #endregion + + } + #region Messages + public sealed partial class CollisionBegin : pb::GeneratedMessage { + private static readonly CollisionBegin defaultInstance = new Builder().BuildPartial(); + public static CollisionBegin DefaultInstance { + get { return defaultInstance; } + } + + public override CollisionBegin DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CollisionBegin ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__FieldAccessorTable; } + } + + public const int TimestampFieldNumber = 2; + private bool hasTimestamp; + private ulong timestamp_ = 0; + public bool HasTimestamp { + get { return hasTimestamp; } + } + [global::System.CLSCompliant(false)] + public ulong Timestamp { + get { return timestamp_; } + } + + public const int ThisPositionFieldNumber = 3; + private int thisPositionMemoizedSerializedSize; + private pbc::PopsicleList thisPosition_ = new pbc::PopsicleList(); + public scg::IList ThisPositionList { + get { return pbc::Lists.AsReadOnly(thisPosition_); } + } + public int ThisPositionCount { + get { return thisPosition_.Count; } + } + public double GetThisPosition(int index) { + return thisPosition_[index]; + } + + public const int OtherPositionFieldNumber = 4; + private int otherPositionMemoizedSerializedSize; + private pbc::PopsicleList otherPosition_ = new pbc::PopsicleList(); + public scg::IList OtherPositionList { + get { return pbc::Lists.AsReadOnly(otherPosition_); } + } + public int OtherPositionCount { + get { return otherPosition_.Count; } + } + public double GetOtherPosition(int index) { + return otherPosition_[index]; + } + + public const int ThisNormalFieldNumber = 5; + private int thisNormalMemoizedSerializedSize; + private pbc::PopsicleList thisNormal_ = new pbc::PopsicleList(); + public scg::IList ThisNormalList { + get { return pbc::Lists.AsReadOnly(thisNormal_); } + } + public int ThisNormalCount { + get { return thisNormal_.Count; } + } + public float GetThisNormal(int index) { + return thisNormal_[index]; + } + + public const int ImpulseFieldNumber = 6; + private int impulseMemoizedSerializedSize; + private pbc::PopsicleList impulse_ = new pbc::PopsicleList(); + public scg::IList ImpulseList { + get { return pbc::Lists.AsReadOnly(impulse_); } + } + public int ImpulseCount { + get { return impulse_.Count; } + } + public float GetImpulse(int index) { + return impulse_[index]; + } + + public const int OtherObjectReferenceFieldNumber = 7; + private bool hasOtherObjectReference; + private pb::ByteString otherObjectReference_ = pb::ByteString.Empty; + public bool HasOtherObjectReference { + get { return hasOtherObjectReference; } + } + public pb::ByteString OtherObjectReference { + get { return otherObjectReference_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasTimestamp) { + output.WriteFixed64(2, Timestamp); + } + if (thisPosition_.Count > 0) { + output.WriteRawVarint32(26); + output.WriteRawVarint32((uint) thisPositionMemoizedSerializedSize); + foreach (double element in thisPosition_) { + output.WriteDoubleNoTag(element); + } + } + if (otherPosition_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) otherPositionMemoizedSerializedSize); + foreach (double element in otherPosition_) { + output.WriteDoubleNoTag(element); + } + } + if (thisNormal_.Count > 0) { + output.WriteRawVarint32(42); + output.WriteRawVarint32((uint) thisNormalMemoizedSerializedSize); + foreach (float element in thisNormal_) { + output.WriteFloatNoTag(element); + } + } + if (impulse_.Count > 0) { + output.WriteRawVarint32(50); + output.WriteRawVarint32((uint) impulseMemoizedSerializedSize); + foreach (float element in impulse_) { + output.WriteFloatNoTag(element); + } + } + if (HasOtherObjectReference) { + output.WriteBytes(7, OtherObjectReference); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasTimestamp) { + size += pb::CodedOutputStream.ComputeFixed64Size(2, Timestamp); + } + { + int dataSize = 0; + dataSize = 8 * thisPosition_.Count; + size += dataSize; + if (thisPosition_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + thisPositionMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 8 * otherPosition_.Count; + size += dataSize; + if (otherPosition_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + otherPositionMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * thisNormal_.Count; + size += dataSize; + if (thisNormal_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + thisNormalMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * impulse_.Count; + size += dataSize; + if (impulse_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + impulseMemoizedSerializedSize = dataSize; + } + if (HasOtherObjectReference) { + size += pb::CodedOutputStream.ComputeBytesSize(7, OtherObjectReference); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static CollisionBegin ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CollisionBegin ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CollisionBegin ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CollisionBegin ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CollisionBegin ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CollisionBegin ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CollisionBegin ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static CollisionBegin ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static CollisionBegin ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CollisionBegin 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(CollisionBegin prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CollisionBegin result = new CollisionBegin(); + + protected override CollisionBegin MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CollisionBegin(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.Descriptor; } + } + + public override CollisionBegin DefaultInstanceForType { + get { return global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.DefaultInstance; } + } + + public override CollisionBegin BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.thisPosition_.MakeReadOnly(); + result.otherPosition_.MakeReadOnly(); + result.thisNormal_.MakeReadOnly(); + result.impulse_.MakeReadOnly(); + CollisionBegin returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is CollisionBegin) { + return MergeFrom((CollisionBegin) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(CollisionBegin other) { + if (other == global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.DefaultInstance) return this; + if (other.HasTimestamp) { + Timestamp = other.Timestamp; + } + if (other.thisPosition_.Count != 0) { + base.AddRange(other.thisPosition_, result.thisPosition_); + } + if (other.otherPosition_.Count != 0) { + base.AddRange(other.otherPosition_, result.otherPosition_); + } + if (other.thisNormal_.Count != 0) { + base.AddRange(other.thisNormal_, result.thisNormal_); + } + if (other.impulse_.Count != 0) { + base.AddRange(other.impulse_, result.impulse_); + } + if (other.HasOtherObjectReference) { + OtherObjectReference = other.OtherObjectReference; + } + 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 17: { + Timestamp = input.ReadFixed64(); + break; + } + case 26: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddThisPosition(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddOtherPosition(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 42: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddThisNormal(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 50: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddImpulse(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 58: { + OtherObjectReference = input.ReadBytes(); + break; + } + } + } + } + + + public bool HasTimestamp { + get { return result.HasTimestamp; } + } + [global::System.CLSCompliant(false)] + public ulong Timestamp { + get { return result.Timestamp; } + set { SetTimestamp(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetTimestamp(ulong value) { + result.hasTimestamp = true; + result.timestamp_ = value; + return this; + } + public Builder ClearTimestamp() { + result.hasTimestamp = false; + result.timestamp_ = 0; + return this; + } + + public pbc::IPopsicleList ThisPositionList { + get { return result.thisPosition_; } + } + public int ThisPositionCount { + get { return result.ThisPositionCount; } + } + public double GetThisPosition(int index) { + return result.GetThisPosition(index); + } + public Builder SetThisPosition(int index, double value) { + result.thisPosition_[index] = value; + return this; + } + public Builder AddThisPosition(double value) { + result.thisPosition_.Add(value); + return this; + } + public Builder AddRangeThisPosition(scg::IEnumerable values) { + base.AddRange(values, result.thisPosition_); + return this; + } + public Builder ClearThisPosition() { + result.thisPosition_.Clear(); + return this; + } + + public pbc::IPopsicleList OtherPositionList { + get { return result.otherPosition_; } + } + public int OtherPositionCount { + get { return result.OtherPositionCount; } + } + public double GetOtherPosition(int index) { + return result.GetOtherPosition(index); + } + public Builder SetOtherPosition(int index, double value) { + result.otherPosition_[index] = value; + return this; + } + public Builder AddOtherPosition(double value) { + result.otherPosition_.Add(value); + return this; + } + public Builder AddRangeOtherPosition(scg::IEnumerable values) { + base.AddRange(values, result.otherPosition_); + return this; + } + public Builder ClearOtherPosition() { + result.otherPosition_.Clear(); + return this; + } + + public pbc::IPopsicleList ThisNormalList { + get { return result.thisNormal_; } + } + public int ThisNormalCount { + get { return result.ThisNormalCount; } + } + public float GetThisNormal(int index) { + return result.GetThisNormal(index); + } + public Builder SetThisNormal(int index, float value) { + result.thisNormal_[index] = value; + return this; + } + public Builder AddThisNormal(float value) { + result.thisNormal_.Add(value); + return this; + } + public Builder AddRangeThisNormal(scg::IEnumerable values) { + base.AddRange(values, result.thisNormal_); + return this; + } + public Builder ClearThisNormal() { + result.thisNormal_.Clear(); + return this; + } + + public pbc::IPopsicleList ImpulseList { + get { return result.impulse_; } + } + public int ImpulseCount { + get { return result.ImpulseCount; } + } + public float GetImpulse(int index) { + return result.GetImpulse(index); + } + public Builder SetImpulse(int index, float value) { + result.impulse_[index] = value; + return this; + } + public Builder AddImpulse(float value) { + result.impulse_.Add(value); + return this; + } + public Builder AddRangeImpulse(scg::IEnumerable values) { + base.AddRange(values, result.impulse_); + return this; + } + public Builder ClearImpulse() { + result.impulse_.Clear(); + return this; + } + + public bool HasOtherObjectReference { + get { return result.HasOtherObjectReference; } + } + public pb::ByteString OtherObjectReference { + get { return result.OtherObjectReference; } + set { SetOtherObjectReference(value); } + } + public Builder SetOtherObjectReference(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasOtherObjectReference = true; + result.otherObjectReference_ = value; + return this; + } + public Builder ClearOtherObjectReference() { + result.hasOtherObjectReference = false; + result.otherObjectReference_ = pb::ByteString.Empty; + return this; + } + } + static CollisionBegin() { + object.ReferenceEquals(global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.Descriptor, null); + } + } + + public sealed partial class CollisionEnd : pb::GeneratedMessage { + private static readonly CollisionEnd defaultInstance = new Builder().BuildPartial(); + public static CollisionEnd DefaultInstance { + get { return defaultInstance; } + } + + public override CollisionEnd DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CollisionEnd ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__FieldAccessorTable; } + } + + public const int TimestampFieldNumber = 2; + private bool hasTimestamp; + private ulong timestamp_ = 0; + public bool HasTimestamp { + get { return hasTimestamp; } + } + [global::System.CLSCompliant(false)] + public ulong Timestamp { + get { return timestamp_; } + } + + public const int OtherObjectReferenceFieldNumber = 6; + private bool hasOtherObjectReference; + private pb::ByteString otherObjectReference_ = pb::ByteString.Empty; + public bool HasOtherObjectReference { + get { return hasOtherObjectReference; } + } + public pb::ByteString OtherObjectReference { + get { return otherObjectReference_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasTimestamp) { + output.WriteFixed64(2, Timestamp); + } + if (HasOtherObjectReference) { + output.WriteBytes(6, OtherObjectReference); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasTimestamp) { + size += pb::CodedOutputStream.ComputeFixed64Size(2, Timestamp); + } + if (HasOtherObjectReference) { + size += pb::CodedOutputStream.ComputeBytesSize(6, OtherObjectReference); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static CollisionEnd ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CollisionEnd ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CollisionEnd ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CollisionEnd ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CollisionEnd ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CollisionEnd ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CollisionEnd ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static CollisionEnd ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static CollisionEnd ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CollisionEnd 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(CollisionEnd prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CollisionEnd result = new CollisionEnd(); + + protected override CollisionEnd MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CollisionEnd(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.Descriptor; } + } + + public override CollisionEnd DefaultInstanceForType { + get { return global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.DefaultInstance; } + } + + public override CollisionEnd BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + CollisionEnd returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is CollisionEnd) { + return MergeFrom((CollisionEnd) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(CollisionEnd other) { + if (other == global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.DefaultInstance) return this; + if (other.HasTimestamp) { + Timestamp = other.Timestamp; + } + if (other.HasOtherObjectReference) { + OtherObjectReference = other.OtherObjectReference; + } + 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 17: { + Timestamp = input.ReadFixed64(); + break; + } + case 50: { + OtherObjectReference = input.ReadBytes(); + break; + } + } + } + } + + + public bool HasTimestamp { + get { return result.HasTimestamp; } + } + [global::System.CLSCompliant(false)] + public ulong Timestamp { + get { return result.Timestamp; } + set { SetTimestamp(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetTimestamp(ulong value) { + result.hasTimestamp = true; + result.timestamp_ = value; + return this; + } + public Builder ClearTimestamp() { + result.hasTimestamp = false; + result.timestamp_ = 0; + return this; + } + + public bool HasOtherObjectReference { + get { return result.HasOtherObjectReference; } + } + public pb::ByteString OtherObjectReference { + get { return result.OtherObjectReference; } + set { SetOtherObjectReference(value); } + } + public Builder SetOtherObjectReference(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasOtherObjectReference = true; + result.otherObjectReference_ = value; + return this; + } + public Builder ClearOtherObjectReference() { + result.hasOtherObjectReference = false; + result.otherObjectReference_ = pb::ByteString.Empty; + return this; + } + } + static CollisionEnd() { + object.ReferenceEquals(global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.Descriptor, null); + } + } + + #endregion + +} diff --git a/OpenSim/Client/Sirikata/Protocol/Physics.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Physics.pbj.cs new file mode 100644 index 0000000..decd204 --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Physics.pbj.cs @@ -0,0 +1,394 @@ +using pbd = global::Google.ProtocolBuffers.Descriptors; +using pb = global::Google.ProtocolBuffers; +namespace Sirikata.Physics.Protocol { + public class CollisionBegin : PBJ.IMessage { + protected _PBJ_Internal.CollisionBegin super; + public _PBJ_Internal.CollisionBegin _PBJSuper{ get { return super;} } + public CollisionBegin() { + super=new _PBJ_Internal.CollisionBegin(); + } + public CollisionBegin(_PBJ_Internal.CollisionBegin reference) { + super=reference; + } + public static CollisionBegin defaultInstance= new CollisionBegin (_PBJ_Internal.CollisionBegin.DefaultInstance); + public static CollisionBegin DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.CollisionBegin.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int TimestampFieldTag=2; + public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} } + public PBJ.Time Timestamp{ get { + if (HasTimestamp) { + return PBJ._PBJ.CastTime(super.Timestamp); + } else { + return PBJ._PBJ.CastTime(); + } + } + } + public const int ThisPositionFieldTag=3; + public int ThisPositionCount { get { return super.ThisPositionCount/3;} } + public bool HasThisPosition(int index) { return true; } + public PBJ.Vector3d GetThisPosition(int index) { + if (HasThisPosition(index)) { + return PBJ._PBJ.CastVector3d(super.GetThisPosition(index*3+0),super.GetThisPosition(index*3+1),super.GetThisPosition(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + public const int OtherPositionFieldTag=4; + public int OtherPositionCount { get { return super.OtherPositionCount/3;} } + public bool HasOtherPosition(int index) { return true; } + public PBJ.Vector3d GetOtherPosition(int index) { + if (HasOtherPosition(index)) { + return PBJ._PBJ.CastVector3d(super.GetOtherPosition(index*3+0),super.GetOtherPosition(index*3+1),super.GetOtherPosition(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + public const int ThisNormalFieldTag=5; + public int ThisNormalCount { get { return super.ThisNormalCount/2;} } + public bool HasThisNormal(int index) { return true; } + public PBJ.Vector3f GetThisNormal(int index) { + if (HasThisNormal(index)) { + return PBJ._PBJ.CastNormal(super.GetThisNormal(index*2+0),super.GetThisNormal(index*2+1)); + } else { + return PBJ._PBJ.CastNormal(); + } + } + public const int ImpulseFieldTag=6; + public int ImpulseCount { get { return super.ImpulseCount;} } + public bool HasImpulse(int index) {return PBJ._PBJ.ValidateFloat(super.GetImpulse(index));} + public float Impulse(int index) { + return (float)PBJ._PBJ.CastFloat(super.GetImpulse(index)); + } + public const int OtherObjectReferenceFieldTag=7; + public bool HasOtherObjectReference{ get {return super.HasOtherObjectReference&&PBJ._PBJ.ValidateUuid(super.OtherObjectReference);} } + public PBJ.UUID OtherObjectReference{ get { + if (HasOtherObjectReference) { + return PBJ._PBJ.CastUuid(super.OtherObjectReference); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(CollisionBegin prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static CollisionBegin ParseFrom(pb::ByteString data) { + return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data)); + } + public static CollisionBegin ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data,er)); + } + public static CollisionBegin ParseFrom(byte[] data) { + return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data)); + } + public static CollisionBegin ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data,er)); + } + public static CollisionBegin ParseFrom(global::System.IO.Stream data) { + return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data)); + } + public static CollisionBegin ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data,er)); + } + public static CollisionBegin ParseFrom(pb::CodedInputStream data) { + return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data)); + } + public static CollisionBegin ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.CollisionBegin.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.CollisionBegin.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.CollisionBegin.Builder();} + public Builder(_PBJ_Internal.CollisionBegin.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(CollisionBegin prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public CollisionBegin BuildPartial() {return new CollisionBegin(super.BuildPartial());} + public CollisionBegin Build() {if (_HasAllPBJFields) return new CollisionBegin(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return CollisionBegin.Descriptor; } } + public Builder ClearTimestamp() { super.ClearTimestamp();return this;} + public const int TimestampFieldTag=2; + public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} } + public PBJ.Time Timestamp{ get { + if (HasTimestamp) { + return PBJ._PBJ.CastTime(super.Timestamp); + } else { + return PBJ._PBJ.CastTime(); + } + } + set { + super.Timestamp=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearThisPosition() { super.ClearThisPosition();return this;} + public const int ThisPositionFieldTag=3; + public int ThisPositionCount { get { return super.ThisPositionCount/3;} } + public bool HasThisPosition(int index) { return true; } + public PBJ.Vector3d GetThisPosition(int index) { + if (HasThisPosition(index)) { + return PBJ._PBJ.CastVector3d(super.GetThisPosition(index*3+0),super.GetThisPosition(index*3+1),super.GetThisPosition(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + public Builder AddThisPosition(PBJ.Vector3d value) { + double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); + super.AddThisPosition(_PBJtempArray[0]); + super.AddThisPosition(_PBJtempArray[1]); + super.AddThisPosition(_PBJtempArray[2]); + return this; + } + public Builder SetThisPosition(int index,PBJ.Vector3d value) { + double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); + super.SetThisPosition(index*3+0,_PBJtempArray[0]); + super.SetThisPosition(index*3+1,_PBJtempArray[1]); + super.SetThisPosition(index*3+2,_PBJtempArray[2]); + return this; + } + public Builder ClearOtherPosition() { super.ClearOtherPosition();return this;} + public const int OtherPositionFieldTag=4; + public int OtherPositionCount { get { return super.OtherPositionCount/3;} } + public bool HasOtherPosition(int index) { return true; } + public PBJ.Vector3d GetOtherPosition(int index) { + if (HasOtherPosition(index)) { + return PBJ._PBJ.CastVector3d(super.GetOtherPosition(index*3+0),super.GetOtherPosition(index*3+1),super.GetOtherPosition(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + public Builder AddOtherPosition(PBJ.Vector3d value) { + double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); + super.AddOtherPosition(_PBJtempArray[0]); + super.AddOtherPosition(_PBJtempArray[1]); + super.AddOtherPosition(_PBJtempArray[2]); + return this; + } + public Builder SetOtherPosition(int index,PBJ.Vector3d value) { + double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); + super.SetOtherPosition(index*3+0,_PBJtempArray[0]); + super.SetOtherPosition(index*3+1,_PBJtempArray[1]); + super.SetOtherPosition(index*3+2,_PBJtempArray[2]); + return this; + } + public Builder ClearThisNormal() { super.ClearThisNormal();return this;} + public const int ThisNormalFieldTag=5; + public int ThisNormalCount { get { return super.ThisNormalCount/2;} } + public bool HasThisNormal(int index) { return true; } + public PBJ.Vector3f GetThisNormal(int index) { + if (HasThisNormal(index)) { + return PBJ._PBJ.CastNormal(super.GetThisNormal(index*2+0),super.GetThisNormal(index*2+1)); + } else { + return PBJ._PBJ.CastNormal(); + } + } + public Builder AddThisNormal(PBJ.Vector3f value) { + float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); + super.AddThisNormal(_PBJtempArray[0]); + super.AddThisNormal(_PBJtempArray[1]); + return this; + } + public Builder SetThisNormal(int index,PBJ.Vector3f value) { + float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); + super.SetThisNormal(index*2+0,_PBJtempArray[0]); + super.SetThisNormal(index*2+1,_PBJtempArray[1]); + return this; + } + public Builder ClearImpulse() { super.ClearImpulse();return this;} + public Builder SetImpulse(int index, float value) { + super.SetImpulse(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int ImpulseFieldTag=6; + public int ImpulseCount { get { return super.ImpulseCount;} } + public bool HasImpulse(int index) {return PBJ._PBJ.ValidateFloat(super.GetImpulse(index));} + public float Impulse(int index) { + return (float)PBJ._PBJ.CastFloat(super.GetImpulse(index)); + } + public Builder AddImpulse(float value) { + super.AddImpulse(PBJ._PBJ.Construct(value)); + return this; + } + public Builder ClearOtherObjectReference() { super.ClearOtherObjectReference();return this;} + public const int OtherObjectReferenceFieldTag=7; + public bool HasOtherObjectReference{ get {return super.HasOtherObjectReference&&PBJ._PBJ.ValidateUuid(super.OtherObjectReference);} } + public PBJ.UUID OtherObjectReference{ get { + if (HasOtherObjectReference) { + return PBJ._PBJ.CastUuid(super.OtherObjectReference); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.OtherObjectReference=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Physics.Protocol { + public class CollisionEnd : PBJ.IMessage { + protected _PBJ_Internal.CollisionEnd super; + public _PBJ_Internal.CollisionEnd _PBJSuper{ get { return super;} } + public CollisionEnd() { + super=new _PBJ_Internal.CollisionEnd(); + } + public CollisionEnd(_PBJ_Internal.CollisionEnd reference) { + super=reference; + } + public static CollisionEnd defaultInstance= new CollisionEnd (_PBJ_Internal.CollisionEnd.DefaultInstance); + public static CollisionEnd DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.CollisionEnd.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int TimestampFieldTag=2; + public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} } + public PBJ.Time Timestamp{ get { + if (HasTimestamp) { + return PBJ._PBJ.CastTime(super.Timestamp); + } else { + return PBJ._PBJ.CastTime(); + } + } + } + public const int OtherObjectReferenceFieldTag=6; + public bool HasOtherObjectReference{ get {return super.HasOtherObjectReference&&PBJ._PBJ.ValidateUuid(super.OtherObjectReference);} } + public PBJ.UUID OtherObjectReference{ get { + if (HasOtherObjectReference) { + return PBJ._PBJ.CastUuid(super.OtherObjectReference); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(CollisionEnd prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static CollisionEnd ParseFrom(pb::ByteString data) { + return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data)); + } + public static CollisionEnd ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data,er)); + } + public static CollisionEnd ParseFrom(byte[] data) { + return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data)); + } + public static CollisionEnd ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data,er)); + } + public static CollisionEnd ParseFrom(global::System.IO.Stream data) { + return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data)); + } + public static CollisionEnd ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data,er)); + } + public static CollisionEnd ParseFrom(pb::CodedInputStream data) { + return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data)); + } + public static CollisionEnd ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.CollisionEnd.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.CollisionEnd.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.CollisionEnd.Builder();} + public Builder(_PBJ_Internal.CollisionEnd.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(CollisionEnd prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public CollisionEnd BuildPartial() {return new CollisionEnd(super.BuildPartial());} + public CollisionEnd Build() {if (_HasAllPBJFields) return new CollisionEnd(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return CollisionEnd.Descriptor; } } + public Builder ClearTimestamp() { super.ClearTimestamp();return this;} + public const int TimestampFieldTag=2; + public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} } + public PBJ.Time Timestamp{ get { + if (HasTimestamp) { + return PBJ._PBJ.CastTime(super.Timestamp); + } else { + return PBJ._PBJ.CastTime(); + } + } + set { + super.Timestamp=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearOtherObjectReference() { super.ClearOtherObjectReference();return this;} + public const int OtherObjectReferenceFieldTag=6; + public bool HasOtherObjectReference{ get {return super.HasOtherObjectReference&&PBJ._PBJ.ValidateUuid(super.OtherObjectReference);} } + public PBJ.UUID OtherObjectReference{ get { + if (HasOtherObjectReference) { + return PBJ._PBJ.CastUuid(super.OtherObjectReference); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.OtherObjectReference=(PBJ._PBJ.Construct(value)); + } + } + } + } +} diff --git a/OpenSim/Client/Sirikata/Protocol/Sirikata.cs b/OpenSim/Client/Sirikata/Protocol/Sirikata.cs new file mode 100644 index 0000000..9283086 --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Sirikata.cs @@ -0,0 +1,8074 @@ +// 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 Sirikata { + + #region Extension registration + public static void RegisterAllExtensions(pb::ExtensionRegistry registry) { + } + #endregion + #region Static variables + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__FieldAccessorTable; + #endregion + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbd::FileDescriptor descriptor; + + static Sirikata() { + byte[] descriptorData = global::System.Convert.FromBase64String( + "Cg5TaXJpa2F0YS5wcm90bxIfU2lyaWthdGEuUHJvdG9jb2wuX1BCSl9JbnRl" + + "cm5hbCI/CgtNZXNzYWdlQm9keRIVCg1tZXNzYWdlX25hbWVzGAkgAygJEhkK" + + "EW1lc3NhZ2VfYXJndW1lbnRzGAogAygMIroDCg9SZWFkT25seU1lc3NhZ2US" + + "FQoNc291cmNlX29iamVjdBgBIAEoDBITCgtzb3VyY2VfcG9ydBgDIAEoDRIV" + + "Cgxzb3VyY2Vfc3BhY2UYgAwgASgMEhoKEmRlc3RpbmF0aW9uX29iamVjdBgC" + + "IAEoDBIYChBkZXN0aW5hdGlvbl9wb3J0GAQgASgNEhoKEWRlc3RpbmF0aW9u" + + "X3NwYWNlGIEMIAEoDBIKCgJpZBgHIAEoAxIQCghyZXBseV9pZBgIIAEoAxJV" + + "Cg1yZXR1cm5fc3RhdHVzGIAOIAEoDjI9LlNpcmlrYXRhLlByb3RvY29sLl9Q" + + "QkpfSW50ZXJuYWwuUmVhZE9ubHlNZXNzYWdlLlJldHVyblN0YXR1cxIVCg1t" + + "ZXNzYWdlX25hbWVzGAkgAygJEhkKEW1lc3NhZ2VfYXJndW1lbnRzGAogAygM" + + "ImsKDFJldHVyblN0YXR1cxILCgdTVUNDRVNTEAASEwoPTkVUV09SS19GQUlM" + + "VVJFEAESEwoPVElNRU9VVF9GQUlMVVJFEAMSEgoOUFJPVE9DT0xfRVJST1IQ" + + "BBIQCgxQT1JUX0ZBSUxVUkUQBSLOAQoNU3BhY2VTZXJ2aWNlcxIZChFyZWdp" + + "c3RyYXRpb25fcG9ydBghIAEoDRIQCghsb2NfcG9ydBgiIAEoDRIRCglnZW9t" + + "X3BvcnQYIyABKA0SEQoJb3NlZ19wb3J0GCQgASgNEhEKCWNzZWdfcG9ydBgl" + + "IAEoDRITCgtyb3V0ZXJfcG9ydBgmIAEoDRIdChVwcmVfY29ubmVjdGlvbl9i" + + "dWZmZXIYQCABKAQSIwobbWF4X3ByZV9jb25uZWN0aW9uX21lc3NhZ2VzGEEg" + + "ASgEIsQBCgZPYmpMb2MSEQoJdGltZXN0YW1wGAIgASgGEhQKCHBvc2l0aW9u" + + "GAMgAygBQgIQARIXCgtvcmllbnRhdGlvbhgEIAMoAkICEAESFAoIdmVsb2Np" + + "dHkYBSADKAJCAhABEhsKD3JvdGF0aW9uYWxfYXhpcxgHIAMoAkICEAESFQoN" + + "YW5ndWxhcl9zcGVlZBgIIAEoAhIUCgx1cGRhdGVfZmxhZ3MYBiABKA0iGAoL" + + "VXBkYXRlRmxhZ3MSCQoFRk9SQ0UQASKFAQoKTG9jUmVxdWVzdBIYChByZXF1" + + "ZXN0ZWRfZmllbGRzGAIgASgNIl0KBkZpZWxkcxIMCghQT1NJVElPThABEg8K" + + "C09SSUVOVEFUSU9OEAISDAoIVkVMT0NJVFkQBBITCg9ST1RBVElPTkFMX0FY" + + "SVMQCBIRCg1BTkdVTEFSX1NQRUVEEBAiigEKBk5ld09iahIcChRvYmplY3Rf" + + "dXVpZF9ldmlkZW5jZRgCIAEoDBJFChRyZXF1ZXN0ZWRfb2JqZWN0X2xvYxgD" + + "IAEoCzInLlNpcmlrYXRhLlByb3RvY29sLl9QQkpfSW50ZXJuYWwuT2JqTG9j" + + "EhsKD2JvdW5kaW5nX3NwaGVyZRgEIAMoAkICEAEiegoGUmV0T2JqEhgKEG9i" + + "amVjdF9yZWZlcmVuY2UYAiABKAwSOQoIbG9jYXRpb24YAyABKAsyJy5TaXJp" + + "a2F0YS5Qcm90b2NvbC5fUEJKX0ludGVybmFsLk9iakxvYxIbCg9ib3VuZGlu" + + "Z19zcGhlcmUYBCADKAJCAhABIiIKBkRlbE9iahIYChBvYmplY3RfcmVmZXJl" + + "bmNlGAIgASgMIpoBCgxOZXdQcm94UXVlcnkSEAoIcXVlcnlfaWQYAiABKA0S" + + "EQoJc3RhdGVsZXNzGAMgASgIEhsKD3JlbGF0aXZlX2NlbnRlchgEIAMoAkIC" + + "EAESGwoPYWJzb2x1dGVfY2VudGVyGAUgAygBQgIQARISCgptYXhfcmFkaXVz" + + "GAYgASgCEhcKD21pbl9zb2xpZF9hbmdsZRgHIAEoAiLhAQoIUHJveENhbGwS" + + "EAoIcXVlcnlfaWQYAiACKA0SGAoQcHJveGltYXRlX29iamVjdBgDIAIoDBJR" + + "Cg9wcm94aW1pdHlfZXZlbnQYBCACKA4yOC5TaXJpa2F0YS5Qcm90b2NvbC5f" + + "UEJKX0ludGVybmFsLlByb3hDYWxsLlByb3hpbWl0eUV2ZW50IlYKDlByb3hp" + + "bWl0eUV2ZW50EhQKEEVYSVRFRF9QUk9YSU1JVFkQABIVChFFTlRFUkVEX1BS" + + "T1hJTUlUWRABEhcKE1NUQVRFTEVTU19QUk9YSU1JVFkQAiIgCgxEZWxQcm94" + + "UXVlcnkSEAoIcXVlcnlfaWQYAiABKA0iJQoQVmVjdG9yM2ZQcm9wZXJ0eRIR" + + "CgV2YWx1ZRgKIAMoAkICEAEiHwoOU3RyaW5nUHJvcGVydHkSDQoFdmFsdWUY" + + "CiABKAkiMQoRU3RyaW5nTWFwUHJvcGVydHkSDAoEa2V5cxgCIAMoCRIOCgZ2" + + "YWx1ZXMYAyADKAkiyQIKElBoeXNpY2FsUGFyYW1ldGVycxJGCgRtb2RlGAIg" + + "ASgOMjguU2lyaWthdGEuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5QaHlzaWNh" + + "bFBhcmFtZXRlcnMuTW9kZRIPCgdkZW5zaXR5GAMgASgCEhAKCGZyaWN0aW9u" + + "GAQgASgCEg4KBmJvdW5jZRgFIAEoAhIQCgRodWxsGAYgAygCQgIQARITCgtj" + + "b2xsaWRlX21zZxgQIAEoDRIUCgxjb2xsaWRlX21hc2sYESABKA0SDwoHZ3Jh" + + "dml0eRgSIAEoAiJqCgRNb2RlEg8KC05PTlBIWVNJQ0FMEAASCgoGU1RBVElD" + + "EAESDgoKRFlOQU1JQ0JPWBACEhEKDURZTkFNSUNTUEhFUkUQAxITCg9EWU5B" + + "TUlDQ1lMSU5ERVIQBBINCglDSEFSQUNURVIQBSLaAwoRTGlnaHRJbmZvUHJv" + + "cGVydHkSGQoNZGlmZnVzZV9jb2xvchgDIAMoAkICEAESGgoOc3BlY3VsYXJf" + + "Y29sb3IYBCADKAJCAhABEg0KBXBvd2VyGAUgASgCEhkKDWFtYmllbnRfY29s" + + "b3IYBiADKAJCAhABEhgKDHNoYWRvd19jb2xvchgHIAMoAkICEAESEwoLbGln" + + "aHRfcmFuZ2UYCCABKAESGAoQY29uc3RhbnRfZmFsbG9mZhgJIAEoAhIWCg5s" + + "aW5lYXJfZmFsbG9mZhgKIAEoAhIZChFxdWFkcmF0aWNfZmFsbG9mZhgLIAEo" + + "AhIaChJjb25lX2lubmVyX3JhZGlhbnMYDCABKAISGgoSY29uZV9vdXRlcl9y" + + "YWRpYW5zGA0gASgCEhQKDGNvbmVfZmFsbG9mZhgOIAEoAhJLCgR0eXBlGA8g" + + "ASgOMj0uU2lyaWthdGEuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5MaWdodElu" + + "Zm9Qcm9wZXJ0eS5MaWdodFR5cGVzEhQKDGNhc3RzX3NoYWRvdxgQIAEoCCI3" + + "CgpMaWdodFR5cGVzEgkKBVBPSU5UEAASDQoJU1BPVExJR0hUEAESDwoLRElS" + + "RUNUSU9OQUwQAiIfCg5QYXJlbnRQcm9wZXJ0eRINCgV2YWx1ZRgKIAEoDCIh" + + "ChBVVUlETGlzdFByb3BlcnR5Eg0KBXZhbHVlGAogAygMIqQBCg5Db25uZWN0" + + "VG9TcGFjZRIQCghzcGFjZV9pZBgBIAEoDBIcChRvYmplY3RfdXVpZF9ldmlk" + + "ZW5jZRgCIAEoDBJFChRyZXF1ZXN0ZWRfb2JqZWN0X2xvYxgDIAEoCzInLlNp" + + "cmlrYXRhLlByb3RvY29sLl9QQkpfSW50ZXJuYWwuT2JqTG9jEhsKD2JvdW5k" + + "aW5nX3NwaGVyZRgEIAMoAkICEAEivgIKDENyZWF0ZU9iamVjdBITCgtvYmpl" + + "Y3RfdXVpZBgBIAEoDBJJChBzcGFjZV9wcm9wZXJ0aWVzGAIgAygLMi8uU2ly" + + "aWthdGEuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5Db25uZWN0VG9TcGFjZRIM" + + "CgRtZXNoGAMgASgJEhEKBXNjYWxlGAQgAygCQgIQARIOCgZ3ZWJ1cmwYBSAB" + + "KAkSRgoKbGlnaHRfaW5mbxgGIAEoCzIyLlNpcmlrYXRhLlByb3RvY29sLl9Q" + + "QkpfSW50ZXJuYWwuTGlnaHRJbmZvUHJvcGVydHkSDgoGY2FtZXJhGAcgASgI" + + "EkUKCHBoeXNpY2FsGAggASgLMjMuU2lyaWthdGEuUHJvdG9jb2wuX1BCSl9J" + + "bnRlcm5hbC5QaHlzaWNhbFBhcmFtZXRlcnM="); + pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { + descriptor = root; + internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__Descriptor = Descriptor.MessageTypes[0]; + internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__Descriptor, + new string[] { "MessageNames", "MessageArguments", }); + internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__Descriptor = Descriptor.MessageTypes[1]; + internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__Descriptor, + new string[] { "SourceObject", "SourcePort", "SourceSpace", "DestinationObject", "DestinationPort", "DestinationSpace", "Id", "ReplyId", "ReturnStatus", "MessageNames", "MessageArguments", }); + internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__Descriptor = Descriptor.MessageTypes[2]; + internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__Descriptor, + new string[] { "RegistrationPort", "LocPort", "GeomPort", "OsegPort", "CsegPort", "RouterPort", "PreConnectionBuffer", "MaxPreConnectionMessages", }); + internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__Descriptor = Descriptor.MessageTypes[3]; + internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__Descriptor, + new string[] { "Timestamp", "Position", "Orientation", "Velocity", "RotationalAxis", "AngularSpeed", "UpdateFlags", }); + internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__Descriptor = Descriptor.MessageTypes[4]; + internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__Descriptor, + new string[] { "RequestedFields", }); + internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__Descriptor = Descriptor.MessageTypes[5]; + internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__Descriptor, + new string[] { "ObjectUuidEvidence", "RequestedObjectLoc", "BoundingSphere", }); + internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__Descriptor = Descriptor.MessageTypes[6]; + internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__Descriptor, + new string[] { "ObjectReference", "Location", "BoundingSphere", }); + internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__Descriptor = Descriptor.MessageTypes[7]; + internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__Descriptor, + new string[] { "ObjectReference", }); + internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__Descriptor = Descriptor.MessageTypes[8]; + internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__Descriptor, + new string[] { "QueryId", "Stateless", "RelativeCenter", "AbsoluteCenter", "MaxRadius", "MinSolidAngle", }); + internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__Descriptor = Descriptor.MessageTypes[9]; + internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__Descriptor, + new string[] { "QueryId", "ProximateObject", "ProximityEvent", }); + internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__Descriptor = Descriptor.MessageTypes[10]; + internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__Descriptor, + new string[] { "QueryId", }); + internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__Descriptor = Descriptor.MessageTypes[11]; + internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__Descriptor, + new string[] { "Value", }); + internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__Descriptor = Descriptor.MessageTypes[12]; + internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__Descriptor, + new string[] { "Value", }); + internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__Descriptor = Descriptor.MessageTypes[13]; + internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__Descriptor, + new string[] { "Keys", "Values", }); + internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__Descriptor = Descriptor.MessageTypes[14]; + internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__Descriptor, + new string[] { "Mode", "Density", "Friction", "Bounce", "Hull", "CollideMsg", "CollideMask", "Gravity", }); + internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__Descriptor = Descriptor.MessageTypes[15]; + internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__Descriptor, + new string[] { "DiffuseColor", "SpecularColor", "Power", "AmbientColor", "ShadowColor", "LightRange", "ConstantFalloff", "LinearFalloff", "QuadraticFalloff", "ConeInnerRadians", "ConeOuterRadians", "ConeFalloff", "Type", "CastsShadow", }); + internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__Descriptor = Descriptor.MessageTypes[16]; + internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__Descriptor, + new string[] { "Value", }); + internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__Descriptor = Descriptor.MessageTypes[17]; + internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__Descriptor, + new string[] { "Value", }); + internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__Descriptor = Descriptor.MessageTypes[18]; + internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__Descriptor, + new string[] { "SpaceId", "ObjectUuidEvidence", "RequestedObjectLoc", "BoundingSphere", }); + internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__Descriptor = Descriptor.MessageTypes[19]; + internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__Descriptor, + new string[] { "ObjectUuid", "SpaceProperties", "Mesh", "Scale", "Weburl", "LightInfo", "Camera", "Physical", }); + return null; + }; + pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, + new pbd::FileDescriptor[] { + }, assigner); + } + #endregion + + } + #region Messages + public sealed partial class MessageBody : pb::GeneratedMessage { + private static readonly MessageBody defaultInstance = new Builder().BuildPartial(); + public static MessageBody DefaultInstance { + get { return defaultInstance; } + } + + public override MessageBody DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override MessageBody ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__FieldAccessorTable; } + } + + public const int MessageNamesFieldNumber = 9; + private pbc::PopsicleList messageNames_ = new pbc::PopsicleList(); + public scg::IList MessageNamesList { + get { return pbc::Lists.AsReadOnly(messageNames_); } + } + public int MessageNamesCount { + get { return messageNames_.Count; } + } + public string GetMessageNames(int index) { + return messageNames_[index]; + } + + public const int MessageArgumentsFieldNumber = 10; + private pbc::PopsicleList messageArguments_ = new pbc::PopsicleList(); + public scg::IList MessageArgumentsList { + get { return pbc::Lists.AsReadOnly(messageArguments_); } + } + public int MessageArgumentsCount { + get { return messageArguments_.Count; } + } + public pb::ByteString GetMessageArguments(int index) { + return messageArguments_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (messageNames_.Count > 0) { + foreach (string element in messageNames_) { + output.WriteString(9, element); + } + } + if (messageArguments_.Count > 0) { + foreach (pb::ByteString element in messageArguments_) { + output.WriteBytes(10, element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + foreach (string element in MessageNamesList) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 1 * messageNames_.Count; + } + { + int dataSize = 0; + foreach (pb::ByteString element in MessageArgumentsList) { + dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); + } + size += dataSize; + size += 1 * messageArguments_.Count; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static MessageBody ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static MessageBody ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static MessageBody ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static MessageBody ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static MessageBody ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static MessageBody ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static MessageBody ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static MessageBody ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static MessageBody ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static MessageBody 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(MessageBody prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + MessageBody result = new MessageBody(); + + protected override MessageBody MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new MessageBody(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.MessageBody.Descriptor; } + } + + public override MessageBody DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.MessageBody.DefaultInstance; } + } + + public override MessageBody BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.messageNames_.MakeReadOnly(); + result.messageArguments_.MakeReadOnly(); + MessageBody returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is MessageBody) { + return MergeFrom((MessageBody) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(MessageBody other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.MessageBody.DefaultInstance) return this; + if (other.messageNames_.Count != 0) { + base.AddRange(other.messageNames_, result.messageNames_); + } + if (other.messageArguments_.Count != 0) { + base.AddRange(other.messageArguments_, result.messageArguments_); + } + 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 74: { + AddMessageNames(input.ReadString()); + break; + } + case 82: { + AddMessageArguments(input.ReadBytes()); + break; + } + } + } + } + + + public pbc::IPopsicleList MessageNamesList { + get { return result.messageNames_; } + } + public int MessageNamesCount { + get { return result.MessageNamesCount; } + } + public string GetMessageNames(int index) { + return result.GetMessageNames(index); + } + public Builder SetMessageNames(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageNames_[index] = value; + return this; + } + public Builder AddMessageNames(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageNames_.Add(value); + return this; + } + public Builder AddRangeMessageNames(scg::IEnumerable values) { + base.AddRange(values, result.messageNames_); + return this; + } + public Builder ClearMessageNames() { + result.messageNames_.Clear(); + return this; + } + + public pbc::IPopsicleList MessageArgumentsList { + get { return result.messageArguments_; } + } + public int MessageArgumentsCount { + get { return result.MessageArgumentsCount; } + } + public pb::ByteString GetMessageArguments(int index) { + return result.GetMessageArguments(index); + } + public Builder SetMessageArguments(int index, pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageArguments_[index] = value; + return this; + } + public Builder AddMessageArguments(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageArguments_.Add(value); + return this; + } + public Builder AddRangeMessageArguments(scg::IEnumerable values) { + base.AddRange(values, result.messageArguments_); + return this; + } + public Builder ClearMessageArguments() { + result.messageArguments_.Clear(); + return this; + } + } + static MessageBody() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class ReadOnlyMessage : pb::GeneratedMessage { + private static readonly ReadOnlyMessage defaultInstance = new Builder().BuildPartial(); + public static ReadOnlyMessage DefaultInstance { + get { return defaultInstance; } + } + + public override ReadOnlyMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ReadOnlyMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__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, + } + + } + #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.ReadOnlyMessage.Types.ReturnStatus returnStatus_ = global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.SUCCESS; + public bool HasReturnStatus { + get { return hasReturnStatus; } + } + public global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus ReturnStatus { + get { return returnStatus_; } + } + + public const int MessageNamesFieldNumber = 9; + private pbc::PopsicleList messageNames_ = new pbc::PopsicleList(); + public scg::IList MessageNamesList { + get { return pbc::Lists.AsReadOnly(messageNames_); } + } + public int MessageNamesCount { + get { return messageNames_.Count; } + } + public string GetMessageNames(int index) { + return messageNames_[index]; + } + + public const int MessageArgumentsFieldNumber = 10; + private pbc::PopsicleList messageArguments_ = new pbc::PopsicleList(); + public scg::IList MessageArgumentsList { + get { return pbc::Lists.AsReadOnly(messageArguments_); } + } + public int MessageArgumentsCount { + get { return messageArguments_.Count; } + } + public pb::ByteString GetMessageArguments(int index) { + return messageArguments_[index]; + } + + 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 (messageNames_.Count > 0) { + foreach (string element in messageNames_) { + output.WriteString(9, element); + } + } + if (messageArguments_.Count > 0) { + foreach (pb::ByteString element in messageArguments_) { + output.WriteBytes(10, element); + } + } + 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); + } + { + int dataSize = 0; + foreach (string element in MessageNamesList) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 1 * messageNames_.Count; + } + { + int dataSize = 0; + foreach (pb::ByteString element in MessageArgumentsList) { + dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); + } + size += dataSize; + size += 1 * messageArguments_.Count; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ReadOnlyMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ReadOnlyMessage ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ReadOnlyMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ReadOnlyMessage 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(ReadOnlyMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ReadOnlyMessage result = new ReadOnlyMessage(); + + protected override ReadOnlyMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ReadOnlyMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Descriptor; } + } + + public override ReadOnlyMessage DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.DefaultInstance; } + } + + public override ReadOnlyMessage BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.messageNames_.MakeReadOnly(); + result.messageArguments_.MakeReadOnly(); + ReadOnlyMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ReadOnlyMessage) { + return MergeFrom((ReadOnlyMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ReadOnlyMessage other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.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; + } + if (other.messageNames_.Count != 0) { + base.AddRange(other.messageNames_, result.messageNames_); + } + if (other.messageArguments_.Count != 0) { + base.AddRange(other.messageArguments_, result.messageArguments_); + } + 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 74: { + AddMessageNames(input.ReadString()); + break; + } + case 82: { + AddMessageArguments(input.ReadBytes()); + 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.ReadOnlyMessage.Types.ReturnStatus), rawValue)) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(1792, (ulong) rawValue); + } else { + ReturnStatus = (global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.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.ReadOnlyMessage.Types.ReturnStatus ReturnStatus { + get { return result.ReturnStatus; } + set { SetReturnStatus(value); } + } + public Builder SetReturnStatus(global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus value) { + result.hasReturnStatus = true; + result.returnStatus_ = value; + return this; + } + public Builder ClearReturnStatus() { + result.hasReturnStatus = false; + result.returnStatus_ = global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.SUCCESS; + return this; + } + + public pbc::IPopsicleList MessageNamesList { + get { return result.messageNames_; } + } + public int MessageNamesCount { + get { return result.MessageNamesCount; } + } + public string GetMessageNames(int index) { + return result.GetMessageNames(index); + } + public Builder SetMessageNames(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageNames_[index] = value; + return this; + } + public Builder AddMessageNames(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageNames_.Add(value); + return this; + } + public Builder AddRangeMessageNames(scg::IEnumerable values) { + base.AddRange(values, result.messageNames_); + return this; + } + public Builder ClearMessageNames() { + result.messageNames_.Clear(); + return this; + } + + public pbc::IPopsicleList MessageArgumentsList { + get { return result.messageArguments_; } + } + public int MessageArgumentsCount { + get { return result.MessageArgumentsCount; } + } + public pb::ByteString GetMessageArguments(int index) { + return result.GetMessageArguments(index); + } + public Builder SetMessageArguments(int index, pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageArguments_[index] = value; + return this; + } + public Builder AddMessageArguments(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageArguments_.Add(value); + return this; + } + public Builder AddRangeMessageArguments(scg::IEnumerable values) { + base.AddRange(values, result.messageArguments_); + return this; + } + public Builder ClearMessageArguments() { + result.messageArguments_.Clear(); + return this; + } + } + static ReadOnlyMessage() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class SpaceServices : pb::GeneratedMessage { + private static readonly SpaceServices defaultInstance = new Builder().BuildPartial(); + public static SpaceServices DefaultInstance { + get { return defaultInstance; } + } + + public override SpaceServices DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override SpaceServices ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__FieldAccessorTable; } + } + + public const int RegistrationPortFieldNumber = 33; + private bool hasRegistrationPort; + private uint registrationPort_ = 0; + public bool HasRegistrationPort { + get { return hasRegistrationPort; } + } + [global::System.CLSCompliant(false)] + public uint RegistrationPort { + get { return registrationPort_; } + } + + public const int LocPortFieldNumber = 34; + private bool hasLocPort; + private uint locPort_ = 0; + public bool HasLocPort { + get { return hasLocPort; } + } + [global::System.CLSCompliant(false)] + public uint LocPort { + get { return locPort_; } + } + + public const int GeomPortFieldNumber = 35; + private bool hasGeomPort; + private uint geomPort_ = 0; + public bool HasGeomPort { + get { return hasGeomPort; } + } + [global::System.CLSCompliant(false)] + public uint GeomPort { + get { return geomPort_; } + } + + public const int OsegPortFieldNumber = 36; + private bool hasOsegPort; + private uint osegPort_ = 0; + public bool HasOsegPort { + get { return hasOsegPort; } + } + [global::System.CLSCompliant(false)] + public uint OsegPort { + get { return osegPort_; } + } + + public const int CsegPortFieldNumber = 37; + private bool hasCsegPort; + private uint csegPort_ = 0; + public bool HasCsegPort { + get { return hasCsegPort; } + } + [global::System.CLSCompliant(false)] + public uint CsegPort { + get { return csegPort_; } + } + + public const int RouterPortFieldNumber = 38; + private bool hasRouterPort; + private uint routerPort_ = 0; + public bool HasRouterPort { + get { return hasRouterPort; } + } + [global::System.CLSCompliant(false)] + public uint RouterPort { + get { return routerPort_; } + } + + public const int PreConnectionBufferFieldNumber = 64; + private bool hasPreConnectionBuffer; + private ulong preConnectionBuffer_ = 0UL; + public bool HasPreConnectionBuffer { + get { return hasPreConnectionBuffer; } + } + [global::System.CLSCompliant(false)] + public ulong PreConnectionBuffer { + get { return preConnectionBuffer_; } + } + + public const int MaxPreConnectionMessagesFieldNumber = 65; + private bool hasMaxPreConnectionMessages; + private ulong maxPreConnectionMessages_ = 0UL; + public bool HasMaxPreConnectionMessages { + get { return hasMaxPreConnectionMessages; } + } + [global::System.CLSCompliant(false)] + public ulong MaxPreConnectionMessages { + get { return maxPreConnectionMessages_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasRegistrationPort) { + output.WriteUInt32(33, RegistrationPort); + } + if (HasLocPort) { + output.WriteUInt32(34, LocPort); + } + if (HasGeomPort) { + output.WriteUInt32(35, GeomPort); + } + if (HasOsegPort) { + output.WriteUInt32(36, OsegPort); + } + if (HasCsegPort) { + output.WriteUInt32(37, CsegPort); + } + if (HasRouterPort) { + output.WriteUInt32(38, RouterPort); + } + if (HasPreConnectionBuffer) { + output.WriteUInt64(64, PreConnectionBuffer); + } + if (HasMaxPreConnectionMessages) { + output.WriteUInt64(65, MaxPreConnectionMessages); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasRegistrationPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(33, RegistrationPort); + } + if (HasLocPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(34, LocPort); + } + if (HasGeomPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(35, GeomPort); + } + if (HasOsegPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(36, OsegPort); + } + if (HasCsegPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(37, CsegPort); + } + if (HasRouterPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(38, RouterPort); + } + if (HasPreConnectionBuffer) { + size += pb::CodedOutputStream.ComputeUInt64Size(64, PreConnectionBuffer); + } + if (HasMaxPreConnectionMessages) { + size += pb::CodedOutputStream.ComputeUInt64Size(65, MaxPreConnectionMessages); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static SpaceServices ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SpaceServices ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SpaceServices ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SpaceServices ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SpaceServices ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SpaceServices ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SpaceServices ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static SpaceServices ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static SpaceServices ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SpaceServices 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(SpaceServices prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + SpaceServices result = new SpaceServices(); + + protected override SpaceServices MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new SpaceServices(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.SpaceServices.Descriptor; } + } + + public override SpaceServices DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.SpaceServices.DefaultInstance; } + } + + public override SpaceServices BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + SpaceServices returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is SpaceServices) { + return MergeFrom((SpaceServices) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(SpaceServices other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.SpaceServices.DefaultInstance) return this; + if (other.HasRegistrationPort) { + RegistrationPort = other.RegistrationPort; + } + if (other.HasLocPort) { + LocPort = other.LocPort; + } + if (other.HasGeomPort) { + GeomPort = other.GeomPort; + } + if (other.HasOsegPort) { + OsegPort = other.OsegPort; + } + if (other.HasCsegPort) { + CsegPort = other.CsegPort; + } + if (other.HasRouterPort) { + RouterPort = other.RouterPort; + } + if (other.HasPreConnectionBuffer) { + PreConnectionBuffer = other.PreConnectionBuffer; + } + if (other.HasMaxPreConnectionMessages) { + MaxPreConnectionMessages = other.MaxPreConnectionMessages; + } + 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 264: { + RegistrationPort = input.ReadUInt32(); + break; + } + case 272: { + LocPort = input.ReadUInt32(); + break; + } + case 280: { + GeomPort = input.ReadUInt32(); + break; + } + case 288: { + OsegPort = input.ReadUInt32(); + break; + } + case 296: { + CsegPort = input.ReadUInt32(); + break; + } + case 304: { + RouterPort = input.ReadUInt32(); + break; + } + case 512: { + PreConnectionBuffer = input.ReadUInt64(); + break; + } + case 520: { + MaxPreConnectionMessages = input.ReadUInt64(); + break; + } + } + } + } + + + public bool HasRegistrationPort { + get { return result.HasRegistrationPort; } + } + [global::System.CLSCompliant(false)] + public uint RegistrationPort { + get { return result.RegistrationPort; } + set { SetRegistrationPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetRegistrationPort(uint value) { + result.hasRegistrationPort = true; + result.registrationPort_ = value; + return this; + } + public Builder ClearRegistrationPort() { + result.hasRegistrationPort = false; + result.registrationPort_ = 0; + return this; + } + + public bool HasLocPort { + get { return result.HasLocPort; } + } + [global::System.CLSCompliant(false)] + public uint LocPort { + get { return result.LocPort; } + set { SetLocPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetLocPort(uint value) { + result.hasLocPort = true; + result.locPort_ = value; + return this; + } + public Builder ClearLocPort() { + result.hasLocPort = false; + result.locPort_ = 0; + return this; + } + + public bool HasGeomPort { + get { return result.HasGeomPort; } + } + [global::System.CLSCompliant(false)] + public uint GeomPort { + get { return result.GeomPort; } + set { SetGeomPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetGeomPort(uint value) { + result.hasGeomPort = true; + result.geomPort_ = value; + return this; + } + public Builder ClearGeomPort() { + result.hasGeomPort = false; + result.geomPort_ = 0; + return this; + } + + public bool HasOsegPort { + get { return result.HasOsegPort; } + } + [global::System.CLSCompliant(false)] + public uint OsegPort { + get { return result.OsegPort; } + set { SetOsegPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetOsegPort(uint value) { + result.hasOsegPort = true; + result.osegPort_ = value; + return this; + } + public Builder ClearOsegPort() { + result.hasOsegPort = false; + result.osegPort_ = 0; + return this; + } + + public bool HasCsegPort { + get { return result.HasCsegPort; } + } + [global::System.CLSCompliant(false)] + public uint CsegPort { + get { return result.CsegPort; } + set { SetCsegPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetCsegPort(uint value) { + result.hasCsegPort = true; + result.csegPort_ = value; + return this; + } + public Builder ClearCsegPort() { + result.hasCsegPort = false; + result.csegPort_ = 0; + return this; + } + + public bool HasRouterPort { + get { return result.HasRouterPort; } + } + [global::System.CLSCompliant(false)] + public uint RouterPort { + get { return result.RouterPort; } + set { SetRouterPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetRouterPort(uint value) { + result.hasRouterPort = true; + result.routerPort_ = value; + return this; + } + public Builder ClearRouterPort() { + result.hasRouterPort = false; + result.routerPort_ = 0; + return this; + } + + public bool HasPreConnectionBuffer { + get { return result.HasPreConnectionBuffer; } + } + [global::System.CLSCompliant(false)] + public ulong PreConnectionBuffer { + get { return result.PreConnectionBuffer; } + set { SetPreConnectionBuffer(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetPreConnectionBuffer(ulong value) { + result.hasPreConnectionBuffer = true; + result.preConnectionBuffer_ = value; + return this; + } + public Builder ClearPreConnectionBuffer() { + result.hasPreConnectionBuffer = false; + result.preConnectionBuffer_ = 0UL; + return this; + } + + public bool HasMaxPreConnectionMessages { + get { return result.HasMaxPreConnectionMessages; } + } + [global::System.CLSCompliant(false)] + public ulong MaxPreConnectionMessages { + get { return result.MaxPreConnectionMessages; } + set { SetMaxPreConnectionMessages(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetMaxPreConnectionMessages(ulong value) { + result.hasMaxPreConnectionMessages = true; + result.maxPreConnectionMessages_ = value; + return this; + } + public Builder ClearMaxPreConnectionMessages() { + result.hasMaxPreConnectionMessages = false; + result.maxPreConnectionMessages_ = 0UL; + return this; + } + } + static SpaceServices() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class ObjLoc : pb::GeneratedMessage { + private static readonly ObjLoc defaultInstance = new Builder().BuildPartial(); + public static ObjLoc DefaultInstance { + get { return defaultInstance; } + } + + public override ObjLoc DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ObjLoc ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum UpdateFlags { + FORCE = 1, + } + + } + #endregion + + public const int TimestampFieldNumber = 2; + private bool hasTimestamp; + private ulong timestamp_ = 0; + public bool HasTimestamp { + get { return hasTimestamp; } + } + [global::System.CLSCompliant(false)] + public ulong Timestamp { + get { return timestamp_; } + } + + public const int PositionFieldNumber = 3; + private int positionMemoizedSerializedSize; + private pbc::PopsicleList position_ = new pbc::PopsicleList(); + public scg::IList PositionList { + get { return pbc::Lists.AsReadOnly(position_); } + } + public int PositionCount { + get { return position_.Count; } + } + public double GetPosition(int index) { + return position_[index]; + } + + public const int OrientationFieldNumber = 4; + private int orientationMemoizedSerializedSize; + private pbc::PopsicleList orientation_ = new pbc::PopsicleList(); + public scg::IList OrientationList { + get { return pbc::Lists.AsReadOnly(orientation_); } + } + public int OrientationCount { + get { return orientation_.Count; } + } + public float GetOrientation(int index) { + return orientation_[index]; + } + + public const int VelocityFieldNumber = 5; + private int velocityMemoizedSerializedSize; + private pbc::PopsicleList velocity_ = new pbc::PopsicleList(); + public scg::IList VelocityList { + get { return pbc::Lists.AsReadOnly(velocity_); } + } + public int VelocityCount { + get { return velocity_.Count; } + } + public float GetVelocity(int index) { + return velocity_[index]; + } + + public const int RotationalAxisFieldNumber = 7; + private int rotationalAxisMemoizedSerializedSize; + private pbc::PopsicleList rotationalAxis_ = new pbc::PopsicleList(); + public scg::IList RotationalAxisList { + get { return pbc::Lists.AsReadOnly(rotationalAxis_); } + } + public int RotationalAxisCount { + get { return rotationalAxis_.Count; } + } + public float GetRotationalAxis(int index) { + return rotationalAxis_[index]; + } + + public const int AngularSpeedFieldNumber = 8; + private bool hasAngularSpeed; + private float angularSpeed_ = 0F; + public bool HasAngularSpeed { + get { return hasAngularSpeed; } + } + public float AngularSpeed { + get { return angularSpeed_; } + } + + public const int UpdateFlagsFieldNumber = 6; + private bool hasUpdateFlags; + private uint updateFlags_ = 0; + public bool HasUpdateFlags { + get { return hasUpdateFlags; } + } + [global::System.CLSCompliant(false)] + public uint UpdateFlags { + get { return updateFlags_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasTimestamp) { + output.WriteFixed64(2, Timestamp); + } + if (position_.Count > 0) { + output.WriteRawVarint32(26); + output.WriteRawVarint32((uint) positionMemoizedSerializedSize); + foreach (double element in position_) { + output.WriteDoubleNoTag(element); + } + } + if (orientation_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) orientationMemoizedSerializedSize); + foreach (float element in orientation_) { + output.WriteFloatNoTag(element); + } + } + if (velocity_.Count > 0) { + output.WriteRawVarint32(42); + output.WriteRawVarint32((uint) velocityMemoizedSerializedSize); + foreach (float element in velocity_) { + output.WriteFloatNoTag(element); + } + } + if (HasUpdateFlags) { + output.WriteUInt32(6, UpdateFlags); + } + if (rotationalAxis_.Count > 0) { + output.WriteRawVarint32(58); + output.WriteRawVarint32((uint) rotationalAxisMemoizedSerializedSize); + foreach (float element in rotationalAxis_) { + output.WriteFloatNoTag(element); + } + } + if (HasAngularSpeed) { + output.WriteFloat(8, AngularSpeed); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasTimestamp) { + size += pb::CodedOutputStream.ComputeFixed64Size(2, Timestamp); + } + { + int dataSize = 0; + dataSize = 8 * position_.Count; + size += dataSize; + if (position_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + positionMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * orientation_.Count; + size += dataSize; + if (orientation_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + orientationMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * velocity_.Count; + size += dataSize; + if (velocity_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + velocityMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * rotationalAxis_.Count; + size += dataSize; + if (rotationalAxis_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + rotationalAxisMemoizedSerializedSize = dataSize; + } + if (HasAngularSpeed) { + size += pb::CodedOutputStream.ComputeFloatSize(8, AngularSpeed); + } + if (HasUpdateFlags) { + size += pb::CodedOutputStream.ComputeUInt32Size(6, UpdateFlags); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ObjLoc ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ObjLoc ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ObjLoc ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ObjLoc ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ObjLoc ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ObjLoc ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ObjLoc ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ObjLoc ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ObjLoc ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ObjLoc 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(ObjLoc prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ObjLoc result = new ObjLoc(); + + protected override ObjLoc MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ObjLoc(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Descriptor; } + } + + public override ObjLoc DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; } + } + + public override ObjLoc BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.position_.MakeReadOnly(); + result.orientation_.MakeReadOnly(); + result.velocity_.MakeReadOnly(); + result.rotationalAxis_.MakeReadOnly(); + ObjLoc returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ObjLoc) { + return MergeFrom((ObjLoc) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ObjLoc other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance) return this; + if (other.HasTimestamp) { + Timestamp = other.Timestamp; + } + if (other.position_.Count != 0) { + base.AddRange(other.position_, result.position_); + } + if (other.orientation_.Count != 0) { + base.AddRange(other.orientation_, result.orientation_); + } + if (other.velocity_.Count != 0) { + base.AddRange(other.velocity_, result.velocity_); + } + if (other.rotationalAxis_.Count != 0) { + base.AddRange(other.rotationalAxis_, result.rotationalAxis_); + } + if (other.HasAngularSpeed) { + AngularSpeed = other.AngularSpeed; + } + if (other.HasUpdateFlags) { + UpdateFlags = other.UpdateFlags; + } + 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 17: { + Timestamp = input.ReadFixed64(); + break; + } + case 26: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddPosition(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddOrientation(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 42: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddVelocity(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 48: { + UpdateFlags = input.ReadUInt32(); + break; + } + case 58: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddRotationalAxis(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 69: { + AngularSpeed = input.ReadFloat(); + break; + } + } + } + } + + + public bool HasTimestamp { + get { return result.HasTimestamp; } + } + [global::System.CLSCompliant(false)] + public ulong Timestamp { + get { return result.Timestamp; } + set { SetTimestamp(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetTimestamp(ulong value) { + result.hasTimestamp = true; + result.timestamp_ = value; + return this; + } + public Builder ClearTimestamp() { + result.hasTimestamp = false; + result.timestamp_ = 0; + return this; + } + + public pbc::IPopsicleList PositionList { + get { return result.position_; } + } + public int PositionCount { + get { return result.PositionCount; } + } + public double GetPosition(int index) { + return result.GetPosition(index); + } + public Builder SetPosition(int index, double value) { + result.position_[index] = value; + return this; + } + public Builder AddPosition(double value) { + result.position_.Add(value); + return this; + } + public Builder AddRangePosition(scg::IEnumerable values) { + base.AddRange(values, result.position_); + return this; + } + public Builder ClearPosition() { + result.position_.Clear(); + return this; + } + + public pbc::IPopsicleList OrientationList { + get { return result.orientation_; } + } + public int OrientationCount { + get { return result.OrientationCount; } + } + public float GetOrientation(int index) { + return result.GetOrientation(index); + } + public Builder SetOrientation(int index, float value) { + result.orientation_[index] = value; + return this; + } + public Builder AddOrientation(float value) { + result.orientation_.Add(value); + return this; + } + public Builder AddRangeOrientation(scg::IEnumerable values) { + base.AddRange(values, result.orientation_); + return this; + } + public Builder ClearOrientation() { + result.orientation_.Clear(); + return this; + } + + public pbc::IPopsicleList VelocityList { + get { return result.velocity_; } + } + public int VelocityCount { + get { return result.VelocityCount; } + } + public float GetVelocity(int index) { + return result.GetVelocity(index); + } + public Builder SetVelocity(int index, float value) { + result.velocity_[index] = value; + return this; + } + public Builder AddVelocity(float value) { + result.velocity_.Add(value); + return this; + } + public Builder AddRangeVelocity(scg::IEnumerable values) { + base.AddRange(values, result.velocity_); + return this; + } + public Builder ClearVelocity() { + result.velocity_.Clear(); + return this; + } + + public pbc::IPopsicleList RotationalAxisList { + get { return result.rotationalAxis_; } + } + public int RotationalAxisCount { + get { return result.RotationalAxisCount; } + } + public float GetRotationalAxis(int index) { + return result.GetRotationalAxis(index); + } + public Builder SetRotationalAxis(int index, float value) { + result.rotationalAxis_[index] = value; + return this; + } + public Builder AddRotationalAxis(float value) { + result.rotationalAxis_.Add(value); + return this; + } + public Builder AddRangeRotationalAxis(scg::IEnumerable values) { + base.AddRange(values, result.rotationalAxis_); + return this; + } + public Builder ClearRotationalAxis() { + result.rotationalAxis_.Clear(); + return this; + } + + public bool HasAngularSpeed { + get { return result.HasAngularSpeed; } + } + public float AngularSpeed { + get { return result.AngularSpeed; } + set { SetAngularSpeed(value); } + } + public Builder SetAngularSpeed(float value) { + result.hasAngularSpeed = true; + result.angularSpeed_ = value; + return this; + } + public Builder ClearAngularSpeed() { + result.hasAngularSpeed = false; + result.angularSpeed_ = 0F; + return this; + } + + public bool HasUpdateFlags { + get { return result.HasUpdateFlags; } + } + [global::System.CLSCompliant(false)] + public uint UpdateFlags { + get { return result.UpdateFlags; } + set { SetUpdateFlags(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetUpdateFlags(uint value) { + result.hasUpdateFlags = true; + result.updateFlags_ = value; + return this; + } + public Builder ClearUpdateFlags() { + result.hasUpdateFlags = false; + result.updateFlags_ = 0; + return this; + } + } + static ObjLoc() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class LocRequest : pb::GeneratedMessage { + private static readonly LocRequest defaultInstance = new Builder().BuildPartial(); + public static LocRequest DefaultInstance { + get { return defaultInstance; } + } + + public override LocRequest DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override LocRequest ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum Fields { + POSITION = 1, + ORIENTATION = 2, + VELOCITY = 4, + ROTATIONAL_AXIS = 8, + ANGULAR_SPEED = 16, + } + + } + #endregion + + public const int RequestedFieldsFieldNumber = 2; + private bool hasRequestedFields; + private uint requestedFields_ = 0; + public bool HasRequestedFields { + get { return hasRequestedFields; } + } + [global::System.CLSCompliant(false)] + public uint RequestedFields { + get { return requestedFields_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasRequestedFields) { + output.WriteUInt32(2, RequestedFields); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasRequestedFields) { + size += pb::CodedOutputStream.ComputeUInt32Size(2, RequestedFields); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static LocRequest ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static LocRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static LocRequest ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static LocRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static LocRequest ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static LocRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static LocRequest ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static LocRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static LocRequest ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static LocRequest 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(LocRequest prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + LocRequest result = new LocRequest(); + + protected override LocRequest MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new LocRequest(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.LocRequest.Descriptor; } + } + + public override LocRequest DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.LocRequest.DefaultInstance; } + } + + public override LocRequest BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + LocRequest returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is LocRequest) { + return MergeFrom((LocRequest) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(LocRequest other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.LocRequest.DefaultInstance) return this; + if (other.HasRequestedFields) { + RequestedFields = other.RequestedFields; + } + 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 16: { + RequestedFields = input.ReadUInt32(); + break; + } + } + } + } + + + public bool HasRequestedFields { + get { return result.HasRequestedFields; } + } + [global::System.CLSCompliant(false)] + public uint RequestedFields { + get { return result.RequestedFields; } + set { SetRequestedFields(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetRequestedFields(uint value) { + result.hasRequestedFields = true; + result.requestedFields_ = value; + return this; + } + public Builder ClearRequestedFields() { + result.hasRequestedFields = false; + result.requestedFields_ = 0; + return this; + } + } + static LocRequest() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class NewObj : pb::GeneratedMessage { + private static readonly NewObj defaultInstance = new Builder().BuildPartial(); + public static NewObj DefaultInstance { + get { return defaultInstance; } + } + + public override NewObj DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override NewObj ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__FieldAccessorTable; } + } + + public const int ObjectUuidEvidenceFieldNumber = 2; + private bool hasObjectUuidEvidence; + private pb::ByteString objectUuidEvidence_ = pb::ByteString.Empty; + public bool HasObjectUuidEvidence { + get { return hasObjectUuidEvidence; } + } + public pb::ByteString ObjectUuidEvidence { + get { return objectUuidEvidence_; } + } + + public const int RequestedObjectLocFieldNumber = 3; + private bool hasRequestedObjectLoc; + private global::Sirikata.Protocol._PBJ_Internal.ObjLoc requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; + public bool HasRequestedObjectLoc { + get { return hasRequestedObjectLoc; } + } + public global::Sirikata.Protocol._PBJ_Internal.ObjLoc RequestedObjectLoc { + get { return requestedObjectLoc_; } + } + + public const int BoundingSphereFieldNumber = 4; + private int boundingSphereMemoizedSerializedSize; + private pbc::PopsicleList boundingSphere_ = new pbc::PopsicleList(); + public scg::IList BoundingSphereList { + get { return pbc::Lists.AsReadOnly(boundingSphere_); } + } + public int BoundingSphereCount { + get { return boundingSphere_.Count; } + } + public float GetBoundingSphere(int index) { + return boundingSphere_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasObjectUuidEvidence) { + output.WriteBytes(2, ObjectUuidEvidence); + } + if (HasRequestedObjectLoc) { + output.WriteMessage(3, RequestedObjectLoc); + } + if (boundingSphere_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) boundingSphereMemoizedSerializedSize); + foreach (float element in boundingSphere_) { + output.WriteFloatNoTag(element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasObjectUuidEvidence) { + size += pb::CodedOutputStream.ComputeBytesSize(2, ObjectUuidEvidence); + } + if (HasRequestedObjectLoc) { + size += pb::CodedOutputStream.ComputeMessageSize(3, RequestedObjectLoc); + } + { + int dataSize = 0; + dataSize = 4 * boundingSphere_.Count; + size += dataSize; + if (boundingSphere_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + boundingSphereMemoizedSerializedSize = dataSize; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static NewObj ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NewObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NewObj ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NewObj ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NewObj ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NewObj ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static NewObj ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static NewObj ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static NewObj ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NewObj 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(NewObj prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + NewObj result = new NewObj(); + + protected override NewObj MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new NewObj(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.NewObj.Descriptor; } + } + + public override NewObj DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.NewObj.DefaultInstance; } + } + + public override NewObj BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.boundingSphere_.MakeReadOnly(); + NewObj returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is NewObj) { + return MergeFrom((NewObj) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(NewObj other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.NewObj.DefaultInstance) return this; + if (other.HasObjectUuidEvidence) { + ObjectUuidEvidence = other.ObjectUuidEvidence; + } + if (other.HasRequestedObjectLoc) { + MergeRequestedObjectLoc(other.RequestedObjectLoc); + } + if (other.boundingSphere_.Count != 0) { + base.AddRange(other.boundingSphere_, result.boundingSphere_); + } + 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 18: { + ObjectUuidEvidence = input.ReadBytes(); + break; + } + case 26: { + global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(); + if (HasRequestedObjectLoc) { + subBuilder.MergeFrom(RequestedObjectLoc); + } + input.ReadMessage(subBuilder, extensionRegistry); + RequestedObjectLoc = subBuilder.BuildPartial(); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddBoundingSphere(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + } + } + } + + + public bool HasObjectUuidEvidence { + get { return result.HasObjectUuidEvidence; } + } + public pb::ByteString ObjectUuidEvidence { + get { return result.ObjectUuidEvidence; } + set { SetObjectUuidEvidence(value); } + } + public Builder SetObjectUuidEvidence(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectUuidEvidence = true; + result.objectUuidEvidence_ = value; + return this; + } + public Builder ClearObjectUuidEvidence() { + result.hasObjectUuidEvidence = false; + result.objectUuidEvidence_ = pb::ByteString.Empty; + return this; + } + + public bool HasRequestedObjectLoc { + get { return result.HasRequestedObjectLoc; } + } + public global::Sirikata.Protocol._PBJ_Internal.ObjLoc RequestedObjectLoc { + get { return result.RequestedObjectLoc; } + set { SetRequestedObjectLoc(value); } + } + public Builder SetRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasRequestedObjectLoc = true; + result.requestedObjectLoc_ = value; + return this; + } + public Builder SetRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasRequestedObjectLoc = true; + result.requestedObjectLoc_ = builderForValue.Build(); + return this; + } + public Builder MergeRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasRequestedObjectLoc && + result.requestedObjectLoc_ != global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance) { + result.requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(result.requestedObjectLoc_).MergeFrom(value).BuildPartial(); + } else { + result.requestedObjectLoc_ = value; + } + result.hasRequestedObjectLoc = true; + return this; + } + public Builder ClearRequestedObjectLoc() { + result.hasRequestedObjectLoc = false; + result.requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; + return this; + } + + public pbc::IPopsicleList BoundingSphereList { + get { return result.boundingSphere_; } + } + public int BoundingSphereCount { + get { return result.BoundingSphereCount; } + } + public float GetBoundingSphere(int index) { + return result.GetBoundingSphere(index); + } + public Builder SetBoundingSphere(int index, float value) { + result.boundingSphere_[index] = value; + return this; + } + public Builder AddBoundingSphere(float value) { + result.boundingSphere_.Add(value); + return this; + } + public Builder AddRangeBoundingSphere(scg::IEnumerable values) { + base.AddRange(values, result.boundingSphere_); + return this; + } + public Builder ClearBoundingSphere() { + result.boundingSphere_.Clear(); + return this; + } + } + static NewObj() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class RetObj : pb::GeneratedMessage { + private static readonly RetObj defaultInstance = new Builder().BuildPartial(); + public static RetObj DefaultInstance { + get { return defaultInstance; } + } + + public override RetObj DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override RetObj ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__FieldAccessorTable; } + } + + public const int ObjectReferenceFieldNumber = 2; + private bool hasObjectReference; + private pb::ByteString objectReference_ = pb::ByteString.Empty; + public bool HasObjectReference { + get { return hasObjectReference; } + } + public pb::ByteString ObjectReference { + get { return objectReference_; } + } + + public const int LocationFieldNumber = 3; + private bool hasLocation; + private global::Sirikata.Protocol._PBJ_Internal.ObjLoc location_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; + public bool HasLocation { + get { return hasLocation; } + } + public global::Sirikata.Protocol._PBJ_Internal.ObjLoc Location { + get { return location_; } + } + + public const int BoundingSphereFieldNumber = 4; + private int boundingSphereMemoizedSerializedSize; + private pbc::PopsicleList boundingSphere_ = new pbc::PopsicleList(); + public scg::IList BoundingSphereList { + get { return pbc::Lists.AsReadOnly(boundingSphere_); } + } + public int BoundingSphereCount { + get { return boundingSphere_.Count; } + } + public float GetBoundingSphere(int index) { + return boundingSphere_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasObjectReference) { + output.WriteBytes(2, ObjectReference); + } + if (HasLocation) { + output.WriteMessage(3, Location); + } + if (boundingSphere_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) boundingSphereMemoizedSerializedSize); + foreach (float element in boundingSphere_) { + output.WriteFloatNoTag(element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasObjectReference) { + size += pb::CodedOutputStream.ComputeBytesSize(2, ObjectReference); + } + if (HasLocation) { + size += pb::CodedOutputStream.ComputeMessageSize(3, Location); + } + { + int dataSize = 0; + dataSize = 4 * boundingSphere_.Count; + size += dataSize; + if (boundingSphere_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + boundingSphereMemoizedSerializedSize = dataSize; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static RetObj ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RetObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RetObj ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RetObj ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RetObj ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RetObj ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static RetObj ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static RetObj ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static RetObj ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RetObj 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(RetObj prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + RetObj result = new RetObj(); + + protected override RetObj MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new RetObj(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.RetObj.Descriptor; } + } + + public override RetObj DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.RetObj.DefaultInstance; } + } + + public override RetObj BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.boundingSphere_.MakeReadOnly(); + RetObj returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is RetObj) { + return MergeFrom((RetObj) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(RetObj other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.RetObj.DefaultInstance) return this; + if (other.HasObjectReference) { + ObjectReference = other.ObjectReference; + } + if (other.HasLocation) { + MergeLocation(other.Location); + } + if (other.boundingSphere_.Count != 0) { + base.AddRange(other.boundingSphere_, result.boundingSphere_); + } + 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 18: { + ObjectReference = input.ReadBytes(); + break; + } + case 26: { + global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(); + if (HasLocation) { + subBuilder.MergeFrom(Location); + } + input.ReadMessage(subBuilder, extensionRegistry); + Location = subBuilder.BuildPartial(); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddBoundingSphere(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + } + } + } + + + public bool HasObjectReference { + get { return result.HasObjectReference; } + } + public pb::ByteString ObjectReference { + get { return result.ObjectReference; } + set { SetObjectReference(value); } + } + public Builder SetObjectReference(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectReference = true; + result.objectReference_ = value; + return this; + } + public Builder ClearObjectReference() { + result.hasObjectReference = false; + result.objectReference_ = pb::ByteString.Empty; + return this; + } + + public bool HasLocation { + get { return result.HasLocation; } + } + public global::Sirikata.Protocol._PBJ_Internal.ObjLoc Location { + get { return result.Location; } + set { SetLocation(value); } + } + public Builder SetLocation(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasLocation = true; + result.location_ = value; + return this; + } + public Builder SetLocation(global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasLocation = true; + result.location_ = builderForValue.Build(); + return this; + } + public Builder MergeLocation(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasLocation && + result.location_ != global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance) { + result.location_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(result.location_).MergeFrom(value).BuildPartial(); + } else { + result.location_ = value; + } + result.hasLocation = true; + return this; + } + public Builder ClearLocation() { + result.hasLocation = false; + result.location_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; + return this; + } + + public pbc::IPopsicleList BoundingSphereList { + get { return result.boundingSphere_; } + } + public int BoundingSphereCount { + get { return result.BoundingSphereCount; } + } + public float GetBoundingSphere(int index) { + return result.GetBoundingSphere(index); + } + public Builder SetBoundingSphere(int index, float value) { + result.boundingSphere_[index] = value; + return this; + } + public Builder AddBoundingSphere(float value) { + result.boundingSphere_.Add(value); + return this; + } + public Builder AddRangeBoundingSphere(scg::IEnumerable values) { + base.AddRange(values, result.boundingSphere_); + return this; + } + public Builder ClearBoundingSphere() { + result.boundingSphere_.Clear(); + return this; + } + } + static RetObj() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class DelObj : pb::GeneratedMessage { + private static readonly DelObj defaultInstance = new Builder().BuildPartial(); + public static DelObj DefaultInstance { + get { return defaultInstance; } + } + + public override DelObj DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override DelObj ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__FieldAccessorTable; } + } + + public const int ObjectReferenceFieldNumber = 2; + private bool hasObjectReference; + private pb::ByteString objectReference_ = pb::ByteString.Empty; + public bool HasObjectReference { + get { return hasObjectReference; } + } + public pb::ByteString ObjectReference { + get { return objectReference_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasObjectReference) { + output.WriteBytes(2, ObjectReference); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasObjectReference) { + size += pb::CodedOutputStream.ComputeBytesSize(2, ObjectReference); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static DelObj ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DelObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DelObj ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DelObj ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DelObj ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DelObj ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static DelObj ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static DelObj ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static DelObj ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DelObj 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(DelObj prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + DelObj result = new DelObj(); + + protected override DelObj MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new DelObj(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.DelObj.Descriptor; } + } + + public override DelObj DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.DelObj.DefaultInstance; } + } + + public override DelObj BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + DelObj returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is DelObj) { + return MergeFrom((DelObj) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(DelObj other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.DelObj.DefaultInstance) return this; + if (other.HasObjectReference) { + ObjectReference = other.ObjectReference; + } + 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 18: { + ObjectReference = input.ReadBytes(); + break; + } + } + } + } + + + public bool HasObjectReference { + get { return result.HasObjectReference; } + } + public pb::ByteString ObjectReference { + get { return result.ObjectReference; } + set { SetObjectReference(value); } + } + public Builder SetObjectReference(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectReference = true; + result.objectReference_ = value; + return this; + } + public Builder ClearObjectReference() { + result.hasObjectReference = false; + result.objectReference_ = pb::ByteString.Empty; + return this; + } + } + static DelObj() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class NewProxQuery : pb::GeneratedMessage { + private static readonly NewProxQuery defaultInstance = new Builder().BuildPartial(); + public static NewProxQuery DefaultInstance { + get { return defaultInstance; } + } + + public override NewProxQuery DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override NewProxQuery ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__FieldAccessorTable; } + } + + public const int QueryIdFieldNumber = 2; + private bool hasQueryId; + private uint queryId_ = 0; + public bool HasQueryId { + get { return hasQueryId; } + } + [global::System.CLSCompliant(false)] + public uint QueryId { + get { return queryId_; } + } + + public const int StatelessFieldNumber = 3; + private bool hasStateless; + private bool stateless_ = false; + public bool HasStateless { + get { return hasStateless; } + } + public bool Stateless { + get { return stateless_; } + } + + public const int RelativeCenterFieldNumber = 4; + private int relativeCenterMemoizedSerializedSize; + private pbc::PopsicleList relativeCenter_ = new pbc::PopsicleList(); + public scg::IList RelativeCenterList { + get { return pbc::Lists.AsReadOnly(relativeCenter_); } + } + public int RelativeCenterCount { + get { return relativeCenter_.Count; } + } + public float GetRelativeCenter(int index) { + return relativeCenter_[index]; + } + + public const int AbsoluteCenterFieldNumber = 5; + private int absoluteCenterMemoizedSerializedSize; + private pbc::PopsicleList absoluteCenter_ = new pbc::PopsicleList(); + public scg::IList AbsoluteCenterList { + get { return pbc::Lists.AsReadOnly(absoluteCenter_); } + } + public int AbsoluteCenterCount { + get { return absoluteCenter_.Count; } + } + public double GetAbsoluteCenter(int index) { + return absoluteCenter_[index]; + } + + public const int MaxRadiusFieldNumber = 6; + private bool hasMaxRadius; + private float maxRadius_ = 0F; + public bool HasMaxRadius { + get { return hasMaxRadius; } + } + public float MaxRadius { + get { return maxRadius_; } + } + + public const int MinSolidAngleFieldNumber = 7; + private bool hasMinSolidAngle; + private float minSolidAngle_ = 0F; + public bool HasMinSolidAngle { + get { return hasMinSolidAngle; } + } + public float MinSolidAngle { + get { return minSolidAngle_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasQueryId) { + output.WriteUInt32(2, QueryId); + } + if (HasStateless) { + output.WriteBool(3, Stateless); + } + if (relativeCenter_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) relativeCenterMemoizedSerializedSize); + foreach (float element in relativeCenter_) { + output.WriteFloatNoTag(element); + } + } + if (absoluteCenter_.Count > 0) { + output.WriteRawVarint32(42); + output.WriteRawVarint32((uint) absoluteCenterMemoizedSerializedSize); + foreach (double element in absoluteCenter_) { + output.WriteDoubleNoTag(element); + } + } + if (HasMaxRadius) { + output.WriteFloat(6, MaxRadius); + } + if (HasMinSolidAngle) { + output.WriteFloat(7, MinSolidAngle); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasQueryId) { + size += pb::CodedOutputStream.ComputeUInt32Size(2, QueryId); + } + if (HasStateless) { + size += pb::CodedOutputStream.ComputeBoolSize(3, Stateless); + } + { + int dataSize = 0; + dataSize = 4 * relativeCenter_.Count; + size += dataSize; + if (relativeCenter_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + relativeCenterMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 8 * absoluteCenter_.Count; + size += dataSize; + if (absoluteCenter_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + absoluteCenterMemoizedSerializedSize = dataSize; + } + if (HasMaxRadius) { + size += pb::CodedOutputStream.ComputeFloatSize(6, MaxRadius); + } + if (HasMinSolidAngle) { + size += pb::CodedOutputStream.ComputeFloatSize(7, MinSolidAngle); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static NewProxQuery ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NewProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NewProxQuery ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NewProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NewProxQuery ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NewProxQuery ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static NewProxQuery ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static NewProxQuery ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static NewProxQuery ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NewProxQuery 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(NewProxQuery prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + NewProxQuery result = new NewProxQuery(); + + protected override NewProxQuery MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new NewProxQuery(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.NewProxQuery.Descriptor; } + } + + public override NewProxQuery DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.NewProxQuery.DefaultInstance; } + } + + public override NewProxQuery BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.relativeCenter_.MakeReadOnly(); + result.absoluteCenter_.MakeReadOnly(); + NewProxQuery returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is NewProxQuery) { + return MergeFrom((NewProxQuery) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(NewProxQuery other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.NewProxQuery.DefaultInstance) return this; + if (other.HasQueryId) { + QueryId = other.QueryId; + } + if (other.HasStateless) { + Stateless = other.Stateless; + } + if (other.relativeCenter_.Count != 0) { + base.AddRange(other.relativeCenter_, result.relativeCenter_); + } + if (other.absoluteCenter_.Count != 0) { + base.AddRange(other.absoluteCenter_, result.absoluteCenter_); + } + if (other.HasMaxRadius) { + MaxRadius = other.MaxRadius; + } + if (other.HasMinSolidAngle) { + MinSolidAngle = other.MinSolidAngle; + } + 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 16: { + QueryId = input.ReadUInt32(); + break; + } + case 24: { + Stateless = input.ReadBool(); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddRelativeCenter(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 42: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddAbsoluteCenter(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 53: { + MaxRadius = input.ReadFloat(); + break; + } + case 61: { + MinSolidAngle = input.ReadFloat(); + break; + } + } + } + } + + + public bool HasQueryId { + get { return result.HasQueryId; } + } + [global::System.CLSCompliant(false)] + public uint QueryId { + get { return result.QueryId; } + set { SetQueryId(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetQueryId(uint value) { + result.hasQueryId = true; + result.queryId_ = value; + return this; + } + public Builder ClearQueryId() { + result.hasQueryId = false; + result.queryId_ = 0; + return this; + } + + public bool HasStateless { + get { return result.HasStateless; } + } + public bool Stateless { + get { return result.Stateless; } + set { SetStateless(value); } + } + public Builder SetStateless(bool value) { + result.hasStateless = true; + result.stateless_ = value; + return this; + } + public Builder ClearStateless() { + result.hasStateless = false; + result.stateless_ = false; + return this; + } + + public pbc::IPopsicleList RelativeCenterList { + get { return result.relativeCenter_; } + } + public int RelativeCenterCount { + get { return result.RelativeCenterCount; } + } + public float GetRelativeCenter(int index) { + return result.GetRelativeCenter(index); + } + public Builder SetRelativeCenter(int index, float value) { + result.relativeCenter_[index] = value; + return this; + } + public Builder AddRelativeCenter(float value) { + result.relativeCenter_.Add(value); + return this; + } + public Builder AddRangeRelativeCenter(scg::IEnumerable values) { + base.AddRange(values, result.relativeCenter_); + return this; + } + public Builder ClearRelativeCenter() { + result.relativeCenter_.Clear(); + return this; + } + + public pbc::IPopsicleList AbsoluteCenterList { + get { return result.absoluteCenter_; } + } + public int AbsoluteCenterCount { + get { return result.AbsoluteCenterCount; } + } + public double GetAbsoluteCenter(int index) { + return result.GetAbsoluteCenter(index); + } + public Builder SetAbsoluteCenter(int index, double value) { + result.absoluteCenter_[index] = value; + return this; + } + public Builder AddAbsoluteCenter(double value) { + result.absoluteCenter_.Add(value); + return this; + } + public Builder AddRangeAbsoluteCenter(scg::IEnumerable values) { + base.AddRange(values, result.absoluteCenter_); + return this; + } + public Builder ClearAbsoluteCenter() { + result.absoluteCenter_.Clear(); + return this; + } + + public bool HasMaxRadius { + get { return result.HasMaxRadius; } + } + public float MaxRadius { + get { return result.MaxRadius; } + set { SetMaxRadius(value); } + } + public Builder SetMaxRadius(float value) { + result.hasMaxRadius = true; + result.maxRadius_ = value; + return this; + } + public Builder ClearMaxRadius() { + result.hasMaxRadius = false; + result.maxRadius_ = 0F; + return this; + } + + public bool HasMinSolidAngle { + get { return result.HasMinSolidAngle; } + } + public float MinSolidAngle { + get { return result.MinSolidAngle; } + set { SetMinSolidAngle(value); } + } + public Builder SetMinSolidAngle(float value) { + result.hasMinSolidAngle = true; + result.minSolidAngle_ = value; + return this; + } + public Builder ClearMinSolidAngle() { + result.hasMinSolidAngle = false; + result.minSolidAngle_ = 0F; + return this; + } + } + static NewProxQuery() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class ProxCall : pb::GeneratedMessage { + private static readonly ProxCall defaultInstance = new Builder().BuildPartial(); + public static ProxCall DefaultInstance { + get { return defaultInstance; } + } + + public override ProxCall DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ProxCall ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum ProximityEvent { + EXITED_PROXIMITY = 0, + ENTERED_PROXIMITY = 1, + STATELESS_PROXIMITY = 2, + } + + } + #endregion + + public const int QueryIdFieldNumber = 2; + private bool hasQueryId; + private uint queryId_ = 0; + public bool HasQueryId { + get { return hasQueryId; } + } + [global::System.CLSCompliant(false)] + public uint QueryId { + get { return queryId_; } + } + + public const int ProximateObjectFieldNumber = 3; + private bool hasProximateObject; + private pb::ByteString proximateObject_ = pb::ByteString.Empty; + public bool HasProximateObject { + get { return hasProximateObject; } + } + public pb::ByteString ProximateObject { + get { return proximateObject_; } + } + + public const int ProximityEventFieldNumber = 4; + private bool hasProximityEvent; + private global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent proximityEvent_ = global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent.EXITED_PROXIMITY; + public bool HasProximityEvent { + get { return hasProximityEvent; } + } + public global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent ProximityEvent { + get { return proximityEvent_; } + } + + public override bool IsInitialized { + get { + if (!hasQueryId) return false; + if (!hasProximateObject) return false; + if (!hasProximityEvent) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasQueryId) { + output.WriteUInt32(2, QueryId); + } + if (HasProximateObject) { + output.WriteBytes(3, ProximateObject); + } + if (HasProximityEvent) { + output.WriteEnum(4, (int) ProximityEvent); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasQueryId) { + size += pb::CodedOutputStream.ComputeUInt32Size(2, QueryId); + } + if (HasProximateObject) { + size += pb::CodedOutputStream.ComputeBytesSize(3, ProximateObject); + } + if (HasProximityEvent) { + size += pb::CodedOutputStream.ComputeEnumSize(4, (int) ProximityEvent); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ProxCall ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ProxCall ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ProxCall ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ProxCall ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ProxCall ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ProxCall ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ProxCall ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ProxCall ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ProxCall ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ProxCall 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(ProxCall prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ProxCall result = new ProxCall(); + + protected override ProxCall MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ProxCall(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ProxCall.Descriptor; } + } + + public override ProxCall DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ProxCall.DefaultInstance; } + } + + public override ProxCall BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + ProxCall returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ProxCall) { + return MergeFrom((ProxCall) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ProxCall other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.ProxCall.DefaultInstance) return this; + if (other.HasQueryId) { + QueryId = other.QueryId; + } + if (other.HasProximateObject) { + ProximateObject = other.ProximateObject; + } + if (other.HasProximityEvent) { + ProximityEvent = other.ProximityEvent; + } + 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 16: { + QueryId = input.ReadUInt32(); + break; + } + case 26: { + ProximateObject = input.ReadBytes(); + break; + } + case 32: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent), rawValue)) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(4, (ulong) rawValue); + } else { + ProximityEvent = (global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent) rawValue; + } + break; + } + } + } + } + + + public bool HasQueryId { + get { return result.HasQueryId; } + } + [global::System.CLSCompliant(false)] + public uint QueryId { + get { return result.QueryId; } + set { SetQueryId(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetQueryId(uint value) { + result.hasQueryId = true; + result.queryId_ = value; + return this; + } + public Builder ClearQueryId() { + result.hasQueryId = false; + result.queryId_ = 0; + return this; + } + + public bool HasProximateObject { + get { return result.HasProximateObject; } + } + public pb::ByteString ProximateObject { + get { return result.ProximateObject; } + set { SetProximateObject(value); } + } + public Builder SetProximateObject(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasProximateObject = true; + result.proximateObject_ = value; + return this; + } + public Builder ClearProximateObject() { + result.hasProximateObject = false; + result.proximateObject_ = pb::ByteString.Empty; + return this; + } + + public bool HasProximityEvent { + get { return result.HasProximityEvent; } + } + public global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent ProximityEvent { + get { return result.ProximityEvent; } + set { SetProximityEvent(value); } + } + public Builder SetProximityEvent(global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent value) { + result.hasProximityEvent = true; + result.proximityEvent_ = value; + return this; + } + public Builder ClearProximityEvent() { + result.hasProximityEvent = false; + result.proximityEvent_ = global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent.EXITED_PROXIMITY; + return this; + } + } + static ProxCall() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class DelProxQuery : pb::GeneratedMessage { + private static readonly DelProxQuery defaultInstance = new Builder().BuildPartial(); + public static DelProxQuery DefaultInstance { + get { return defaultInstance; } + } + + public override DelProxQuery DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override DelProxQuery ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__FieldAccessorTable; } + } + + public const int QueryIdFieldNumber = 2; + private bool hasQueryId; + private uint queryId_ = 0; + public bool HasQueryId { + get { return hasQueryId; } + } + [global::System.CLSCompliant(false)] + public uint QueryId { + get { return queryId_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasQueryId) { + output.WriteUInt32(2, QueryId); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasQueryId) { + size += pb::CodedOutputStream.ComputeUInt32Size(2, QueryId); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static DelProxQuery ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DelProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DelProxQuery ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DelProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DelProxQuery ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DelProxQuery ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static DelProxQuery ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static DelProxQuery ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static DelProxQuery ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DelProxQuery 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(DelProxQuery prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + DelProxQuery result = new DelProxQuery(); + + protected override DelProxQuery MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new DelProxQuery(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.DelProxQuery.Descriptor; } + } + + public override DelProxQuery DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.DelProxQuery.DefaultInstance; } + } + + public override DelProxQuery BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + DelProxQuery returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is DelProxQuery) { + return MergeFrom((DelProxQuery) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(DelProxQuery other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.DelProxQuery.DefaultInstance) return this; + if (other.HasQueryId) { + QueryId = other.QueryId; + } + 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 16: { + QueryId = input.ReadUInt32(); + break; + } + } + } + } + + + public bool HasQueryId { + get { return result.HasQueryId; } + } + [global::System.CLSCompliant(false)] + public uint QueryId { + get { return result.QueryId; } + set { SetQueryId(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetQueryId(uint value) { + result.hasQueryId = true; + result.queryId_ = value; + return this; + } + public Builder ClearQueryId() { + result.hasQueryId = false; + result.queryId_ = 0; + return this; + } + } + static DelProxQuery() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class Vector3fProperty : pb::GeneratedMessage { + private static readonly Vector3fProperty defaultInstance = new Builder().BuildPartial(); + public static Vector3fProperty DefaultInstance { + get { return defaultInstance; } + } + + public override Vector3fProperty DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Vector3fProperty ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__FieldAccessorTable; } + } + + public const int ValueFieldNumber = 10; + private int valueMemoizedSerializedSize; + private pbc::PopsicleList value_ = new pbc::PopsicleList(); + public scg::IList ValueList { + get { return pbc::Lists.AsReadOnly(value_); } + } + public int ValueCount { + get { return value_.Count; } + } + public float GetValue(int index) { + return value_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (value_.Count > 0) { + output.WriteRawVarint32(82); + output.WriteRawVarint32((uint) valueMemoizedSerializedSize); + foreach (float element in value_) { + output.WriteFloatNoTag(element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + dataSize = 4 * value_.Count; + size += dataSize; + if (value_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + valueMemoizedSerializedSize = dataSize; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Vector3fProperty ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Vector3fProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Vector3fProperty ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Vector3fProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Vector3fProperty ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Vector3fProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Vector3fProperty ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static Vector3fProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static Vector3fProperty ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Vector3fProperty 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(Vector3fProperty prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Vector3fProperty result = new Vector3fProperty(); + + protected override Vector3fProperty MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Vector3fProperty(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty.Descriptor; } + } + + public override Vector3fProperty DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty.DefaultInstance; } + } + + public override Vector3fProperty BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.value_.MakeReadOnly(); + Vector3fProperty returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Vector3fProperty) { + return MergeFrom((Vector3fProperty) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Vector3fProperty other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty.DefaultInstance) return this; + if (other.value_.Count != 0) { + base.AddRange(other.value_, result.value_); + } + 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 82: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddValue(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + } + } + } + + + public pbc::IPopsicleList ValueList { + get { return result.value_; } + } + public int ValueCount { + get { return result.ValueCount; } + } + public float GetValue(int index) { + return result.GetValue(index); + } + public Builder SetValue(int index, float value) { + result.value_[index] = value; + return this; + } + public Builder AddValue(float value) { + result.value_.Add(value); + return this; + } + public Builder AddRangeValue(scg::IEnumerable values) { + base.AddRange(values, result.value_); + return this; + } + public Builder ClearValue() { + result.value_.Clear(); + return this; + } + } + static Vector3fProperty() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class StringProperty : pb::GeneratedMessage { + private static readonly StringProperty defaultInstance = new Builder().BuildPartial(); + public static StringProperty DefaultInstance { + get { return defaultInstance; } + } + + public override StringProperty DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override StringProperty ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__FieldAccessorTable; } + } + + public const int ValueFieldNumber = 10; + private bool hasValue; + private string value_ = ""; + public bool HasValue { + get { return hasValue; } + } + public string Value { + get { return value_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasValue) { + output.WriteString(10, Value); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasValue) { + size += pb::CodedOutputStream.ComputeStringSize(10, Value); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static StringProperty ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StringProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StringProperty ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StringProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StringProperty ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StringProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static StringProperty ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static StringProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static StringProperty ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StringProperty 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(StringProperty prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + StringProperty result = new StringProperty(); + + protected override StringProperty MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new StringProperty(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.StringProperty.Descriptor; } + } + + public override StringProperty DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.StringProperty.DefaultInstance; } + } + + public override StringProperty BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + StringProperty returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is StringProperty) { + return MergeFrom((StringProperty) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(StringProperty other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.StringProperty.DefaultInstance) return this; + if (other.HasValue) { + Value = other.Value; + } + 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 82: { + Value = input.ReadString(); + break; + } + } + } + } + + + public bool HasValue { + get { return result.HasValue; } + } + public string Value { + get { return result.Value; } + set { SetValue(value); } + } + public Builder SetValue(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasValue = true; + result.value_ = value; + return this; + } + public Builder ClearValue() { + result.hasValue = false; + result.value_ = ""; + return this; + } + } + static StringProperty() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class StringMapProperty : pb::GeneratedMessage { + private static readonly StringMapProperty defaultInstance = new Builder().BuildPartial(); + public static StringMapProperty DefaultInstance { + get { return defaultInstance; } + } + + public override StringMapProperty DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override StringMapProperty ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__FieldAccessorTable; } + } + + public const int KeysFieldNumber = 2; + private pbc::PopsicleList keys_ = new pbc::PopsicleList(); + public scg::IList KeysList { + get { return pbc::Lists.AsReadOnly(keys_); } + } + public int KeysCount { + get { return keys_.Count; } + } + public string GetKeys(int index) { + return keys_[index]; + } + + public const int ValuesFieldNumber = 3; + private pbc::PopsicleList values_ = new pbc::PopsicleList(); + public scg::IList ValuesList { + get { return pbc::Lists.AsReadOnly(values_); } + } + public int ValuesCount { + get { return values_.Count; } + } + public string GetValues(int index) { + return values_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (keys_.Count > 0) { + foreach (string element in keys_) { + output.WriteString(2, element); + } + } + if (values_.Count > 0) { + foreach (string element in values_) { + output.WriteString(3, element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + foreach (string element in KeysList) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 1 * keys_.Count; + } + { + int dataSize = 0; + foreach (string element in ValuesList) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 1 * values_.Count; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static StringMapProperty ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StringMapProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StringMapProperty ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StringMapProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StringMapProperty ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StringMapProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static StringMapProperty ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static StringMapProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static StringMapProperty ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StringMapProperty 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(StringMapProperty prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + StringMapProperty result = new StringMapProperty(); + + protected override StringMapProperty MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new StringMapProperty(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.StringMapProperty.Descriptor; } + } + + public override StringMapProperty DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.StringMapProperty.DefaultInstance; } + } + + public override StringMapProperty BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.keys_.MakeReadOnly(); + result.values_.MakeReadOnly(); + StringMapProperty returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is StringMapProperty) { + return MergeFrom((StringMapProperty) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(StringMapProperty other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.StringMapProperty.DefaultInstance) return this; + if (other.keys_.Count != 0) { + base.AddRange(other.keys_, result.keys_); + } + if (other.values_.Count != 0) { + base.AddRange(other.values_, result.values_); + } + 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 18: { + AddKeys(input.ReadString()); + break; + } + case 26: { + AddValues(input.ReadString()); + break; + } + } + } + } + + + public pbc::IPopsicleList KeysList { + get { return result.keys_; } + } + public int KeysCount { + get { return result.KeysCount; } + } + public string GetKeys(int index) { + return result.GetKeys(index); + } + public Builder SetKeys(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.keys_[index] = value; + return this; + } + public Builder AddKeys(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.keys_.Add(value); + return this; + } + public Builder AddRangeKeys(scg::IEnumerable values) { + base.AddRange(values, result.keys_); + return this; + } + public Builder ClearKeys() { + result.keys_.Clear(); + return this; + } + + public pbc::IPopsicleList ValuesList { + get { return result.values_; } + } + public int ValuesCount { + get { return result.ValuesCount; } + } + public string GetValues(int index) { + return result.GetValues(index); + } + public Builder SetValues(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.values_[index] = value; + return this; + } + public Builder AddValues(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.values_.Add(value); + return this; + } + public Builder AddRangeValues(scg::IEnumerable values) { + base.AddRange(values, result.values_); + return this; + } + public Builder ClearValues() { + result.values_.Clear(); + return this; + } + } + static StringMapProperty() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class PhysicalParameters : pb::GeneratedMessage { + private static readonly PhysicalParameters defaultInstance = new Builder().BuildPartial(); + public static PhysicalParameters DefaultInstance { + get { return defaultInstance; } + } + + public override PhysicalParameters DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override PhysicalParameters ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum Mode { + NONPHYSICAL = 0, + STATIC = 1, + DYNAMICBOX = 2, + DYNAMICSPHERE = 3, + DYNAMICCYLINDER = 4, + CHARACTER = 5, + } + + } + #endregion + + public const int ModeFieldNumber = 2; + private bool hasMode; + private global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode mode_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode.NONPHYSICAL; + public bool HasMode { + get { return hasMode; } + } + public global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode Mode { + get { return mode_; } + } + + public const int DensityFieldNumber = 3; + private bool hasDensity; + private float density_ = 0F; + public bool HasDensity { + get { return hasDensity; } + } + public float Density { + get { return density_; } + } + + public const int FrictionFieldNumber = 4; + private bool hasFriction; + private float friction_ = 0F; + public bool HasFriction { + get { return hasFriction; } + } + public float Friction { + get { return friction_; } + } + + public const int BounceFieldNumber = 5; + private bool hasBounce; + private float bounce_ = 0F; + public bool HasBounce { + get { return hasBounce; } + } + public float Bounce { + get { return bounce_; } + } + + public const int HullFieldNumber = 6; + private int hullMemoizedSerializedSize; + private pbc::PopsicleList hull_ = new pbc::PopsicleList(); + public scg::IList HullList { + get { return pbc::Lists.AsReadOnly(hull_); } + } + public int HullCount { + get { return hull_.Count; } + } + public float GetHull(int index) { + return hull_[index]; + } + + public const int CollideMsgFieldNumber = 16; + private bool hasCollideMsg; + private uint collideMsg_ = 0; + public bool HasCollideMsg { + get { return hasCollideMsg; } + } + [global::System.CLSCompliant(false)] + public uint CollideMsg { + get { return collideMsg_; } + } + + public const int CollideMaskFieldNumber = 17; + private bool hasCollideMask; + private uint collideMask_ = 0; + public bool HasCollideMask { + get { return hasCollideMask; } + } + [global::System.CLSCompliant(false)] + public uint CollideMask { + get { return collideMask_; } + } + + public const int GravityFieldNumber = 18; + private bool hasGravity; + private float gravity_ = 0F; + public bool HasGravity { + get { return hasGravity; } + } + public float Gravity { + get { return gravity_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasMode) { + output.WriteEnum(2, (int) Mode); + } + if (HasDensity) { + output.WriteFloat(3, Density); + } + if (HasFriction) { + output.WriteFloat(4, Friction); + } + if (HasBounce) { + output.WriteFloat(5, Bounce); + } + if (hull_.Count > 0) { + output.WriteRawVarint32(50); + output.WriteRawVarint32((uint) hullMemoizedSerializedSize); + foreach (float element in hull_) { + output.WriteFloatNoTag(element); + } + } + if (HasCollideMsg) { + output.WriteUInt32(16, CollideMsg); + } + if (HasCollideMask) { + output.WriteUInt32(17, CollideMask); + } + if (HasGravity) { + output.WriteFloat(18, Gravity); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasMode) { + size += pb::CodedOutputStream.ComputeEnumSize(2, (int) Mode); + } + if (HasDensity) { + size += pb::CodedOutputStream.ComputeFloatSize(3, Density); + } + if (HasFriction) { + size += pb::CodedOutputStream.ComputeFloatSize(4, Friction); + } + if (HasBounce) { + size += pb::CodedOutputStream.ComputeFloatSize(5, Bounce); + } + { + int dataSize = 0; + dataSize = 4 * hull_.Count; + size += dataSize; + if (hull_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + hullMemoizedSerializedSize = dataSize; + } + if (HasCollideMsg) { + size += pb::CodedOutputStream.ComputeUInt32Size(16, CollideMsg); + } + if (HasCollideMask) { + size += pb::CodedOutputStream.ComputeUInt32Size(17, CollideMask); + } + if (HasGravity) { + size += pb::CodedOutputStream.ComputeFloatSize(18, Gravity); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static PhysicalParameters ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static PhysicalParameters ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static PhysicalParameters ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static PhysicalParameters ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static PhysicalParameters ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static PhysicalParameters ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static PhysicalParameters ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static PhysicalParameters ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static PhysicalParameters ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static PhysicalParameters 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(PhysicalParameters prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + PhysicalParameters result = new PhysicalParameters(); + + protected override PhysicalParameters MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new PhysicalParameters(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Descriptor; } + } + + public override PhysicalParameters DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance; } + } + + public override PhysicalParameters BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.hull_.MakeReadOnly(); + PhysicalParameters returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is PhysicalParameters) { + return MergeFrom((PhysicalParameters) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(PhysicalParameters other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance) return this; + if (other.HasMode) { + Mode = other.Mode; + } + if (other.HasDensity) { + Density = other.Density; + } + if (other.HasFriction) { + Friction = other.Friction; + } + if (other.HasBounce) { + Bounce = other.Bounce; + } + if (other.hull_.Count != 0) { + base.AddRange(other.hull_, result.hull_); + } + if (other.HasCollideMsg) { + CollideMsg = other.CollideMsg; + } + if (other.HasCollideMask) { + CollideMask = other.CollideMask; + } + if (other.HasGravity) { + Gravity = other.Gravity; + } + 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 16: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode), rawValue)) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(2, (ulong) rawValue); + } else { + Mode = (global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode) rawValue; + } + break; + } + case 29: { + Density = input.ReadFloat(); + break; + } + case 37: { + Friction = input.ReadFloat(); + break; + } + case 45: { + Bounce = input.ReadFloat(); + break; + } + case 50: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddHull(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 128: { + CollideMsg = input.ReadUInt32(); + break; + } + case 136: { + CollideMask = input.ReadUInt32(); + break; + } + case 149: { + Gravity = input.ReadFloat(); + break; + } + } + } + } + + + public bool HasMode { + get { return result.HasMode; } + } + public global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode Mode { + get { return result.Mode; } + set { SetMode(value); } + } + public Builder SetMode(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode value) { + result.hasMode = true; + result.mode_ = value; + return this; + } + public Builder ClearMode() { + result.hasMode = false; + result.mode_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode.NONPHYSICAL; + return this; + } + + public bool HasDensity { + get { return result.HasDensity; } + } + public float Density { + get { return result.Density; } + set { SetDensity(value); } + } + public Builder SetDensity(float value) { + result.hasDensity = true; + result.density_ = value; + return this; + } + public Builder ClearDensity() { + result.hasDensity = false; + result.density_ = 0F; + return this; + } + + public bool HasFriction { + get { return result.HasFriction; } + } + public float Friction { + get { return result.Friction; } + set { SetFriction(value); } + } + public Builder SetFriction(float value) { + result.hasFriction = true; + result.friction_ = value; + return this; + } + public Builder ClearFriction() { + result.hasFriction = false; + result.friction_ = 0F; + return this; + } + + public bool HasBounce { + get { return result.HasBounce; } + } + public float Bounce { + get { return result.Bounce; } + set { SetBounce(value); } + } + public Builder SetBounce(float value) { + result.hasBounce = true; + result.bounce_ = value; + return this; + } + public Builder ClearBounce() { + result.hasBounce = false; + result.bounce_ = 0F; + return this; + } + + public pbc::IPopsicleList HullList { + get { return result.hull_; } + } + public int HullCount { + get { return result.HullCount; } + } + public float GetHull(int index) { + return result.GetHull(index); + } + public Builder SetHull(int index, float value) { + result.hull_[index] = value; + return this; + } + public Builder AddHull(float value) { + result.hull_.Add(value); + return this; + } + public Builder AddRangeHull(scg::IEnumerable values) { + base.AddRange(values, result.hull_); + return this; + } + public Builder ClearHull() { + result.hull_.Clear(); + return this; + } + + public bool HasCollideMsg { + get { return result.HasCollideMsg; } + } + [global::System.CLSCompliant(false)] + public uint CollideMsg { + get { return result.CollideMsg; } + set { SetCollideMsg(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetCollideMsg(uint value) { + result.hasCollideMsg = true; + result.collideMsg_ = value; + return this; + } + public Builder ClearCollideMsg() { + result.hasCollideMsg = false; + result.collideMsg_ = 0; + return this; + } + + public bool HasCollideMask { + get { return result.HasCollideMask; } + } + [global::System.CLSCompliant(false)] + public uint CollideMask { + get { return result.CollideMask; } + set { SetCollideMask(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetCollideMask(uint value) { + result.hasCollideMask = true; + result.collideMask_ = value; + return this; + } + public Builder ClearCollideMask() { + result.hasCollideMask = false; + result.collideMask_ = 0; + return this; + } + + public bool HasGravity { + get { return result.HasGravity; } + } + public float Gravity { + get { return result.Gravity; } + set { SetGravity(value); } + } + public Builder SetGravity(float value) { + result.hasGravity = true; + result.gravity_ = value; + return this; + } + public Builder ClearGravity() { + result.hasGravity = false; + result.gravity_ = 0F; + return this; + } + } + static PhysicalParameters() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class LightInfoProperty : pb::GeneratedMessage { + private static readonly LightInfoProperty defaultInstance = new Builder().BuildPartial(); + public static LightInfoProperty DefaultInstance { + get { return defaultInstance; } + } + + public override LightInfoProperty DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override LightInfoProperty ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum LightTypes { + POINT = 0, + SPOTLIGHT = 1, + DIRECTIONAL = 2, + } + + } + #endregion + + public const int DiffuseColorFieldNumber = 3; + private int diffuseColorMemoizedSerializedSize; + private pbc::PopsicleList diffuseColor_ = new pbc::PopsicleList(); + public scg::IList DiffuseColorList { + get { return pbc::Lists.AsReadOnly(diffuseColor_); } + } + public int DiffuseColorCount { + get { return diffuseColor_.Count; } + } + public float GetDiffuseColor(int index) { + return diffuseColor_[index]; + } + + public const int SpecularColorFieldNumber = 4; + private int specularColorMemoizedSerializedSize; + private pbc::PopsicleList specularColor_ = new pbc::PopsicleList(); + public scg::IList SpecularColorList { + get { return pbc::Lists.AsReadOnly(specularColor_); } + } + public int SpecularColorCount { + get { return specularColor_.Count; } + } + public float GetSpecularColor(int index) { + return specularColor_[index]; + } + + public const int PowerFieldNumber = 5; + private bool hasPower; + private float power_ = 0F; + public bool HasPower { + get { return hasPower; } + } + public float Power { + get { return power_; } + } + + public const int AmbientColorFieldNumber = 6; + private int ambientColorMemoizedSerializedSize; + private pbc::PopsicleList ambientColor_ = new pbc::PopsicleList(); + public scg::IList AmbientColorList { + get { return pbc::Lists.AsReadOnly(ambientColor_); } + } + public int AmbientColorCount { + get { return ambientColor_.Count; } + } + public float GetAmbientColor(int index) { + return ambientColor_[index]; + } + + public const int ShadowColorFieldNumber = 7; + private int shadowColorMemoizedSerializedSize; + private pbc::PopsicleList shadowColor_ = new pbc::PopsicleList(); + public scg::IList ShadowColorList { + get { return pbc::Lists.AsReadOnly(shadowColor_); } + } + public int ShadowColorCount { + get { return shadowColor_.Count; } + } + public float GetShadowColor(int index) { + return shadowColor_[index]; + } + + public const int LightRangeFieldNumber = 8; + private bool hasLightRange; + private double lightRange_ = 0D; + public bool HasLightRange { + get { return hasLightRange; } + } + public double LightRange { + get { return lightRange_; } + } + + public const int ConstantFalloffFieldNumber = 9; + private bool hasConstantFalloff; + private float constantFalloff_ = 0F; + public bool HasConstantFalloff { + get { return hasConstantFalloff; } + } + public float ConstantFalloff { + get { return constantFalloff_; } + } + + public const int LinearFalloffFieldNumber = 10; + private bool hasLinearFalloff; + private float linearFalloff_ = 0F; + public bool HasLinearFalloff { + get { return hasLinearFalloff; } + } + public float LinearFalloff { + get { return linearFalloff_; } + } + + public const int QuadraticFalloffFieldNumber = 11; + private bool hasQuadraticFalloff; + private float quadraticFalloff_ = 0F; + public bool HasQuadraticFalloff { + get { return hasQuadraticFalloff; } + } + public float QuadraticFalloff { + get { return quadraticFalloff_; } + } + + public const int ConeInnerRadiansFieldNumber = 12; + private bool hasConeInnerRadians; + private float coneInnerRadians_ = 0F; + public bool HasConeInnerRadians { + get { return hasConeInnerRadians; } + } + public float ConeInnerRadians { + get { return coneInnerRadians_; } + } + + public const int ConeOuterRadiansFieldNumber = 13; + private bool hasConeOuterRadians; + private float coneOuterRadians_ = 0F; + public bool HasConeOuterRadians { + get { return hasConeOuterRadians; } + } + public float ConeOuterRadians { + get { return coneOuterRadians_; } + } + + public const int ConeFalloffFieldNumber = 14; + private bool hasConeFalloff; + private float coneFalloff_ = 0F; + public bool HasConeFalloff { + get { return hasConeFalloff; } + } + public float ConeFalloff { + get { return coneFalloff_; } + } + + public const int TypeFieldNumber = 15; + private bool hasType; + private global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes type_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes.POINT; + public bool HasType { + get { return hasType; } + } + public global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes Type { + get { return type_; } + } + + public const int CastsShadowFieldNumber = 16; + private bool hasCastsShadow; + private bool castsShadow_ = false; + public bool HasCastsShadow { + get { return hasCastsShadow; } + } + public bool CastsShadow { + get { return castsShadow_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (diffuseColor_.Count > 0) { + output.WriteRawVarint32(26); + output.WriteRawVarint32((uint) diffuseColorMemoizedSerializedSize); + foreach (float element in diffuseColor_) { + output.WriteFloatNoTag(element); + } + } + if (specularColor_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) specularColorMemoizedSerializedSize); + foreach (float element in specularColor_) { + output.WriteFloatNoTag(element); + } + } + if (HasPower) { + output.WriteFloat(5, Power); + } + if (ambientColor_.Count > 0) { + output.WriteRawVarint32(50); + output.WriteRawVarint32((uint) ambientColorMemoizedSerializedSize); + foreach (float element in ambientColor_) { + output.WriteFloatNoTag(element); + } + } + if (shadowColor_.Count > 0) { + output.WriteRawVarint32(58); + output.WriteRawVarint32((uint) shadowColorMemoizedSerializedSize); + foreach (float element in shadowColor_) { + output.WriteFloatNoTag(element); + } + } + if (HasLightRange) { + output.WriteDouble(8, LightRange); + } + if (HasConstantFalloff) { + output.WriteFloat(9, ConstantFalloff); + } + if (HasLinearFalloff) { + output.WriteFloat(10, LinearFalloff); + } + if (HasQuadraticFalloff) { + output.WriteFloat(11, QuadraticFalloff); + } + if (HasConeInnerRadians) { + output.WriteFloat(12, ConeInnerRadians); + } + if (HasConeOuterRadians) { + output.WriteFloat(13, ConeOuterRadians); + } + if (HasConeFalloff) { + output.WriteFloat(14, ConeFalloff); + } + if (HasType) { + output.WriteEnum(15, (int) Type); + } + if (HasCastsShadow) { + output.WriteBool(16, CastsShadow); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + dataSize = 4 * diffuseColor_.Count; + size += dataSize; + if (diffuseColor_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + diffuseColorMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * specularColor_.Count; + size += dataSize; + if (specularColor_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + specularColorMemoizedSerializedSize = dataSize; + } + if (HasPower) { + size += pb::CodedOutputStream.ComputeFloatSize(5, Power); + } + { + int dataSize = 0; + dataSize = 4 * ambientColor_.Count; + size += dataSize; + if (ambientColor_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + ambientColorMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * shadowColor_.Count; + size += dataSize; + if (shadowColor_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + shadowColorMemoizedSerializedSize = dataSize; + } + if (HasLightRange) { + size += pb::CodedOutputStream.ComputeDoubleSize(8, LightRange); + } + if (HasConstantFalloff) { + size += pb::CodedOutputStream.ComputeFloatSize(9, ConstantFalloff); + } + if (HasLinearFalloff) { + size += pb::CodedOutputStream.ComputeFloatSize(10, LinearFalloff); + } + if (HasQuadraticFalloff) { + size += pb::CodedOutputStream.ComputeFloatSize(11, QuadraticFalloff); + } + if (HasConeInnerRadians) { + size += pb::CodedOutputStream.ComputeFloatSize(12, ConeInnerRadians); + } + if (HasConeOuterRadians) { + size += pb::CodedOutputStream.ComputeFloatSize(13, ConeOuterRadians); + } + if (HasConeFalloff) { + size += pb::CodedOutputStream.ComputeFloatSize(14, ConeFalloff); + } + if (HasType) { + size += pb::CodedOutputStream.ComputeEnumSize(15, (int) Type); + } + if (HasCastsShadow) { + size += pb::CodedOutputStream.ComputeBoolSize(16, CastsShadow); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static LightInfoProperty ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static LightInfoProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static LightInfoProperty ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static LightInfoProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static LightInfoProperty ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static LightInfoProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static LightInfoProperty ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static LightInfoProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static LightInfoProperty ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static LightInfoProperty 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(LightInfoProperty prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + LightInfoProperty result = new LightInfoProperty(); + + protected override LightInfoProperty MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new LightInfoProperty(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Descriptor; } + } + + public override LightInfoProperty DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance; } + } + + public override LightInfoProperty BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.diffuseColor_.MakeReadOnly(); + result.specularColor_.MakeReadOnly(); + result.ambientColor_.MakeReadOnly(); + result.shadowColor_.MakeReadOnly(); + LightInfoProperty returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is LightInfoProperty) { + return MergeFrom((LightInfoProperty) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(LightInfoProperty other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance) return this; + if (other.diffuseColor_.Count != 0) { + base.AddRange(other.diffuseColor_, result.diffuseColor_); + } + if (other.specularColor_.Count != 0) { + base.AddRange(other.specularColor_, result.specularColor_); + } + if (other.HasPower) { + Power = other.Power; + } + if (other.ambientColor_.Count != 0) { + base.AddRange(other.ambientColor_, result.ambientColor_); + } + if (other.shadowColor_.Count != 0) { + base.AddRange(other.shadowColor_, result.shadowColor_); + } + if (other.HasLightRange) { + LightRange = other.LightRange; + } + if (other.HasConstantFalloff) { + ConstantFalloff = other.ConstantFalloff; + } + if (other.HasLinearFalloff) { + LinearFalloff = other.LinearFalloff; + } + if (other.HasQuadraticFalloff) { + QuadraticFalloff = other.QuadraticFalloff; + } + if (other.HasConeInnerRadians) { + ConeInnerRadians = other.ConeInnerRadians; + } + if (other.HasConeOuterRadians) { + ConeOuterRadians = other.ConeOuterRadians; + } + if (other.HasConeFalloff) { + ConeFalloff = other.ConeFalloff; + } + if (other.HasType) { + Type = other.Type; + } + if (other.HasCastsShadow) { + CastsShadow = other.CastsShadow; + } + 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 26: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddDiffuseColor(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddSpecularColor(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 45: { + Power = input.ReadFloat(); + break; + } + case 50: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddAmbientColor(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 58: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddShadowColor(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 65: { + LightRange = input.ReadDouble(); + break; + } + case 77: { + ConstantFalloff = input.ReadFloat(); + break; + } + case 85: { + LinearFalloff = input.ReadFloat(); + break; + } + case 93: { + QuadraticFalloff = input.ReadFloat(); + break; + } + case 101: { + ConeInnerRadians = input.ReadFloat(); + break; + } + case 109: { + ConeOuterRadians = input.ReadFloat(); + break; + } + case 117: { + ConeFalloff = input.ReadFloat(); + break; + } + case 120: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes), rawValue)) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(15, (ulong) rawValue); + } else { + Type = (global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes) rawValue; + } + break; + } + case 128: { + CastsShadow = input.ReadBool(); + break; + } + } + } + } + + + public pbc::IPopsicleList DiffuseColorList { + get { return result.diffuseColor_; } + } + public int DiffuseColorCount { + get { return result.DiffuseColorCount; } + } + public float GetDiffuseColor(int index) { + return result.GetDiffuseColor(index); + } + public Builder SetDiffuseColor(int index, float value) { + result.diffuseColor_[index] = value; + return this; + } + public Builder AddDiffuseColor(float value) { + result.diffuseColor_.Add(value); + return this; + } + public Builder AddRangeDiffuseColor(scg::IEnumerable values) { + base.AddRange(values, result.diffuseColor_); + return this; + } + public Builder ClearDiffuseColor() { + result.diffuseColor_.Clear(); + return this; + } + + public pbc::IPopsicleList SpecularColorList { + get { return result.specularColor_; } + } + public int SpecularColorCount { + get { return result.SpecularColorCount; } + } + public float GetSpecularColor(int index) { + return result.GetSpecularColor(index); + } + public Builder SetSpecularColor(int index, float value) { + result.specularColor_[index] = value; + return this; + } + public Builder AddSpecularColor(float value) { + result.specularColor_.Add(value); + return this; + } + public Builder AddRangeSpecularColor(scg::IEnumerable values) { + base.AddRange(values, result.specularColor_); + return this; + } + public Builder ClearSpecularColor() { + result.specularColor_.Clear(); + return this; + } + + public bool HasPower { + get { return result.HasPower; } + } + public float Power { + get { return result.Power; } + set { SetPower(value); } + } + public Builder SetPower(float value) { + result.hasPower = true; + result.power_ = value; + return this; + } + public Builder ClearPower() { + result.hasPower = false; + result.power_ = 0F; + return this; + } + + public pbc::IPopsicleList AmbientColorList { + get { return result.ambientColor_; } + } + public int AmbientColorCount { + get { return result.AmbientColorCount; } + } + public float GetAmbientColor(int index) { + return result.GetAmbientColor(index); + } + public Builder SetAmbientColor(int index, float value) { + result.ambientColor_[index] = value; + return this; + } + public Builder AddAmbientColor(float value) { + result.ambientColor_.Add(value); + return this; + } + public Builder AddRangeAmbientColor(scg::IEnumerable values) { + base.AddRange(values, result.ambientColor_); + return this; + } + public Builder ClearAmbientColor() { + result.ambientColor_.Clear(); + return this; + } + + public pbc::IPopsicleList ShadowColorList { + get { return result.shadowColor_; } + } + public int ShadowColorCount { + get { return result.ShadowColorCount; } + } + public float GetShadowColor(int index) { + return result.GetShadowColor(index); + } + public Builder SetShadowColor(int index, float value) { + result.shadowColor_[index] = value; + return this; + } + public Builder AddShadowColor(float value) { + result.shadowColor_.Add(value); + return this; + } + public Builder AddRangeShadowColor(scg::IEnumerable values) { + base.AddRange(values, result.shadowColor_); + return this; + } + public Builder ClearShadowColor() { + result.shadowColor_.Clear(); + return this; + } + + public bool HasLightRange { + get { return result.HasLightRange; } + } + public double LightRange { + get { return result.LightRange; } + set { SetLightRange(value); } + } + public Builder SetLightRange(double value) { + result.hasLightRange = true; + result.lightRange_ = value; + return this; + } + public Builder ClearLightRange() { + result.hasLightRange = false; + result.lightRange_ = 0D; + return this; + } + + public bool HasConstantFalloff { + get { return result.HasConstantFalloff; } + } + public float ConstantFalloff { + get { return result.ConstantFalloff; } + set { SetConstantFalloff(value); } + } + public Builder SetConstantFalloff(float value) { + result.hasConstantFalloff = true; + result.constantFalloff_ = value; + return this; + } + public Builder ClearConstantFalloff() { + result.hasConstantFalloff = false; + result.constantFalloff_ = 0F; + return this; + } + + public bool HasLinearFalloff { + get { return result.HasLinearFalloff; } + } + public float LinearFalloff { + get { return result.LinearFalloff; } + set { SetLinearFalloff(value); } + } + public Builder SetLinearFalloff(float value) { + result.hasLinearFalloff = true; + result.linearFalloff_ = value; + return this; + } + public Builder ClearLinearFalloff() { + result.hasLinearFalloff = false; + result.linearFalloff_ = 0F; + return this; + } + + public bool HasQuadraticFalloff { + get { return result.HasQuadraticFalloff; } + } + public float QuadraticFalloff { + get { return result.QuadraticFalloff; } + set { SetQuadraticFalloff(value); } + } + public Builder SetQuadraticFalloff(float value) { + result.hasQuadraticFalloff = true; + result.quadraticFalloff_ = value; + return this; + } + public Builder ClearQuadraticFalloff() { + result.hasQuadraticFalloff = false; + result.quadraticFalloff_ = 0F; + return this; + } + + public bool HasConeInnerRadians { + get { return result.HasConeInnerRadians; } + } + public float ConeInnerRadians { + get { return result.ConeInnerRadians; } + set { SetConeInnerRadians(value); } + } + public Builder SetConeInnerRadians(float value) { + result.hasConeInnerRadians = true; + result.coneInnerRadians_ = value; + return this; + } + public Builder ClearConeInnerRadians() { + result.hasConeInnerRadians = false; + result.coneInnerRadians_ = 0F; + return this; + } + + public bool HasConeOuterRadians { + get { return result.HasConeOuterRadians; } + } + public float ConeOuterRadians { + get { return result.ConeOuterRadians; } + set { SetConeOuterRadians(value); } + } + public Builder SetConeOuterRadians(float value) { + result.hasConeOuterRadians = true; + result.coneOuterRadians_ = value; + return this; + } + public Builder ClearConeOuterRadians() { + result.hasConeOuterRadians = false; + result.coneOuterRadians_ = 0F; + return this; + } + + public bool HasConeFalloff { + get { return result.HasConeFalloff; } + } + public float ConeFalloff { + get { return result.ConeFalloff; } + set { SetConeFalloff(value); } + } + public Builder SetConeFalloff(float value) { + result.hasConeFalloff = true; + result.coneFalloff_ = value; + return this; + } + public Builder ClearConeFalloff() { + result.hasConeFalloff = false; + result.coneFalloff_ = 0F; + return this; + } + + public bool HasType { + get { return result.HasType; } + } + public global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes Type { + get { return result.Type; } + set { SetType(value); } + } + public Builder SetType(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes value) { + result.hasType = true; + result.type_ = value; + return this; + } + public Builder ClearType() { + result.hasType = false; + result.type_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes.POINT; + return this; + } + + public bool HasCastsShadow { + get { return result.HasCastsShadow; } + } + public bool CastsShadow { + get { return result.CastsShadow; } + set { SetCastsShadow(value); } + } + public Builder SetCastsShadow(bool value) { + result.hasCastsShadow = true; + result.castsShadow_ = value; + return this; + } + public Builder ClearCastsShadow() { + result.hasCastsShadow = false; + result.castsShadow_ = false; + return this; + } + } + static LightInfoProperty() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class ParentProperty : pb::GeneratedMessage { + private static readonly ParentProperty defaultInstance = new Builder().BuildPartial(); + public static ParentProperty DefaultInstance { + get { return defaultInstance; } + } + + public override ParentProperty DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ParentProperty ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__FieldAccessorTable; } + } + + public const int ValueFieldNumber = 10; + private bool hasValue; + private pb::ByteString value_ = pb::ByteString.Empty; + public bool HasValue { + get { return hasValue; } + } + public pb::ByteString Value { + get { return value_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasValue) { + output.WriteBytes(10, Value); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasValue) { + size += pb::CodedOutputStream.ComputeBytesSize(10, Value); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ParentProperty ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ParentProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ParentProperty ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ParentProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ParentProperty ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ParentProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ParentProperty ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ParentProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ParentProperty ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ParentProperty 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(ParentProperty prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ParentProperty result = new ParentProperty(); + + protected override ParentProperty MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ParentProperty(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ParentProperty.Descriptor; } + } + + public override ParentProperty DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ParentProperty.DefaultInstance; } + } + + public override ParentProperty BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + ParentProperty returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ParentProperty) { + return MergeFrom((ParentProperty) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ParentProperty other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.ParentProperty.DefaultInstance) return this; + if (other.HasValue) { + Value = other.Value; + } + 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 82: { + Value = input.ReadBytes(); + break; + } + } + } + } + + + public bool HasValue { + get { return result.HasValue; } + } + public pb::ByteString Value { + get { return result.Value; } + set { SetValue(value); } + } + public Builder SetValue(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasValue = true; + result.value_ = value; + return this; + } + public Builder ClearValue() { + result.hasValue = false; + result.value_ = pb::ByteString.Empty; + return this; + } + } + static ParentProperty() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class UUIDListProperty : pb::GeneratedMessage { + private static readonly UUIDListProperty defaultInstance = new Builder().BuildPartial(); + public static UUIDListProperty DefaultInstance { + get { return defaultInstance; } + } + + public override UUIDListProperty DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override UUIDListProperty ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__FieldAccessorTable; } + } + + public const int ValueFieldNumber = 10; + private pbc::PopsicleList value_ = new pbc::PopsicleList(); + public scg::IList ValueList { + get { return pbc::Lists.AsReadOnly(value_); } + } + public int ValueCount { + get { return value_.Count; } + } + public pb::ByteString GetValue(int index) { + return value_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (value_.Count > 0) { + foreach (pb::ByteString element in value_) { + output.WriteBytes(10, element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + foreach (pb::ByteString element in ValueList) { + dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); + } + size += dataSize; + size += 1 * value_.Count; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static UUIDListProperty ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static UUIDListProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static UUIDListProperty ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static UUIDListProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static UUIDListProperty ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static UUIDListProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static UUIDListProperty ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static UUIDListProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static UUIDListProperty ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static UUIDListProperty 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(UUIDListProperty prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + UUIDListProperty result = new UUIDListProperty(); + + protected override UUIDListProperty MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new UUIDListProperty(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty.Descriptor; } + } + + public override UUIDListProperty DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty.DefaultInstance; } + } + + public override UUIDListProperty BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.value_.MakeReadOnly(); + UUIDListProperty returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is UUIDListProperty) { + return MergeFrom((UUIDListProperty) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(UUIDListProperty other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty.DefaultInstance) return this; + if (other.value_.Count != 0) { + base.AddRange(other.value_, result.value_); + } + 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 82: { + AddValue(input.ReadBytes()); + break; + } + } + } + } + + + public pbc::IPopsicleList ValueList { + get { return result.value_; } + } + public int ValueCount { + get { return result.ValueCount; } + } + public pb::ByteString GetValue(int index) { + return result.GetValue(index); + } + public Builder SetValue(int index, pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.value_[index] = value; + return this; + } + public Builder AddValue(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.value_.Add(value); + return this; + } + public Builder AddRangeValue(scg::IEnumerable values) { + base.AddRange(values, result.value_); + return this; + } + public Builder ClearValue() { + result.value_.Clear(); + return this; + } + } + static UUIDListProperty() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class ConnectToSpace : pb::GeneratedMessage { + private static readonly ConnectToSpace defaultInstance = new Builder().BuildPartial(); + public static ConnectToSpace DefaultInstance { + get { return defaultInstance; } + } + + public override ConnectToSpace DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ConnectToSpace ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__FieldAccessorTable; } + } + + public const int SpaceIdFieldNumber = 1; + private bool hasSpaceId; + private pb::ByteString spaceId_ = pb::ByteString.Empty; + public bool HasSpaceId { + get { return hasSpaceId; } + } + public pb::ByteString SpaceId { + get { return spaceId_; } + } + + public const int ObjectUuidEvidenceFieldNumber = 2; + private bool hasObjectUuidEvidence; + private pb::ByteString objectUuidEvidence_ = pb::ByteString.Empty; + public bool HasObjectUuidEvidence { + get { return hasObjectUuidEvidence; } + } + public pb::ByteString ObjectUuidEvidence { + get { return objectUuidEvidence_; } + } + + public const int RequestedObjectLocFieldNumber = 3; + private bool hasRequestedObjectLoc; + private global::Sirikata.Protocol._PBJ_Internal.ObjLoc requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; + public bool HasRequestedObjectLoc { + get { return hasRequestedObjectLoc; } + } + public global::Sirikata.Protocol._PBJ_Internal.ObjLoc RequestedObjectLoc { + get { return requestedObjectLoc_; } + } + + public const int BoundingSphereFieldNumber = 4; + private int boundingSphereMemoizedSerializedSize; + private pbc::PopsicleList boundingSphere_ = new pbc::PopsicleList(); + public scg::IList BoundingSphereList { + get { return pbc::Lists.AsReadOnly(boundingSphere_); } + } + public int BoundingSphereCount { + get { return boundingSphere_.Count; } + } + public float GetBoundingSphere(int index) { + return boundingSphere_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasSpaceId) { + output.WriteBytes(1, SpaceId); + } + if (HasObjectUuidEvidence) { + output.WriteBytes(2, ObjectUuidEvidence); + } + if (HasRequestedObjectLoc) { + output.WriteMessage(3, RequestedObjectLoc); + } + if (boundingSphere_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) boundingSphereMemoizedSerializedSize); + foreach (float element in boundingSphere_) { + output.WriteFloatNoTag(element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasSpaceId) { + size += pb::CodedOutputStream.ComputeBytesSize(1, SpaceId); + } + if (HasObjectUuidEvidence) { + size += pb::CodedOutputStream.ComputeBytesSize(2, ObjectUuidEvidence); + } + if (HasRequestedObjectLoc) { + size += pb::CodedOutputStream.ComputeMessageSize(3, RequestedObjectLoc); + } + { + int dataSize = 0; + dataSize = 4 * boundingSphere_.Count; + size += dataSize; + if (boundingSphere_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + boundingSphereMemoizedSerializedSize = dataSize; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ConnectToSpace ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ConnectToSpace ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ConnectToSpace ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ConnectToSpace ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ConnectToSpace ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ConnectToSpace ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ConnectToSpace ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ConnectToSpace ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ConnectToSpace ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ConnectToSpace 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(ConnectToSpace prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ConnectToSpace result = new ConnectToSpace(); + + protected override ConnectToSpace MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ConnectToSpace(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Descriptor; } + } + + public override ConnectToSpace DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.DefaultInstance; } + } + + public override ConnectToSpace BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.boundingSphere_.MakeReadOnly(); + ConnectToSpace returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ConnectToSpace) { + return MergeFrom((ConnectToSpace) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ConnectToSpace other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.DefaultInstance) return this; + if (other.HasSpaceId) { + SpaceId = other.SpaceId; + } + if (other.HasObjectUuidEvidence) { + ObjectUuidEvidence = other.ObjectUuidEvidence; + } + if (other.HasRequestedObjectLoc) { + MergeRequestedObjectLoc(other.RequestedObjectLoc); + } + if (other.boundingSphere_.Count != 0) { + base.AddRange(other.boundingSphere_, result.boundingSphere_); + } + 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: { + SpaceId = input.ReadBytes(); + break; + } + case 18: { + ObjectUuidEvidence = input.ReadBytes(); + break; + } + case 26: { + global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(); + if (HasRequestedObjectLoc) { + subBuilder.MergeFrom(RequestedObjectLoc); + } + input.ReadMessage(subBuilder, extensionRegistry); + RequestedObjectLoc = subBuilder.BuildPartial(); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddBoundingSphere(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + } + } + } + + + public bool HasSpaceId { + get { return result.HasSpaceId; } + } + public pb::ByteString SpaceId { + get { return result.SpaceId; } + set { SetSpaceId(value); } + } + public Builder SetSpaceId(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasSpaceId = true; + result.spaceId_ = value; + return this; + } + public Builder ClearSpaceId() { + result.hasSpaceId = false; + result.spaceId_ = pb::ByteString.Empty; + return this; + } + + public bool HasObjectUuidEvidence { + get { return result.HasObjectUuidEvidence; } + } + public pb::ByteString ObjectUuidEvidence { + get { return result.ObjectUuidEvidence; } + set { SetObjectUuidEvidence(value); } + } + public Builder SetObjectUuidEvidence(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectUuidEvidence = true; + result.objectUuidEvidence_ = value; + return this; + } + public Builder ClearObjectUuidEvidence() { + result.hasObjectUuidEvidence = false; + result.objectUuidEvidence_ = pb::ByteString.Empty; + return this; + } + + public bool HasRequestedObjectLoc { + get { return result.HasRequestedObjectLoc; } + } + public global::Sirikata.Protocol._PBJ_Internal.ObjLoc RequestedObjectLoc { + get { return result.RequestedObjectLoc; } + set { SetRequestedObjectLoc(value); } + } + public Builder SetRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasRequestedObjectLoc = true; + result.requestedObjectLoc_ = value; + return this; + } + public Builder SetRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasRequestedObjectLoc = true; + result.requestedObjectLoc_ = builderForValue.Build(); + return this; + } + public Builder MergeRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasRequestedObjectLoc && + result.requestedObjectLoc_ != global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance) { + result.requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(result.requestedObjectLoc_).MergeFrom(value).BuildPartial(); + } else { + result.requestedObjectLoc_ = value; + } + result.hasRequestedObjectLoc = true; + return this; + } + public Builder ClearRequestedObjectLoc() { + result.hasRequestedObjectLoc = false; + result.requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; + return this; + } + + public pbc::IPopsicleList BoundingSphereList { + get { return result.boundingSphere_; } + } + public int BoundingSphereCount { + get { return result.BoundingSphereCount; } + } + public float GetBoundingSphere(int index) { + return result.GetBoundingSphere(index); + } + public Builder SetBoundingSphere(int index, float value) { + result.boundingSphere_[index] = value; + return this; + } + public Builder AddBoundingSphere(float value) { + result.boundingSphere_.Add(value); + return this; + } + public Builder AddRangeBoundingSphere(scg::IEnumerable values) { + base.AddRange(values, result.boundingSphere_); + return this; + } + public Builder ClearBoundingSphere() { + result.boundingSphere_.Clear(); + return this; + } + } + static ConnectToSpace() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class CreateObject : pb::GeneratedMessage { + private static readonly CreateObject defaultInstance = new Builder().BuildPartial(); + public static CreateObject DefaultInstance { + get { return defaultInstance; } + } + + public override CreateObject DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CreateObject ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__FieldAccessorTable; } + } + + public const int ObjectUuidFieldNumber = 1; + private bool hasObjectUuid; + private pb::ByteString objectUuid_ = pb::ByteString.Empty; + public bool HasObjectUuid { + get { return hasObjectUuid; } + } + public pb::ByteString ObjectUuid { + get { return objectUuid_; } + } + + public const int SpacePropertiesFieldNumber = 2; + private pbc::PopsicleList spaceProperties_ = new pbc::PopsicleList(); + public scg::IList SpacePropertiesList { + get { return spaceProperties_; } + } + public int SpacePropertiesCount { + get { return spaceProperties_.Count; } + } + public global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace GetSpaceProperties(int index) { + return spaceProperties_[index]; + } + + public const int MeshFieldNumber = 3; + private bool hasMesh; + private string mesh_ = ""; + public bool HasMesh { + get { return hasMesh; } + } + public string Mesh { + get { return mesh_; } + } + + public const int ScaleFieldNumber = 4; + private int scaleMemoizedSerializedSize; + private pbc::PopsicleList scale_ = new pbc::PopsicleList(); + public scg::IList ScaleList { + get { return pbc::Lists.AsReadOnly(scale_); } + } + public int ScaleCount { + get { return scale_.Count; } + } + public float GetScale(int index) { + return scale_[index]; + } + + public const int WeburlFieldNumber = 5; + private bool hasWeburl; + private string weburl_ = ""; + public bool HasWeburl { + get { return hasWeburl; } + } + public string Weburl { + get { return weburl_; } + } + + public const int LightInfoFieldNumber = 6; + private bool hasLightInfo; + private global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty lightInfo_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance; + public bool HasLightInfo { + get { return hasLightInfo; } + } + public global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty LightInfo { + get { return lightInfo_; } + } + + public const int CameraFieldNumber = 7; + private bool hasCamera; + private bool camera_ = false; + public bool HasCamera { + get { return hasCamera; } + } + public bool Camera { + get { return camera_; } + } + + public const int PhysicalFieldNumber = 8; + private bool hasPhysical; + private global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters physical_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance; + public bool HasPhysical { + get { return hasPhysical; } + } + public global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters Physical { + get { return physical_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasObjectUuid) { + output.WriteBytes(1, ObjectUuid); + } + foreach (global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace element in SpacePropertiesList) { + output.WriteMessage(2, element); + } + if (HasMesh) { + output.WriteString(3, Mesh); + } + if (scale_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) scaleMemoizedSerializedSize); + foreach (float element in scale_) { + output.WriteFloatNoTag(element); + } + } + if (HasWeburl) { + output.WriteString(5, Weburl); + } + if (HasLightInfo) { + output.WriteMessage(6, LightInfo); + } + if (HasCamera) { + output.WriteBool(7, Camera); + } + if (HasPhysical) { + output.WriteMessage(8, Physical); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasObjectUuid) { + size += pb::CodedOutputStream.ComputeBytesSize(1, ObjectUuid); + } + foreach (global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace element in SpacePropertiesList) { + size += pb::CodedOutputStream.ComputeMessageSize(2, element); + } + if (HasMesh) { + size += pb::CodedOutputStream.ComputeStringSize(3, Mesh); + } + { + int dataSize = 0; + dataSize = 4 * scale_.Count; + size += dataSize; + if (scale_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + scaleMemoizedSerializedSize = dataSize; + } + if (HasWeburl) { + size += pb::CodedOutputStream.ComputeStringSize(5, Weburl); + } + if (HasLightInfo) { + size += pb::CodedOutputStream.ComputeMessageSize(6, LightInfo); + } + if (HasCamera) { + size += pb::CodedOutputStream.ComputeBoolSize(7, Camera); + } + if (HasPhysical) { + size += pb::CodedOutputStream.ComputeMessageSize(8, Physical); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static CreateObject ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CreateObject ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CreateObject ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CreateObject ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CreateObject ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CreateObject ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CreateObject ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static CreateObject ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static CreateObject ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CreateObject 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(CreateObject prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CreateObject result = new CreateObject(); + + protected override CreateObject MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CreateObject(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.CreateObject.Descriptor; } + } + + public override CreateObject DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.CreateObject.DefaultInstance; } + } + + public override CreateObject BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.spaceProperties_.MakeReadOnly(); + result.scale_.MakeReadOnly(); + CreateObject returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is CreateObject) { + return MergeFrom((CreateObject) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(CreateObject other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.CreateObject.DefaultInstance) return this; + if (other.HasObjectUuid) { + ObjectUuid = other.ObjectUuid; + } + if (other.spaceProperties_.Count != 0) { + base.AddRange(other.spaceProperties_, result.spaceProperties_); + } + if (other.HasMesh) { + Mesh = other.Mesh; + } + if (other.scale_.Count != 0) { + base.AddRange(other.scale_, result.scale_); + } + if (other.HasWeburl) { + Weburl = other.Weburl; + } + if (other.HasLightInfo) { + MergeLightInfo(other.LightInfo); + } + if (other.HasCamera) { + Camera = other.Camera; + } + if (other.HasPhysical) { + MergePhysical(other.Physical); + } + 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: { + ObjectUuid = input.ReadBytes(); + break; + } + case 18: { + global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddSpaceProperties(subBuilder.BuildPartial()); + break; + } + case 26: { + Mesh = input.ReadString(); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddScale(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 42: { + Weburl = input.ReadString(); + break; + } + case 50: { + global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.CreateBuilder(); + if (HasLightInfo) { + subBuilder.MergeFrom(LightInfo); + } + input.ReadMessage(subBuilder, extensionRegistry); + LightInfo = subBuilder.BuildPartial(); + break; + } + case 56: { + Camera = input.ReadBool(); + break; + } + case 66: { + global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.CreateBuilder(); + if (HasPhysical) { + subBuilder.MergeFrom(Physical); + } + input.ReadMessage(subBuilder, extensionRegistry); + Physical = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasObjectUuid { + get { return result.HasObjectUuid; } + } + public pb::ByteString ObjectUuid { + get { return result.ObjectUuid; } + set { SetObjectUuid(value); } + } + public Builder SetObjectUuid(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectUuid = true; + result.objectUuid_ = value; + return this; + } + public Builder ClearObjectUuid() { + result.hasObjectUuid = false; + result.objectUuid_ = pb::ByteString.Empty; + return this; + } + + public pbc::IPopsicleList SpacePropertiesList { + get { return result.spaceProperties_; } + } + public int SpacePropertiesCount { + get { return result.SpacePropertiesCount; } + } + public global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace GetSpaceProperties(int index) { + return result.GetSpaceProperties(index); + } + public Builder SetSpaceProperties(int index, global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.spaceProperties_[index] = value; + return this; + } + public Builder SetSpaceProperties(int index, global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.spaceProperties_[index] = builderForValue.Build(); + return this; + } + public Builder AddSpaceProperties(global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.spaceProperties_.Add(value); + return this; + } + public Builder AddSpaceProperties(global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.spaceProperties_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeSpaceProperties(scg::IEnumerable values) { + base.AddRange(values, result.spaceProperties_); + return this; + } + public Builder ClearSpaceProperties() { + result.spaceProperties_.Clear(); + return this; + } + + public bool HasMesh { + get { return result.HasMesh; } + } + public string Mesh { + get { return result.Mesh; } + set { SetMesh(value); } + } + public Builder SetMesh(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasMesh = true; + result.mesh_ = value; + return this; + } + public Builder ClearMesh() { + result.hasMesh = false; + result.mesh_ = ""; + return this; + } + + public pbc::IPopsicleList ScaleList { + get { return result.scale_; } + } + public int ScaleCount { + get { return result.ScaleCount; } + } + public float GetScale(int index) { + return result.GetScale(index); + } + public Builder SetScale(int index, float value) { + result.scale_[index] = value; + return this; + } + public Builder AddScale(float value) { + result.scale_.Add(value); + return this; + } + public Builder AddRangeScale(scg::IEnumerable values) { + base.AddRange(values, result.scale_); + return this; + } + public Builder ClearScale() { + result.scale_.Clear(); + return this; + } + + public bool HasWeburl { + get { return result.HasWeburl; } + } + public string Weburl { + get { return result.Weburl; } + set { SetWeburl(value); } + } + public Builder SetWeburl(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasWeburl = true; + result.weburl_ = value; + return this; + } + public Builder ClearWeburl() { + result.hasWeburl = false; + result.weburl_ = ""; + return this; + } + + public bool HasLightInfo { + get { return result.HasLightInfo; } + } + public global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty LightInfo { + get { return result.LightInfo; } + set { SetLightInfo(value); } + } + public Builder SetLightInfo(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasLightInfo = true; + result.lightInfo_ = value; + return this; + } + public Builder SetLightInfo(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasLightInfo = true; + result.lightInfo_ = builderForValue.Build(); + return this; + } + public Builder MergeLightInfo(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasLightInfo && + result.lightInfo_ != global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance) { + result.lightInfo_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.CreateBuilder(result.lightInfo_).MergeFrom(value).BuildPartial(); + } else { + result.lightInfo_ = value; + } + result.hasLightInfo = true; + return this; + } + public Builder ClearLightInfo() { + result.hasLightInfo = false; + result.lightInfo_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance; + return this; + } + + public bool HasCamera { + get { return result.HasCamera; } + } + public bool Camera { + get { return result.Camera; } + set { SetCamera(value); } + } + public Builder SetCamera(bool value) { + result.hasCamera = true; + result.camera_ = value; + return this; + } + public Builder ClearCamera() { + result.hasCamera = false; + result.camera_ = false; + return this; + } + + public bool HasPhysical { + get { return result.HasPhysical; } + } + public global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters Physical { + get { return result.Physical; } + set { SetPhysical(value); } + } + public Builder SetPhysical(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasPhysical = true; + result.physical_ = value; + return this; + } + public Builder SetPhysical(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasPhysical = true; + result.physical_ = builderForValue.Build(); + return this; + } + public Builder MergePhysical(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasPhysical && + result.physical_ != global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance) { + result.physical_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.CreateBuilder(result.physical_).MergeFrom(value).BuildPartial(); + } else { + result.physical_ = value; + } + result.hasPhysical = true; + return this; + } + public Builder ClearPhysical() { + result.hasPhysical = false; + result.physical_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance; + return this; + } + } + static CreateObject() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + #endregion + +} diff --git a/OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs new file mode 100644 index 0000000..9c0e3e7 --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs @@ -0,0 +1,3907 @@ +using pbd = global::Google.ProtocolBuffers.Descriptors; +using pb = global::Google.ProtocolBuffers; +namespace Sirikata.Protocol { + public class MessageBody : PBJ.IMessage { + protected _PBJ_Internal.MessageBody super; + public _PBJ_Internal.MessageBody _PBJSuper{ get { return super;} } + public MessageBody() { + super=new _PBJ_Internal.MessageBody(); + } + public MessageBody(_PBJ_Internal.MessageBody reference) { + super=reference; + } + public static MessageBody defaultInstance= new MessageBody (_PBJ_Internal.MessageBody.DefaultInstance); + public static MessageBody DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.MessageBody.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int MessageNamesFieldTag=9; + public int MessageNamesCount { get { return super.MessageNamesCount;} } + public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));} + public string MessageNames(int index) { + return (string)PBJ._PBJ.CastString(super.GetMessageNames(index)); + } + public const int MessageArgumentsFieldTag=10; + public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} } + public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));} + public pb::ByteString MessageArguments(int index) { + return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index)); + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(MessageBody prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static MessageBody ParseFrom(pb::ByteString data) { + return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data)); + } + public static MessageBody ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er)); + } + public static MessageBody ParseFrom(byte[] data) { + return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data)); + } + public static MessageBody ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er)); + } + public static MessageBody ParseFrom(global::System.IO.Stream data) { + return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data)); + } + public static MessageBody ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er)); + } + public static MessageBody ParseFrom(pb::CodedInputStream data) { + return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data)); + } + public static MessageBody ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.MessageBody.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.MessageBody.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.MessageBody.Builder();} + public Builder(_PBJ_Internal.MessageBody.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(MessageBody prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public MessageBody BuildPartial() {return new MessageBody(super.BuildPartial());} + public MessageBody Build() {if (_HasAllPBJFields) return new MessageBody(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return MessageBody.Descriptor; } } + public Builder ClearMessageNames() { super.ClearMessageNames();return this;} + public Builder SetMessageNames(int index, string value) { + super.SetMessageNames(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int MessageNamesFieldTag=9; + public int MessageNamesCount { get { return super.MessageNamesCount;} } + public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));} + public string MessageNames(int index) { + return (string)PBJ._PBJ.CastString(super.GetMessageNames(index)); + } + public Builder AddMessageNames(string value) { + super.AddMessageNames(PBJ._PBJ.Construct(value)); + return this; + } + public Builder ClearMessageArguments() { super.ClearMessageArguments();return this;} + public Builder SetMessageArguments(int index, pb::ByteString value) { + super.SetMessageArguments(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int MessageArgumentsFieldTag=10; + public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} } + public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));} + public pb::ByteString MessageArguments(int index) { + return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index)); + } + public Builder AddMessageArguments(pb::ByteString value) { + super.AddMessageArguments(PBJ._PBJ.Construct(value)); + return this; + } + } + } +} +namespace Sirikata.Protocol { + public class ReadOnlyMessage : PBJ.IMessage { + protected _PBJ_Internal.ReadOnlyMessage super; + public _PBJ_Internal.ReadOnlyMessage _PBJSuper{ get { return super;} } + public ReadOnlyMessage() { + super=new _PBJ_Internal.ReadOnlyMessage(); + } + public ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage reference) { + super=reference; + } + public static ReadOnlyMessage defaultInstance= new ReadOnlyMessage (_PBJ_Internal.ReadOnlyMessage.DefaultInstance); + public static ReadOnlyMessage DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.ReadOnlyMessage.Descriptor; } } + public static class Types { + public enum ReturnStatus { + SUCCESS=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.SUCCESS, + NETWORK_FAILURE=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.NETWORK_FAILURE, + TIMEOUT_FAILURE=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.TIMEOUT_FAILURE, + PROTOCOL_ERROR=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.PROTOCOL_ERROR, + PORT_FAILURE=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.PORT_FAILURE + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int SourceObjectFieldTag=1; + public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} } + public PBJ.UUID SourceObject{ get { + if (HasSourceObject) { + return PBJ._PBJ.CastUuid(super.SourceObject); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int SourcePortFieldTag=3; + public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} } + public uint SourcePort{ get { + if (HasSourcePort) { + return PBJ._PBJ.CastUint32(super.SourcePort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int SourceSpaceFieldTag=1536; + public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} } + public PBJ.UUID SourceSpace{ get { + if (HasSourceSpace) { + return PBJ._PBJ.CastUuid(super.SourceSpace); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int DestinationObjectFieldTag=2; + public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} } + public PBJ.UUID DestinationObject{ get { + if (HasDestinationObject) { + return PBJ._PBJ.CastUuid(super.DestinationObject); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int DestinationPortFieldTag=4; + public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} } + public uint DestinationPort{ get { + if (HasDestinationPort) { + return PBJ._PBJ.CastUint32(super.DestinationPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int DestinationSpaceFieldTag=1537; + public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} } + public PBJ.UUID DestinationSpace{ get { + if (HasDestinationSpace) { + return PBJ._PBJ.CastUuid(super.DestinationSpace); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int IdFieldTag=7; + public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} } + public long Id{ get { + if (HasId) { + return PBJ._PBJ.CastInt64(super.Id); + } else { + return PBJ._PBJ.CastInt64(); + } + } + } + public const int ReplyIdFieldTag=8; + public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} } + public long ReplyId{ get { + if (HasReplyId) { + return PBJ._PBJ.CastInt64(super.ReplyId); + } else { + return PBJ._PBJ.CastInt64(); + } + } + } + public const int ReturnStatusFieldTag=1792; + public bool HasReturnStatus{ get {return super.HasReturnStatus;} } + public Types.ReturnStatus ReturnStatus{ get { + if (HasReturnStatus) { + return (Types.ReturnStatus)super.ReturnStatus; + } else { + return new Types.ReturnStatus(); + } + } + } + public const int MessageNamesFieldTag=9; + public int MessageNamesCount { get { return super.MessageNamesCount;} } + public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));} + public string MessageNames(int index) { + return (string)PBJ._PBJ.CastString(super.GetMessageNames(index)); + } + public const int MessageArgumentsFieldTag=10; + public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} } + public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));} + public pb::ByteString MessageArguments(int index) { + return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index)); + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(ReadOnlyMessage prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static ReadOnlyMessage ParseFrom(pb::ByteString data) { + return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data)); + } + public static ReadOnlyMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er)); + } + public static ReadOnlyMessage ParseFrom(byte[] data) { + return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data)); + } + public static ReadOnlyMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er)); + } + public static ReadOnlyMessage ParseFrom(global::System.IO.Stream data) { + return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data)); + } + public static ReadOnlyMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er)); + } + public static ReadOnlyMessage ParseFrom(pb::CodedInputStream data) { + return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data)); + } + public static ReadOnlyMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.ReadOnlyMessage.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.ReadOnlyMessage.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.ReadOnlyMessage.Builder();} + public Builder(_PBJ_Internal.ReadOnlyMessage.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(ReadOnlyMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public ReadOnlyMessage BuildPartial() {return new ReadOnlyMessage(super.BuildPartial());} + public ReadOnlyMessage Build() {if (_HasAllPBJFields) return new ReadOnlyMessage(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return ReadOnlyMessage.Descriptor; } } + public Builder ClearSourceObject() { super.ClearSourceObject();return this;} + public const int SourceObjectFieldTag=1; + public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} } + public PBJ.UUID SourceObject{ get { + if (HasSourceObject) { + return PBJ._PBJ.CastUuid(super.SourceObject); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.SourceObject=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearSourcePort() { super.ClearSourcePort();return this;} + public const int SourcePortFieldTag=3; + public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} } + public uint SourcePort{ get { + if (HasSourcePort) { + return PBJ._PBJ.CastUint32(super.SourcePort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.SourcePort=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearSourceSpace() { super.ClearSourceSpace();return this;} + public const int SourceSpaceFieldTag=1536; + public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} } + public PBJ.UUID SourceSpace{ get { + if (HasSourceSpace) { + return PBJ._PBJ.CastUuid(super.SourceSpace); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.SourceSpace=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearDestinationObject() { super.ClearDestinationObject();return this;} + public const int DestinationObjectFieldTag=2; + public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} } + public PBJ.UUID DestinationObject{ get { + if (HasDestinationObject) { + return PBJ._PBJ.CastUuid(super.DestinationObject); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.DestinationObject=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearDestinationPort() { super.ClearDestinationPort();return this;} + public const int DestinationPortFieldTag=4; + public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} } + public uint DestinationPort{ get { + if (HasDestinationPort) { + return PBJ._PBJ.CastUint32(super.DestinationPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.DestinationPort=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearDestinationSpace() { super.ClearDestinationSpace();return this;} + public const int DestinationSpaceFieldTag=1537; + public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} } + public PBJ.UUID DestinationSpace{ get { + if (HasDestinationSpace) { + return PBJ._PBJ.CastUuid(super.DestinationSpace); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.DestinationSpace=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearId() { super.ClearId();return this;} + public const int IdFieldTag=7; + public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} } + public long Id{ get { + if (HasId) { + return PBJ._PBJ.CastInt64(super.Id); + } else { + return PBJ._PBJ.CastInt64(); + } + } + set { + super.Id=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearReplyId() { super.ClearReplyId();return this;} + public const int ReplyIdFieldTag=8; + public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} } + public long ReplyId{ get { + if (HasReplyId) { + return PBJ._PBJ.CastInt64(super.ReplyId); + } else { + return PBJ._PBJ.CastInt64(); + } + } + set { + super.ReplyId=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;} + public const int ReturnStatusFieldTag=1792; + public bool HasReturnStatus{ get {return super.HasReturnStatus;} } + public Types.ReturnStatus ReturnStatus{ get { + if (HasReturnStatus) { + return (Types.ReturnStatus)super.ReturnStatus; + } else { + return new Types.ReturnStatus(); + } + } + set { + super.ReturnStatus=((_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus)value); + } + } + public Builder ClearMessageNames() { super.ClearMessageNames();return this;} + public Builder SetMessageNames(int index, string value) { + super.SetMessageNames(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int MessageNamesFieldTag=9; + public int MessageNamesCount { get { return super.MessageNamesCount;} } + public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));} + public string MessageNames(int index) { + return (string)PBJ._PBJ.CastString(super.GetMessageNames(index)); + } + public Builder AddMessageNames(string value) { + super.AddMessageNames(PBJ._PBJ.Construct(value)); + return this; + } + public Builder ClearMessageArguments() { super.ClearMessageArguments();return this;} + public Builder SetMessageArguments(int index, pb::ByteString value) { + super.SetMessageArguments(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int MessageArgumentsFieldTag=10; + public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} } + public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));} + public pb::ByteString MessageArguments(int index) { + return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index)); + } + public Builder AddMessageArguments(pb::ByteString value) { + super.AddMessageArguments(PBJ._PBJ.Construct(value)); + return this; + } + } + } +} +namespace Sirikata.Protocol { + public class SpaceServices : PBJ.IMessage { + protected _PBJ_Internal.SpaceServices super; + public _PBJ_Internal.SpaceServices _PBJSuper{ get { return super;} } + public SpaceServices() { + super=new _PBJ_Internal.SpaceServices(); + } + public SpaceServices(_PBJ_Internal.SpaceServices reference) { + super=reference; + } + public static SpaceServices defaultInstance= new SpaceServices (_PBJ_Internal.SpaceServices.DefaultInstance); + public static SpaceServices DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.SpaceServices.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int RegistrationPortFieldTag=33; + public bool HasRegistrationPort{ get {return super.HasRegistrationPort&&PBJ._PBJ.ValidateUint32(super.RegistrationPort);} } + public uint RegistrationPort{ get { + if (HasRegistrationPort) { + return PBJ._PBJ.CastUint32(super.RegistrationPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int LocPortFieldTag=34; + public bool HasLocPort{ get {return super.HasLocPort&&PBJ._PBJ.ValidateUint32(super.LocPort);} } + public uint LocPort{ get { + if (HasLocPort) { + return PBJ._PBJ.CastUint32(super.LocPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int GeomPortFieldTag=35; + public bool HasGeomPort{ get {return super.HasGeomPort&&PBJ._PBJ.ValidateUint32(super.GeomPort);} } + public uint GeomPort{ get { + if (HasGeomPort) { + return PBJ._PBJ.CastUint32(super.GeomPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int OsegPortFieldTag=36; + public bool HasOsegPort{ get {return super.HasOsegPort&&PBJ._PBJ.ValidateUint32(super.OsegPort);} } + public uint OsegPort{ get { + if (HasOsegPort) { + return PBJ._PBJ.CastUint32(super.OsegPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int CsegPortFieldTag=37; + public bool HasCsegPort{ get {return super.HasCsegPort&&PBJ._PBJ.ValidateUint32(super.CsegPort);} } + public uint CsegPort{ get { + if (HasCsegPort) { + return PBJ._PBJ.CastUint32(super.CsegPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int RouterPortFieldTag=38; + public bool HasRouterPort{ get {return super.HasRouterPort&&PBJ._PBJ.ValidateUint32(super.RouterPort);} } + public uint RouterPort{ get { + if (HasRouterPort) { + return PBJ._PBJ.CastUint32(super.RouterPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int PreConnectionBufferFieldTag=64; + public bool HasPreConnectionBuffer{ get {return super.HasPreConnectionBuffer&&PBJ._PBJ.ValidateUint64(super.PreConnectionBuffer);} } + public ulong PreConnectionBuffer{ get { + if (HasPreConnectionBuffer) { + return PBJ._PBJ.CastUint64(super.PreConnectionBuffer); + } else { + return PBJ._PBJ.CastUint64(); + } + } + } + public const int MaxPreConnectionMessagesFieldTag=65; + public bool HasMaxPreConnectionMessages{ get {return super.HasMaxPreConnectionMessages&&PBJ._PBJ.ValidateUint64(super.MaxPreConnectionMessages);} } + public ulong MaxPreConnectionMessages{ get { + if (HasMaxPreConnectionMessages) { + return PBJ._PBJ.CastUint64(super.MaxPreConnectionMessages); + } else { + return PBJ._PBJ.CastUint64(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(SpaceServices prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static SpaceServices ParseFrom(pb::ByteString data) { + return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data)); + } + public static SpaceServices ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er)); + } + public static SpaceServices ParseFrom(byte[] data) { + return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data)); + } + public static SpaceServices ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er)); + } + public static SpaceServices ParseFrom(global::System.IO.Stream data) { + return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data)); + } + public static SpaceServices ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er)); + } + public static SpaceServices ParseFrom(pb::CodedInputStream data) { + return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data)); + } + public static SpaceServices ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.SpaceServices.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.SpaceServices.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.SpaceServices.Builder();} + public Builder(_PBJ_Internal.SpaceServices.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(SpaceServices prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public SpaceServices BuildPartial() {return new SpaceServices(super.BuildPartial());} + public SpaceServices Build() {if (_HasAllPBJFields) return new SpaceServices(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return SpaceServices.Descriptor; } } + public Builder ClearRegistrationPort() { super.ClearRegistrationPort();return this;} + public const int RegistrationPortFieldTag=33; + public bool HasRegistrationPort{ get {return super.HasRegistrationPort&&PBJ._PBJ.ValidateUint32(super.RegistrationPort);} } + public uint RegistrationPort{ get { + if (HasRegistrationPort) { + return PBJ._PBJ.CastUint32(super.RegistrationPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.RegistrationPort=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearLocPort() { super.ClearLocPort();return this;} + public const int LocPortFieldTag=34; + public bool HasLocPort{ get {return super.HasLocPort&&PBJ._PBJ.ValidateUint32(super.LocPort);} } + public uint LocPort{ get { + if (HasLocPort) { + return PBJ._PBJ.CastUint32(super.LocPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.LocPort=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearGeomPort() { super.ClearGeomPort();return this;} + public const int GeomPortFieldTag=35; + public bool HasGeomPort{ get {return super.HasGeomPort&&PBJ._PBJ.ValidateUint32(super.GeomPort);} } + public uint GeomPort{ get { + if (HasGeomPort) { + return PBJ._PBJ.CastUint32(super.GeomPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.GeomPort=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearOsegPort() { super.ClearOsegPort();return this;} + public const int OsegPortFieldTag=36; + public bool HasOsegPort{ get {return super.HasOsegPort&&PBJ._PBJ.ValidateUint32(super.OsegPort);} } + public uint OsegPort{ get { + if (HasOsegPort) { + return PBJ._PBJ.CastUint32(super.OsegPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.OsegPort=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearCsegPort() { super.ClearCsegPort();return this;} + public const int CsegPortFieldTag=37; + public bool HasCsegPort{ get {return super.HasCsegPort&&PBJ._PBJ.ValidateUint32(super.CsegPort);} } + public uint CsegPort{ get { + if (HasCsegPort) { + return PBJ._PBJ.CastUint32(super.CsegPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.CsegPort=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearRouterPort() { super.ClearRouterPort();return this;} + public const int RouterPortFieldTag=38; + public bool HasRouterPort{ get {return super.HasRouterPort&&PBJ._PBJ.ValidateUint32(super.RouterPort);} } + public uint RouterPort{ get { + if (HasRouterPort) { + return PBJ._PBJ.CastUint32(super.RouterPort); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.RouterPort=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearPreConnectionBuffer() { super.ClearPreConnectionBuffer();return this;} + public const int PreConnectionBufferFieldTag=64; + public bool HasPreConnectionBuffer{ get {return super.HasPreConnectionBuffer&&PBJ._PBJ.ValidateUint64(super.PreConnectionBuffer);} } + public ulong PreConnectionBuffer{ get { + if (HasPreConnectionBuffer) { + return PBJ._PBJ.CastUint64(super.PreConnectionBuffer); + } else { + return PBJ._PBJ.CastUint64(); + } + } + set { + super.PreConnectionBuffer=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearMaxPreConnectionMessages() { super.ClearMaxPreConnectionMessages();return this;} + public const int MaxPreConnectionMessagesFieldTag=65; + public bool HasMaxPreConnectionMessages{ get {return super.HasMaxPreConnectionMessages&&PBJ._PBJ.ValidateUint64(super.MaxPreConnectionMessages);} } + public ulong MaxPreConnectionMessages{ get { + if (HasMaxPreConnectionMessages) { + return PBJ._PBJ.CastUint64(super.MaxPreConnectionMessages); + } else { + return PBJ._PBJ.CastUint64(); + } + } + set { + super.MaxPreConnectionMessages=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Protocol { + public class ObjLoc : PBJ.IMessage { + protected _PBJ_Internal.ObjLoc super; + public _PBJ_Internal.ObjLoc _PBJSuper{ get { return super;} } + public ObjLoc() { + super=new _PBJ_Internal.ObjLoc(); + } + public ObjLoc(_PBJ_Internal.ObjLoc reference) { + super=reference; + } + public static ObjLoc defaultInstance= new ObjLoc (_PBJ_Internal.ObjLoc.DefaultInstance); + public static ObjLoc DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.ObjLoc.Descriptor; } } + public static class Types { + public enum UpdateFlags { + FORCE=_PBJ_Internal.ObjLoc.Types.UpdateFlags.FORCE + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int TimestampFieldTag=2; + public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} } + public PBJ.Time Timestamp{ get { + if (HasTimestamp) { + return PBJ._PBJ.CastTime(super.Timestamp); + } else { + return PBJ._PBJ.CastTime(); + } + } + } + public const int PositionFieldTag=3; + public bool HasPosition{ get {return super.PositionCount>=3;} } + public PBJ.Vector3d Position{ get { + int index=0; + if (HasPosition) { + return PBJ._PBJ.CastVector3d(super.GetPosition(index*3+0),super.GetPosition(index*3+1),super.GetPosition(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + } + public const int OrientationFieldTag=4; + public bool HasOrientation{ get {return super.OrientationCount>=3;} } + public PBJ.Quaternion Orientation{ get { + int index=0; + if (HasOrientation) { + return PBJ._PBJ.CastQuaternion(super.GetOrientation(index*3+0),super.GetOrientation(index*3+1),super.GetOrientation(index*3+2)); + } else { + return PBJ._PBJ.CastQuaternion(); + } + } + } + public const int VelocityFieldTag=5; + public bool HasVelocity{ get {return super.VelocityCount>=3;} } + public PBJ.Vector3f Velocity{ get { + int index=0; + if (HasVelocity) { + return PBJ._PBJ.CastVector3f(super.GetVelocity(index*3+0),super.GetVelocity(index*3+1),super.GetVelocity(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + } + public const int RotationalAxisFieldTag=7; + public bool HasRotationalAxis{ get {return super.RotationalAxisCount>=2;} } + public PBJ.Vector3f RotationalAxis{ get { + int index=0; + if (HasRotationalAxis) { + return PBJ._PBJ.CastNormal(super.GetRotationalAxis(index*2+0),super.GetRotationalAxis(index*2+1)); + } else { + return PBJ._PBJ.CastNormal(); + } + } + } + public const int AngularSpeedFieldTag=8; + public bool HasAngularSpeed{ get {return super.HasAngularSpeed&&PBJ._PBJ.ValidateFloat(super.AngularSpeed);} } + public float AngularSpeed{ get { + if (HasAngularSpeed) { + return PBJ._PBJ.CastFloat(super.AngularSpeed); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int UpdateFlagsFieldTag=6; + public bool HasUpdateFlags { get { + if (!super.HasUpdateFlags) return false; + return PBJ._PBJ.ValidateFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE); + } } + public byte UpdateFlags{ get { + if (HasUpdateFlags) { + return (byte)PBJ._PBJ.CastFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE); + } else { + return (byte)PBJ._PBJ.CastFlags((ulong)Types.UpdateFlags.FORCE); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(ObjLoc prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static ObjLoc ParseFrom(pb::ByteString data) { + return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data)); + } + public static ObjLoc ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er)); + } + public static ObjLoc ParseFrom(byte[] data) { + return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data)); + } + public static ObjLoc ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er)); + } + public static ObjLoc ParseFrom(global::System.IO.Stream data) { + return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data)); + } + public static ObjLoc ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er)); + } + public static ObjLoc ParseFrom(pb::CodedInputStream data) { + return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data)); + } + public static ObjLoc ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.ObjLoc.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.ObjLoc.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.ObjLoc.Builder();} + public Builder(_PBJ_Internal.ObjLoc.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(ObjLoc prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public ObjLoc BuildPartial() {return new ObjLoc(super.BuildPartial());} + public ObjLoc Build() {if (_HasAllPBJFields) return new ObjLoc(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return ObjLoc.Descriptor; } } + public Builder ClearTimestamp() { super.ClearTimestamp();return this;} + public const int TimestampFieldTag=2; + public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} } + public PBJ.Time Timestamp{ get { + if (HasTimestamp) { + return PBJ._PBJ.CastTime(super.Timestamp); + } else { + return PBJ._PBJ.CastTime(); + } + } + set { + super.Timestamp=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearPosition() { super.ClearPosition();return this;} + public const int PositionFieldTag=3; + public bool HasPosition{ get {return super.PositionCount>=3;} } + public PBJ.Vector3d Position{ get { + int index=0; + if (HasPosition) { + return PBJ._PBJ.CastVector3d(super.GetPosition(index*3+0),super.GetPosition(index*3+1),super.GetPosition(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + set { + super.ClearPosition(); + double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); + super.AddPosition(_PBJtempArray[0]); + super.AddPosition(_PBJtempArray[1]); + super.AddPosition(_PBJtempArray[2]); + } + } + public Builder ClearOrientation() { super.ClearOrientation();return this;} + public const int OrientationFieldTag=4; + public bool HasOrientation{ get {return super.OrientationCount>=3;} } + public PBJ.Quaternion Orientation{ get { + int index=0; + if (HasOrientation) { + return PBJ._PBJ.CastQuaternion(super.GetOrientation(index*3+0),super.GetOrientation(index*3+1),super.GetOrientation(index*3+2)); + } else { + return PBJ._PBJ.CastQuaternion(); + } + } + set { + super.ClearOrientation(); + float[] _PBJtempArray=PBJ._PBJ.ConstructQuaternion(value); + super.AddOrientation(_PBJtempArray[0]); + super.AddOrientation(_PBJtempArray[1]); + super.AddOrientation(_PBJtempArray[2]); + } + } + public Builder ClearVelocity() { super.ClearVelocity();return this;} + public const int VelocityFieldTag=5; + public bool HasVelocity{ get {return super.VelocityCount>=3;} } + public PBJ.Vector3f Velocity{ get { + int index=0; + if (HasVelocity) { + return PBJ._PBJ.CastVector3f(super.GetVelocity(index*3+0),super.GetVelocity(index*3+1),super.GetVelocity(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + set { + super.ClearVelocity(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.AddVelocity(_PBJtempArray[0]); + super.AddVelocity(_PBJtempArray[1]); + super.AddVelocity(_PBJtempArray[2]); + } + } + public Builder ClearRotationalAxis() { super.ClearRotationalAxis();return this;} + public const int RotationalAxisFieldTag=7; + public bool HasRotationalAxis{ get {return super.RotationalAxisCount>=2;} } + public PBJ.Vector3f RotationalAxis{ get { + int index=0; + if (HasRotationalAxis) { + return PBJ._PBJ.CastNormal(super.GetRotationalAxis(index*2+0),super.GetRotationalAxis(index*2+1)); + } else { + return PBJ._PBJ.CastNormal(); + } + } + set { + super.ClearRotationalAxis(); + float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); + super.AddRotationalAxis(_PBJtempArray[0]); + super.AddRotationalAxis(_PBJtempArray[1]); + } + } + public Builder ClearAngularSpeed() { super.ClearAngularSpeed();return this;} + public const int AngularSpeedFieldTag=8; + public bool HasAngularSpeed{ get {return super.HasAngularSpeed&&PBJ._PBJ.ValidateFloat(super.AngularSpeed);} } + public float AngularSpeed{ get { + if (HasAngularSpeed) { + return PBJ._PBJ.CastFloat(super.AngularSpeed); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.AngularSpeed=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearUpdateFlags() { super.ClearUpdateFlags();return this;} + public const int UpdateFlagsFieldTag=6; + public bool HasUpdateFlags { get { + if (!super.HasUpdateFlags) return false; + return PBJ._PBJ.ValidateFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE); + } } + public byte UpdateFlags{ get { + if (HasUpdateFlags) { + return (byte)PBJ._PBJ.CastFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE); + } else { + return (byte)PBJ._PBJ.CastFlags((ulong)Types.UpdateFlags.FORCE); + } + } + set { + super.UpdateFlags=((value)); + } + } + } + } +} +namespace Sirikata.Protocol { + public class LocRequest : PBJ.IMessage { + protected _PBJ_Internal.LocRequest super; + public _PBJ_Internal.LocRequest _PBJSuper{ get { return super;} } + public LocRequest() { + super=new _PBJ_Internal.LocRequest(); + } + public LocRequest(_PBJ_Internal.LocRequest reference) { + super=reference; + } + public static LocRequest defaultInstance= new LocRequest (_PBJ_Internal.LocRequest.DefaultInstance); + public static LocRequest DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.LocRequest.Descriptor; } } + public static class Types { + public enum Fields { + POSITION=_PBJ_Internal.LocRequest.Types.Fields.POSITION, + ORIENTATION=_PBJ_Internal.LocRequest.Types.Fields.ORIENTATION, + VELOCITY=_PBJ_Internal.LocRequest.Types.Fields.VELOCITY, + ROTATIONAL_AXIS=_PBJ_Internal.LocRequest.Types.Fields.ROTATIONAL_AXIS, + ANGULAR_SPEED=_PBJ_Internal.LocRequest.Types.Fields.ANGULAR_SPEED + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int RequestedFieldsFieldTag=2; + public bool HasRequestedFields { get { + if (!super.HasRequestedFields) return false; + return PBJ._PBJ.ValidateFlags(super.RequestedFields,(ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED); + } } + public uint RequestedFields{ get { + if (HasRequestedFields) { + return (uint)PBJ._PBJ.CastFlags(super.RequestedFields,(ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED); + } else { + return (uint)PBJ._PBJ.CastFlags((ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(LocRequest prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static LocRequest ParseFrom(pb::ByteString data) { + return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data)); + } + public static LocRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er)); + } + public static LocRequest ParseFrom(byte[] data) { + return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data)); + } + public static LocRequest ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er)); + } + public static LocRequest ParseFrom(global::System.IO.Stream data) { + return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data)); + } + public static LocRequest ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er)); + } + public static LocRequest ParseFrom(pb::CodedInputStream data) { + return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data)); + } + public static LocRequest ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.LocRequest.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.LocRequest.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.LocRequest.Builder();} + public Builder(_PBJ_Internal.LocRequest.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(LocRequest prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public LocRequest BuildPartial() {return new LocRequest(super.BuildPartial());} + public LocRequest Build() {if (_HasAllPBJFields) return new LocRequest(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return LocRequest.Descriptor; } } + public Builder ClearRequestedFields() { super.ClearRequestedFields();return this;} + public const int RequestedFieldsFieldTag=2; + public bool HasRequestedFields { get { + if (!super.HasRequestedFields) return false; + return PBJ._PBJ.ValidateFlags(super.RequestedFields,(ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED); + } } + public uint RequestedFields{ get { + if (HasRequestedFields) { + return (uint)PBJ._PBJ.CastFlags(super.RequestedFields,(ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED); + } else { + return (uint)PBJ._PBJ.CastFlags((ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED); + } + } + set { + super.RequestedFields=((value)); + } + } + } + } +} +namespace Sirikata.Protocol { + public class NewObj : PBJ.IMessage { + protected _PBJ_Internal.NewObj super; + public _PBJ_Internal.NewObj _PBJSuper{ get { return super;} } + public NewObj() { + super=new _PBJ_Internal.NewObj(); + } + public NewObj(_PBJ_Internal.NewObj reference) { + super=reference; + } + public static NewObj defaultInstance= new NewObj (_PBJ_Internal.NewObj.DefaultInstance); + public static NewObj DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.NewObj.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ObjectUuidEvidenceFieldTag=2; + public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} } + public PBJ.UUID ObjectUuidEvidence{ get { + if (HasObjectUuidEvidence) { + return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int RequestedObjectLocFieldTag=3; + public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} } + public ObjLoc RequestedObjectLoc{ get { + if (HasRequestedObjectLoc) { + return new ObjLoc(super.RequestedObjectLoc); + } else { + return new ObjLoc(); + } + } + } + public const int BoundingSphereFieldTag=4; + public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} } + public PBJ.BoundingSphere3f BoundingSphere{ get { + int index=0; + if (HasBoundingSphere) { + return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3)); + } else { + return PBJ._PBJ.CastBoundingsphere3f(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(NewObj prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static NewObj ParseFrom(pb::ByteString data) { + return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data)); + } + public static NewObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er)); + } + public static NewObj ParseFrom(byte[] data) { + return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data)); + } + public static NewObj ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er)); + } + public static NewObj ParseFrom(global::System.IO.Stream data) { + return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data)); + } + public static NewObj ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er)); + } + public static NewObj ParseFrom(pb::CodedInputStream data) { + return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data)); + } + public static NewObj ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.NewObj.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.NewObj.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.NewObj.Builder();} + public Builder(_PBJ_Internal.NewObj.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(NewObj prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public NewObj BuildPartial() {return new NewObj(super.BuildPartial());} + public NewObj Build() {if (_HasAllPBJFields) return new NewObj(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return NewObj.Descriptor; } } + public Builder ClearObjectUuidEvidence() { super.ClearObjectUuidEvidence();return this;} + public const int ObjectUuidEvidenceFieldTag=2; + public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} } + public PBJ.UUID ObjectUuidEvidence{ get { + if (HasObjectUuidEvidence) { + return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.ObjectUuidEvidence=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearRequestedObjectLoc() { super.ClearRequestedObjectLoc();return this;} + public const int RequestedObjectLocFieldTag=3; + public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} } + public ObjLoc RequestedObjectLoc{ get { + if (HasRequestedObjectLoc) { + return new ObjLoc(super.RequestedObjectLoc); + } else { + return new ObjLoc(); + } + } + set { + super.RequestedObjectLoc=value._PBJSuper; + } + } + public Builder ClearBoundingSphere() { super.ClearBoundingSphere();return this;} + public const int BoundingSphereFieldTag=4; + public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} } + public PBJ.BoundingSphere3f BoundingSphere{ get { + int index=0; + if (HasBoundingSphere) { + return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3)); + } else { + return PBJ._PBJ.CastBoundingsphere3f(); + } + } + set { + super.ClearBoundingSphere(); + float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value); + super.AddBoundingSphere(_PBJtempArray[0]); + super.AddBoundingSphere(_PBJtempArray[1]); + super.AddBoundingSphere(_PBJtempArray[2]); + super.AddBoundingSphere(_PBJtempArray[3]); + } + } + } + } +} +namespace Sirikata.Protocol { + public class RetObj : PBJ.IMessage { + protected _PBJ_Internal.RetObj super; + public _PBJ_Internal.RetObj _PBJSuper{ get { return super;} } + public RetObj() { + super=new _PBJ_Internal.RetObj(); + } + public RetObj(_PBJ_Internal.RetObj reference) { + super=reference; + } + public static RetObj defaultInstance= new RetObj (_PBJ_Internal.RetObj.DefaultInstance); + public static RetObj DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.RetObj.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ObjectReferenceFieldTag=2; + public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} } + public PBJ.UUID ObjectReference{ get { + if (HasObjectReference) { + return PBJ._PBJ.CastUuid(super.ObjectReference); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int LocationFieldTag=3; + public bool HasLocation{ get {return super.HasLocation;} } + public ObjLoc Location{ get { + if (HasLocation) { + return new ObjLoc(super.Location); + } else { + return new ObjLoc(); + } + } + } + public const int BoundingSphereFieldTag=4; + public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} } + public PBJ.BoundingSphere3f BoundingSphere{ get { + int index=0; + if (HasBoundingSphere) { + return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3)); + } else { + return PBJ._PBJ.CastBoundingsphere3f(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(RetObj prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static RetObj ParseFrom(pb::ByteString data) { + return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data)); + } + public static RetObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er)); + } + public static RetObj ParseFrom(byte[] data) { + return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data)); + } + public static RetObj ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er)); + } + public static RetObj ParseFrom(global::System.IO.Stream data) { + return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data)); + } + public static RetObj ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er)); + } + public static RetObj ParseFrom(pb::CodedInputStream data) { + return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data)); + } + public static RetObj ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.RetObj.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.RetObj.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.RetObj.Builder();} + public Builder(_PBJ_Internal.RetObj.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(RetObj prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public RetObj BuildPartial() {return new RetObj(super.BuildPartial());} + public RetObj Build() {if (_HasAllPBJFields) return new RetObj(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return RetObj.Descriptor; } } + public Builder ClearObjectReference() { super.ClearObjectReference();return this;} + public const int ObjectReferenceFieldTag=2; + public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} } + public PBJ.UUID ObjectReference{ get { + if (HasObjectReference) { + return PBJ._PBJ.CastUuid(super.ObjectReference); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.ObjectReference=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearLocation() { super.ClearLocation();return this;} + public const int LocationFieldTag=3; + public bool HasLocation{ get {return super.HasLocation;} } + public ObjLoc Location{ get { + if (HasLocation) { + return new ObjLoc(super.Location); + } else { + return new ObjLoc(); + } + } + set { + super.Location=value._PBJSuper; + } + } + public Builder ClearBoundingSphere() { super.ClearBoundingSphere();return this;} + public const int BoundingSphereFieldTag=4; + public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} } + public PBJ.BoundingSphere3f BoundingSphere{ get { + int index=0; + if (HasBoundingSphere) { + return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3)); + } else { + return PBJ._PBJ.CastBoundingsphere3f(); + } + } + set { + super.ClearBoundingSphere(); + float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value); + super.AddBoundingSphere(_PBJtempArray[0]); + super.AddBoundingSphere(_PBJtempArray[1]); + super.AddBoundingSphere(_PBJtempArray[2]); + super.AddBoundingSphere(_PBJtempArray[3]); + } + } + } + } +} +namespace Sirikata.Protocol { + public class DelObj : PBJ.IMessage { + protected _PBJ_Internal.DelObj super; + public _PBJ_Internal.DelObj _PBJSuper{ get { return super;} } + public DelObj() { + super=new _PBJ_Internal.DelObj(); + } + public DelObj(_PBJ_Internal.DelObj reference) { + super=reference; + } + public static DelObj defaultInstance= new DelObj (_PBJ_Internal.DelObj.DefaultInstance); + public static DelObj DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.DelObj.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ObjectReferenceFieldTag=2; + public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} } + public PBJ.UUID ObjectReference{ get { + if (HasObjectReference) { + return PBJ._PBJ.CastUuid(super.ObjectReference); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(DelObj prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static DelObj ParseFrom(pb::ByteString data) { + return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data)); + } + public static DelObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er)); + } + public static DelObj ParseFrom(byte[] data) { + return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data)); + } + public static DelObj ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er)); + } + public static DelObj ParseFrom(global::System.IO.Stream data) { + return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data)); + } + public static DelObj ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er)); + } + public static DelObj ParseFrom(pb::CodedInputStream data) { + return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data)); + } + public static DelObj ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.DelObj.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.DelObj.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.DelObj.Builder();} + public Builder(_PBJ_Internal.DelObj.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(DelObj prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public DelObj BuildPartial() {return new DelObj(super.BuildPartial());} + public DelObj Build() {if (_HasAllPBJFields) return new DelObj(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return DelObj.Descriptor; } } + public Builder ClearObjectReference() { super.ClearObjectReference();return this;} + public const int ObjectReferenceFieldTag=2; + public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} } + public PBJ.UUID ObjectReference{ get { + if (HasObjectReference) { + return PBJ._PBJ.CastUuid(super.ObjectReference); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.ObjectReference=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Protocol { + public class NewProxQuery : PBJ.IMessage { + protected _PBJ_Internal.NewProxQuery super; + public _PBJ_Internal.NewProxQuery _PBJSuper{ get { return super;} } + public NewProxQuery() { + super=new _PBJ_Internal.NewProxQuery(); + } + public NewProxQuery(_PBJ_Internal.NewProxQuery reference) { + super=reference; + } + public static NewProxQuery defaultInstance= new NewProxQuery (_PBJ_Internal.NewProxQuery.DefaultInstance); + public static NewProxQuery DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.NewProxQuery.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int QueryIdFieldTag=2; + public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} } + public uint QueryId{ get { + if (HasQueryId) { + return PBJ._PBJ.CastUint32(super.QueryId); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int StatelessFieldTag=3; + public bool HasStateless{ get {return super.HasStateless&&PBJ._PBJ.ValidateBool(super.Stateless);} } + public bool Stateless{ get { + if (HasStateless) { + return PBJ._PBJ.CastBool(super.Stateless); + } else { + return PBJ._PBJ.CastBool(); + } + } + } + public const int RelativeCenterFieldTag=4; + public bool HasRelativeCenter{ get {return super.RelativeCenterCount>=3;} } + public PBJ.Vector3f RelativeCenter{ get { + int index=0; + if (HasRelativeCenter) { + return PBJ._PBJ.CastVector3f(super.GetRelativeCenter(index*3+0),super.GetRelativeCenter(index*3+1),super.GetRelativeCenter(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + } + public const int AbsoluteCenterFieldTag=5; + public bool HasAbsoluteCenter{ get {return super.AbsoluteCenterCount>=3;} } + public PBJ.Vector3d AbsoluteCenter{ get { + int index=0; + if (HasAbsoluteCenter) { + return PBJ._PBJ.CastVector3d(super.GetAbsoluteCenter(index*3+0),super.GetAbsoluteCenter(index*3+1),super.GetAbsoluteCenter(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + } + public const int MaxRadiusFieldTag=6; + public bool HasMaxRadius{ get {return super.HasMaxRadius&&PBJ._PBJ.ValidateFloat(super.MaxRadius);} } + public float MaxRadius{ get { + if (HasMaxRadius) { + return PBJ._PBJ.CastFloat(super.MaxRadius); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int MinSolidAngleFieldTag=7; + public bool HasMinSolidAngle{ get {return super.HasMinSolidAngle&&PBJ._PBJ.ValidateAngle(super.MinSolidAngle);} } + public float MinSolidAngle{ get { + if (HasMinSolidAngle) { + return PBJ._PBJ.CastAngle(super.MinSolidAngle); + } else { + return PBJ._PBJ.CastAngle(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(NewProxQuery prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static NewProxQuery ParseFrom(pb::ByteString data) { + return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data)); + } + public static NewProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er)); + } + public static NewProxQuery ParseFrom(byte[] data) { + return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data)); + } + public static NewProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er)); + } + public static NewProxQuery ParseFrom(global::System.IO.Stream data) { + return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data)); + } + public static NewProxQuery ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er)); + } + public static NewProxQuery ParseFrom(pb::CodedInputStream data) { + return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data)); + } + public static NewProxQuery ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.NewProxQuery.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.NewProxQuery.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.NewProxQuery.Builder();} + public Builder(_PBJ_Internal.NewProxQuery.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(NewProxQuery prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public NewProxQuery BuildPartial() {return new NewProxQuery(super.BuildPartial());} + public NewProxQuery Build() {if (_HasAllPBJFields) return new NewProxQuery(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return NewProxQuery.Descriptor; } } + public Builder ClearQueryId() { super.ClearQueryId();return this;} + public const int QueryIdFieldTag=2; + public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} } + public uint QueryId{ get { + if (HasQueryId) { + return PBJ._PBJ.CastUint32(super.QueryId); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.QueryId=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearStateless() { super.ClearStateless();return this;} + public const int StatelessFieldTag=3; + public bool HasStateless{ get {return super.HasStateless&&PBJ._PBJ.ValidateBool(super.Stateless);} } + public bool Stateless{ get { + if (HasStateless) { + return PBJ._PBJ.CastBool(super.Stateless); + } else { + return PBJ._PBJ.CastBool(); + } + } + set { + super.Stateless=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearRelativeCenter() { super.ClearRelativeCenter();return this;} + public const int RelativeCenterFieldTag=4; + public bool HasRelativeCenter{ get {return super.RelativeCenterCount>=3;} } + public PBJ.Vector3f RelativeCenter{ get { + int index=0; + if (HasRelativeCenter) { + return PBJ._PBJ.CastVector3f(super.GetRelativeCenter(index*3+0),super.GetRelativeCenter(index*3+1),super.GetRelativeCenter(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + set { + super.ClearRelativeCenter(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.AddRelativeCenter(_PBJtempArray[0]); + super.AddRelativeCenter(_PBJtempArray[1]); + super.AddRelativeCenter(_PBJtempArray[2]); + } + } + public Builder ClearAbsoluteCenter() { super.ClearAbsoluteCenter();return this;} + public const int AbsoluteCenterFieldTag=5; + public bool HasAbsoluteCenter{ get {return super.AbsoluteCenterCount>=3;} } + public PBJ.Vector3d AbsoluteCenter{ get { + int index=0; + if (HasAbsoluteCenter) { + return PBJ._PBJ.CastVector3d(super.GetAbsoluteCenter(index*3+0),super.GetAbsoluteCenter(index*3+1),super.GetAbsoluteCenter(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + set { + super.ClearAbsoluteCenter(); + double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); + super.AddAbsoluteCenter(_PBJtempArray[0]); + super.AddAbsoluteCenter(_PBJtempArray[1]); + super.AddAbsoluteCenter(_PBJtempArray[2]); + } + } + public Builder ClearMaxRadius() { super.ClearMaxRadius();return this;} + public const int MaxRadiusFieldTag=6; + public bool HasMaxRadius{ get {return super.HasMaxRadius&&PBJ._PBJ.ValidateFloat(super.MaxRadius);} } + public float MaxRadius{ get { + if (HasMaxRadius) { + return PBJ._PBJ.CastFloat(super.MaxRadius); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.MaxRadius=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearMinSolidAngle() { super.ClearMinSolidAngle();return this;} + public const int MinSolidAngleFieldTag=7; + public bool HasMinSolidAngle{ get {return super.HasMinSolidAngle&&PBJ._PBJ.ValidateAngle(super.MinSolidAngle);} } + public float MinSolidAngle{ get { + if (HasMinSolidAngle) { + return PBJ._PBJ.CastAngle(super.MinSolidAngle); + } else { + return PBJ._PBJ.CastAngle(); + } + } + set { + super.MinSolidAngle=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Protocol { + public class ProxCall : PBJ.IMessage { + protected _PBJ_Internal.ProxCall super; + public _PBJ_Internal.ProxCall _PBJSuper{ get { return super;} } + public ProxCall() { + super=new _PBJ_Internal.ProxCall(); + } + public ProxCall(_PBJ_Internal.ProxCall reference) { + super=reference; + } + public static ProxCall defaultInstance= new ProxCall (_PBJ_Internal.ProxCall.DefaultInstance); + public static ProxCall DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.ProxCall.Descriptor; } } + public static class Types { + public enum ProximityEvent { + EXITED_PROXIMITY=_PBJ_Internal.ProxCall.Types.ProximityEvent.EXITED_PROXIMITY, + ENTERED_PROXIMITY=_PBJ_Internal.ProxCall.Types.ProximityEvent.ENTERED_PROXIMITY, + STATELESS_PROXIMITY=_PBJ_Internal.ProxCall.Types.ProximityEvent.STATELESS_PROXIMITY + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int QueryIdFieldTag=2; + public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} } + public uint QueryId{ get { + if (HasQueryId) { + return PBJ._PBJ.CastUint32(super.QueryId); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int ProximateObjectFieldTag=3; + public bool HasProximateObject{ get {return super.HasProximateObject&&PBJ._PBJ.ValidateUuid(super.ProximateObject);} } + public PBJ.UUID ProximateObject{ get { + if (HasProximateObject) { + return PBJ._PBJ.CastUuid(super.ProximateObject); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int ProximityEventFieldTag=4; + public bool HasProximityEvent{ get {return super.HasProximityEvent;} } + public Types.ProximityEvent ProximityEvent{ get { + if (HasProximityEvent) { + return (Types.ProximityEvent)super.ProximityEvent; + } else { + return new Types.ProximityEvent(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(ProxCall prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static ProxCall ParseFrom(pb::ByteString data) { + return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data)); + } + public static ProxCall ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er)); + } + public static ProxCall ParseFrom(byte[] data) { + return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data)); + } + public static ProxCall ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er)); + } + public static ProxCall ParseFrom(global::System.IO.Stream data) { + return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data)); + } + public static ProxCall ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er)); + } + public static ProxCall ParseFrom(pb::CodedInputStream data) { + return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data)); + } + public static ProxCall ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.ProxCall.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.ProxCall.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.ProxCall.Builder();} + public Builder(_PBJ_Internal.ProxCall.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(ProxCall prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public ProxCall BuildPartial() {return new ProxCall(super.BuildPartial());} + public ProxCall Build() {if (_HasAllPBJFields) return new ProxCall(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return ProxCall.Descriptor; } } + public Builder ClearQueryId() { super.ClearQueryId();return this;} + public const int QueryIdFieldTag=2; + public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} } + public uint QueryId{ get { + if (HasQueryId) { + return PBJ._PBJ.CastUint32(super.QueryId); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.QueryId=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearProximateObject() { super.ClearProximateObject();return this;} + public const int ProximateObjectFieldTag=3; + public bool HasProximateObject{ get {return super.HasProximateObject&&PBJ._PBJ.ValidateUuid(super.ProximateObject);} } + public PBJ.UUID ProximateObject{ get { + if (HasProximateObject) { + return PBJ._PBJ.CastUuid(super.ProximateObject); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.ProximateObject=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearProximityEvent() { super.ClearProximityEvent();return this;} + public const int ProximityEventFieldTag=4; + public bool HasProximityEvent{ get {return super.HasProximityEvent;} } + public Types.ProximityEvent ProximityEvent{ get { + if (HasProximityEvent) { + return (Types.ProximityEvent)super.ProximityEvent; + } else { + return new Types.ProximityEvent(); + } + } + set { + super.ProximityEvent=((_PBJ_Internal.ProxCall.Types.ProximityEvent)value); + } + } + } + } +} +namespace Sirikata.Protocol { + public class DelProxQuery : PBJ.IMessage { + protected _PBJ_Internal.DelProxQuery super; + public _PBJ_Internal.DelProxQuery _PBJSuper{ get { return super;} } + public DelProxQuery() { + super=new _PBJ_Internal.DelProxQuery(); + } + public DelProxQuery(_PBJ_Internal.DelProxQuery reference) { + super=reference; + } + public static DelProxQuery defaultInstance= new DelProxQuery (_PBJ_Internal.DelProxQuery.DefaultInstance); + public static DelProxQuery DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.DelProxQuery.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int QueryIdFieldTag=2; + public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} } + public uint QueryId{ get { + if (HasQueryId) { + return PBJ._PBJ.CastUint32(super.QueryId); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(DelProxQuery prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static DelProxQuery ParseFrom(pb::ByteString data) { + return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data)); + } + public static DelProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er)); + } + public static DelProxQuery ParseFrom(byte[] data) { + return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data)); + } + public static DelProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er)); + } + public static DelProxQuery ParseFrom(global::System.IO.Stream data) { + return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data)); + } + public static DelProxQuery ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er)); + } + public static DelProxQuery ParseFrom(pb::CodedInputStream data) { + return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data)); + } + public static DelProxQuery ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.DelProxQuery.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.DelProxQuery.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.DelProxQuery.Builder();} + public Builder(_PBJ_Internal.DelProxQuery.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(DelProxQuery prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public DelProxQuery BuildPartial() {return new DelProxQuery(super.BuildPartial());} + public DelProxQuery Build() {if (_HasAllPBJFields) return new DelProxQuery(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return DelProxQuery.Descriptor; } } + public Builder ClearQueryId() { super.ClearQueryId();return this;} + public const int QueryIdFieldTag=2; + public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} } + public uint QueryId{ get { + if (HasQueryId) { + return PBJ._PBJ.CastUint32(super.QueryId); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.QueryId=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Protocol { + public class Vector3fProperty : PBJ.IMessage { + protected _PBJ_Internal.Vector3fProperty super; + public _PBJ_Internal.Vector3fProperty _PBJSuper{ get { return super;} } + public Vector3fProperty() { + super=new _PBJ_Internal.Vector3fProperty(); + } + public Vector3fProperty(_PBJ_Internal.Vector3fProperty reference) { + super=reference; + } + public static Vector3fProperty defaultInstance= new Vector3fProperty (_PBJ_Internal.Vector3fProperty.DefaultInstance); + public static Vector3fProperty DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.Vector3fProperty.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ValueFieldTag=10; + public bool HasValue{ get {return super.ValueCount>=3;} } + public PBJ.Vector3f Value{ get { + int index=0; + if (HasValue) { + return PBJ._PBJ.CastVector3f(super.GetValue(index*3+0),super.GetValue(index*3+1),super.GetValue(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(Vector3fProperty prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static Vector3fProperty ParseFrom(pb::ByteString data) { + return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data)); + } + public static Vector3fProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er)); + } + public static Vector3fProperty ParseFrom(byte[] data) { + return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data)); + } + public static Vector3fProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er)); + } + public static Vector3fProperty ParseFrom(global::System.IO.Stream data) { + return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data)); + } + public static Vector3fProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er)); + } + public static Vector3fProperty ParseFrom(pb::CodedInputStream data) { + return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data)); + } + public static Vector3fProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.Vector3fProperty.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.Vector3fProperty.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.Vector3fProperty.Builder();} + public Builder(_PBJ_Internal.Vector3fProperty.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(Vector3fProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public Vector3fProperty BuildPartial() {return new Vector3fProperty(super.BuildPartial());} + public Vector3fProperty Build() {if (_HasAllPBJFields) return new Vector3fProperty(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return Vector3fProperty.Descriptor; } } + public Builder ClearValue() { super.ClearValue();return this;} + public const int ValueFieldTag=10; + public bool HasValue{ get {return super.ValueCount>=3;} } + public PBJ.Vector3f Value{ get { + int index=0; + if (HasValue) { + return PBJ._PBJ.CastVector3f(super.GetValue(index*3+0),super.GetValue(index*3+1),super.GetValue(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + set { + super.ClearValue(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.AddValue(_PBJtempArray[0]); + super.AddValue(_PBJtempArray[1]); + super.AddValue(_PBJtempArray[2]); + } + } + } + } +} +namespace Sirikata.Protocol { + public class StringProperty : PBJ.IMessage { + protected _PBJ_Internal.StringProperty super; + public _PBJ_Internal.StringProperty _PBJSuper{ get { return super;} } + public StringProperty() { + super=new _PBJ_Internal.StringProperty(); + } + public StringProperty(_PBJ_Internal.StringProperty reference) { + super=reference; + } + public static StringProperty defaultInstance= new StringProperty (_PBJ_Internal.StringProperty.DefaultInstance); + public static StringProperty DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.StringProperty.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ValueFieldTag=10; + public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateString(super.Value);} } + public string Value{ get { + if (HasValue) { + return PBJ._PBJ.CastString(super.Value); + } else { + return PBJ._PBJ.CastString(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(StringProperty prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static StringProperty ParseFrom(pb::ByteString data) { + return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data)); + } + public static StringProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er)); + } + public static StringProperty ParseFrom(byte[] data) { + return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data)); + } + public static StringProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er)); + } + public static StringProperty ParseFrom(global::System.IO.Stream data) { + return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data)); + } + public static StringProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er)); + } + public static StringProperty ParseFrom(pb::CodedInputStream data) { + return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data)); + } + public static StringProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.StringProperty.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.StringProperty.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.StringProperty.Builder();} + public Builder(_PBJ_Internal.StringProperty.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(StringProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public StringProperty BuildPartial() {return new StringProperty(super.BuildPartial());} + public StringProperty Build() {if (_HasAllPBJFields) return new StringProperty(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return StringProperty.Descriptor; } } + public Builder ClearValue() { super.ClearValue();return this;} + public const int ValueFieldTag=10; + public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateString(super.Value);} } + public string Value{ get { + if (HasValue) { + return PBJ._PBJ.CastString(super.Value); + } else { + return PBJ._PBJ.CastString(); + } + } + set { + super.Value=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Protocol { + public class StringMapProperty : PBJ.IMessage { + protected _PBJ_Internal.StringMapProperty super; + public _PBJ_Internal.StringMapProperty _PBJSuper{ get { return super;} } + public StringMapProperty() { + super=new _PBJ_Internal.StringMapProperty(); + } + public StringMapProperty(_PBJ_Internal.StringMapProperty reference) { + super=reference; + } + public static StringMapProperty defaultInstance= new StringMapProperty (_PBJ_Internal.StringMapProperty.DefaultInstance); + public static StringMapProperty DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.StringMapProperty.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int KeysFieldTag=2; + public int KeysCount { get { return super.KeysCount;} } + public bool HasKeys(int index) {return PBJ._PBJ.ValidateString(super.GetKeys(index));} + public string Keys(int index) { + return (string)PBJ._PBJ.CastString(super.GetKeys(index)); + } + public const int ValuesFieldTag=3; + public int ValuesCount { get { return super.ValuesCount;} } + public bool HasValues(int index) {return PBJ._PBJ.ValidateString(super.GetValues(index));} + public string Values(int index) { + return (string)PBJ._PBJ.CastString(super.GetValues(index)); + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(StringMapProperty prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static StringMapProperty ParseFrom(pb::ByteString data) { + return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data)); + } + public static StringMapProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er)); + } + public static StringMapProperty ParseFrom(byte[] data) { + return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data)); + } + public static StringMapProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er)); + } + public static StringMapProperty ParseFrom(global::System.IO.Stream data) { + return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data)); + } + public static StringMapProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er)); + } + public static StringMapProperty ParseFrom(pb::CodedInputStream data) { + return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data)); + } + public static StringMapProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.StringMapProperty.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.StringMapProperty.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.StringMapProperty.Builder();} + public Builder(_PBJ_Internal.StringMapProperty.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(StringMapProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public StringMapProperty BuildPartial() {return new StringMapProperty(super.BuildPartial());} + public StringMapProperty Build() {if (_HasAllPBJFields) return new StringMapProperty(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return StringMapProperty.Descriptor; } } + public Builder ClearKeys() { super.ClearKeys();return this;} + public Builder SetKeys(int index, string value) { + super.SetKeys(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int KeysFieldTag=2; + public int KeysCount { get { return super.KeysCount;} } + public bool HasKeys(int index) {return PBJ._PBJ.ValidateString(super.GetKeys(index));} + public string Keys(int index) { + return (string)PBJ._PBJ.CastString(super.GetKeys(index)); + } + public Builder AddKeys(string value) { + super.AddKeys(PBJ._PBJ.Construct(value)); + return this; + } + public Builder ClearValues() { super.ClearValues();return this;} + public Builder SetValues(int index, string value) { + super.SetValues(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int ValuesFieldTag=3; + public int ValuesCount { get { return super.ValuesCount;} } + public bool HasValues(int index) {return PBJ._PBJ.ValidateString(super.GetValues(index));} + public string Values(int index) { + return (string)PBJ._PBJ.CastString(super.GetValues(index)); + } + public Builder AddValues(string value) { + super.AddValues(PBJ._PBJ.Construct(value)); + return this; + } + } + } +} +namespace Sirikata.Protocol { + public class PhysicalParameters : PBJ.IMessage { + protected _PBJ_Internal.PhysicalParameters super; + public _PBJ_Internal.PhysicalParameters _PBJSuper{ get { return super;} } + public PhysicalParameters() { + super=new _PBJ_Internal.PhysicalParameters(); + } + public PhysicalParameters(_PBJ_Internal.PhysicalParameters reference) { + super=reference; + } + public static PhysicalParameters defaultInstance= new PhysicalParameters (_PBJ_Internal.PhysicalParameters.DefaultInstance); + public static PhysicalParameters DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.PhysicalParameters.Descriptor; } } + public static class Types { + public enum Mode { + NONPHYSICAL=_PBJ_Internal.PhysicalParameters.Types.Mode.NONPHYSICAL, + STATIC=_PBJ_Internal.PhysicalParameters.Types.Mode.STATIC, + DYNAMICBOX=_PBJ_Internal.PhysicalParameters.Types.Mode.DYNAMICBOX, + DYNAMICSPHERE=_PBJ_Internal.PhysicalParameters.Types.Mode.DYNAMICSPHERE, + DYNAMICCYLINDER=_PBJ_Internal.PhysicalParameters.Types.Mode.DYNAMICCYLINDER, + CHARACTER=_PBJ_Internal.PhysicalParameters.Types.Mode.CHARACTER + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ModeFieldTag=2; + public bool HasMode{ get {return super.HasMode;} } + public Types.Mode Mode{ get { + if (HasMode) { + return (Types.Mode)super.Mode; + } else { + return new Types.Mode(); + } + } + } + public const int DensityFieldTag=3; + public bool HasDensity{ get {return super.HasDensity&&PBJ._PBJ.ValidateFloat(super.Density);} } + public float Density{ get { + if (HasDensity) { + return PBJ._PBJ.CastFloat(super.Density); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int FrictionFieldTag=4; + public bool HasFriction{ get {return super.HasFriction&&PBJ._PBJ.ValidateFloat(super.Friction);} } + public float Friction{ get { + if (HasFriction) { + return PBJ._PBJ.CastFloat(super.Friction); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int BounceFieldTag=5; + public bool HasBounce{ get {return super.HasBounce&&PBJ._PBJ.ValidateFloat(super.Bounce);} } + public float Bounce{ get { + if (HasBounce) { + return PBJ._PBJ.CastFloat(super.Bounce); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int HullFieldTag=6; + public bool HasHull{ get {return super.HullCount>=3;} } + public PBJ.Vector3f Hull{ get { + int index=0; + if (HasHull) { + return PBJ._PBJ.CastVector3f(super.GetHull(index*3+0),super.GetHull(index*3+1),super.GetHull(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + } + public const int CollideMsgFieldTag=16; + public bool HasCollideMsg{ get {return super.HasCollideMsg&&PBJ._PBJ.ValidateUint32(super.CollideMsg);} } + public uint CollideMsg{ get { + if (HasCollideMsg) { + return PBJ._PBJ.CastUint32(super.CollideMsg); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int CollideMaskFieldTag=17; + public bool HasCollideMask{ get {return super.HasCollideMask&&PBJ._PBJ.ValidateUint32(super.CollideMask);} } + public uint CollideMask{ get { + if (HasCollideMask) { + return PBJ._PBJ.CastUint32(super.CollideMask); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int GravityFieldTag=18; + public bool HasGravity{ get {return super.HasGravity&&PBJ._PBJ.ValidateFloat(super.Gravity);} } + public float Gravity{ get { + if (HasGravity) { + return PBJ._PBJ.CastFloat(super.Gravity); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(PhysicalParameters prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static PhysicalParameters ParseFrom(pb::ByteString data) { + return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data)); + } + public static PhysicalParameters ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er)); + } + public static PhysicalParameters ParseFrom(byte[] data) { + return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data)); + } + public static PhysicalParameters ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er)); + } + public static PhysicalParameters ParseFrom(global::System.IO.Stream data) { + return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data)); + } + public static PhysicalParameters ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er)); + } + public static PhysicalParameters ParseFrom(pb::CodedInputStream data) { + return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data)); + } + public static PhysicalParameters ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.PhysicalParameters.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.PhysicalParameters.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.PhysicalParameters.Builder();} + public Builder(_PBJ_Internal.PhysicalParameters.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(PhysicalParameters prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public PhysicalParameters BuildPartial() {return new PhysicalParameters(super.BuildPartial());} + public PhysicalParameters Build() {if (_HasAllPBJFields) return new PhysicalParameters(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return PhysicalParameters.Descriptor; } } + public Builder ClearMode() { super.ClearMode();return this;} + public const int ModeFieldTag=2; + public bool HasMode{ get {return super.HasMode;} } + public Types.Mode Mode{ get { + if (HasMode) { + return (Types.Mode)super.Mode; + } else { + return new Types.Mode(); + } + } + set { + super.Mode=((_PBJ_Internal.PhysicalParameters.Types.Mode)value); + } + } + public Builder ClearDensity() { super.ClearDensity();return this;} + public const int DensityFieldTag=3; + public bool HasDensity{ get {return super.HasDensity&&PBJ._PBJ.ValidateFloat(super.Density);} } + public float Density{ get { + if (HasDensity) { + return PBJ._PBJ.CastFloat(super.Density); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.Density=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearFriction() { super.ClearFriction();return this;} + public const int FrictionFieldTag=4; + public bool HasFriction{ get {return super.HasFriction&&PBJ._PBJ.ValidateFloat(super.Friction);} } + public float Friction{ get { + if (HasFriction) { + return PBJ._PBJ.CastFloat(super.Friction); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.Friction=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearBounce() { super.ClearBounce();return this;} + public const int BounceFieldTag=5; + public bool HasBounce{ get {return super.HasBounce&&PBJ._PBJ.ValidateFloat(super.Bounce);} } + public float Bounce{ get { + if (HasBounce) { + return PBJ._PBJ.CastFloat(super.Bounce); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.Bounce=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearHull() { super.ClearHull();return this;} + public const int HullFieldTag=6; + public bool HasHull{ get {return super.HullCount>=3;} } + public PBJ.Vector3f Hull{ get { + int index=0; + if (HasHull) { + return PBJ._PBJ.CastVector3f(super.GetHull(index*3+0),super.GetHull(index*3+1),super.GetHull(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + set { + super.ClearHull(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.AddHull(_PBJtempArray[0]); + super.AddHull(_PBJtempArray[1]); + super.AddHull(_PBJtempArray[2]); + } + } + public Builder ClearCollideMsg() { super.ClearCollideMsg();return this;} + public const int CollideMsgFieldTag=16; + public bool HasCollideMsg{ get {return super.HasCollideMsg&&PBJ._PBJ.ValidateUint32(super.CollideMsg);} } + public uint CollideMsg{ get { + if (HasCollideMsg) { + return PBJ._PBJ.CastUint32(super.CollideMsg); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.CollideMsg=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearCollideMask() { super.ClearCollideMask();return this;} + public const int CollideMaskFieldTag=17; + public bool HasCollideMask{ get {return super.HasCollideMask&&PBJ._PBJ.ValidateUint32(super.CollideMask);} } + public uint CollideMask{ get { + if (HasCollideMask) { + return PBJ._PBJ.CastUint32(super.CollideMask); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.CollideMask=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearGravity() { super.ClearGravity();return this;} + public const int GravityFieldTag=18; + public bool HasGravity{ get {return super.HasGravity&&PBJ._PBJ.ValidateFloat(super.Gravity);} } + public float Gravity{ get { + if (HasGravity) { + return PBJ._PBJ.CastFloat(super.Gravity); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.Gravity=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Protocol { + public class LightInfoProperty : PBJ.IMessage { + protected _PBJ_Internal.LightInfoProperty super; + public _PBJ_Internal.LightInfoProperty _PBJSuper{ get { return super;} } + public LightInfoProperty() { + super=new _PBJ_Internal.LightInfoProperty(); + } + public LightInfoProperty(_PBJ_Internal.LightInfoProperty reference) { + super=reference; + } + public static LightInfoProperty defaultInstance= new LightInfoProperty (_PBJ_Internal.LightInfoProperty.DefaultInstance); + public static LightInfoProperty DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.LightInfoProperty.Descriptor; } } + public static class Types { + public enum LightTypes { + POINT=_PBJ_Internal.LightInfoProperty.Types.LightTypes.POINT, + SPOTLIGHT=_PBJ_Internal.LightInfoProperty.Types.LightTypes.SPOTLIGHT, + DIRECTIONAL=_PBJ_Internal.LightInfoProperty.Types.LightTypes.DIRECTIONAL + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int DiffuseColorFieldTag=3; + public bool HasDiffuseColor{ get {return super.DiffuseColorCount>=3;} } + public PBJ.Vector3f DiffuseColor{ get { + int index=0; + if (HasDiffuseColor) { + return PBJ._PBJ.CastVector3f(super.GetDiffuseColor(index*3+0),super.GetDiffuseColor(index*3+1),super.GetDiffuseColor(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + } + public const int SpecularColorFieldTag=4; + public bool HasSpecularColor{ get {return super.SpecularColorCount>=3;} } + public PBJ.Vector3f SpecularColor{ get { + int index=0; + if (HasSpecularColor) { + return PBJ._PBJ.CastVector3f(super.GetSpecularColor(index*3+0),super.GetSpecularColor(index*3+1),super.GetSpecularColor(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + } + public const int PowerFieldTag=5; + public bool HasPower{ get {return super.HasPower&&PBJ._PBJ.ValidateFloat(super.Power);} } + public float Power{ get { + if (HasPower) { + return PBJ._PBJ.CastFloat(super.Power); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int AmbientColorFieldTag=6; + public bool HasAmbientColor{ get {return super.AmbientColorCount>=3;} } + public PBJ.Vector3f AmbientColor{ get { + int index=0; + if (HasAmbientColor) { + return PBJ._PBJ.CastVector3f(super.GetAmbientColor(index*3+0),super.GetAmbientColor(index*3+1),super.GetAmbientColor(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + } + public const int ShadowColorFieldTag=7; + public bool HasShadowColor{ get {return super.ShadowColorCount>=3;} } + public PBJ.Vector3f ShadowColor{ get { + int index=0; + if (HasShadowColor) { + return PBJ._PBJ.CastVector3f(super.GetShadowColor(index*3+0),super.GetShadowColor(index*3+1),super.GetShadowColor(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + } + public const int LightRangeFieldTag=8; + public bool HasLightRange{ get {return super.HasLightRange&&PBJ._PBJ.ValidateDouble(super.LightRange);} } + public double LightRange{ get { + if (HasLightRange) { + return PBJ._PBJ.CastDouble(super.LightRange); + } else { + return PBJ._PBJ.CastDouble(); + } + } + } + public const int ConstantFalloffFieldTag=9; + public bool HasConstantFalloff{ get {return super.HasConstantFalloff&&PBJ._PBJ.ValidateFloat(super.ConstantFalloff);} } + public float ConstantFalloff{ get { + if (HasConstantFalloff) { + return PBJ._PBJ.CastFloat(super.ConstantFalloff); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int LinearFalloffFieldTag=10; + public bool HasLinearFalloff{ get {return super.HasLinearFalloff&&PBJ._PBJ.ValidateFloat(super.LinearFalloff);} } + public float LinearFalloff{ get { + if (HasLinearFalloff) { + return PBJ._PBJ.CastFloat(super.LinearFalloff); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int QuadraticFalloffFieldTag=11; + public bool HasQuadraticFalloff{ get {return super.HasQuadraticFalloff&&PBJ._PBJ.ValidateFloat(super.QuadraticFalloff);} } + public float QuadraticFalloff{ get { + if (HasQuadraticFalloff) { + return PBJ._PBJ.CastFloat(super.QuadraticFalloff); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int ConeInnerRadiansFieldTag=12; + public bool HasConeInnerRadians{ get {return super.HasConeInnerRadians&&PBJ._PBJ.ValidateFloat(super.ConeInnerRadians);} } + public float ConeInnerRadians{ get { + if (HasConeInnerRadians) { + return PBJ._PBJ.CastFloat(super.ConeInnerRadians); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int ConeOuterRadiansFieldTag=13; + public bool HasConeOuterRadians{ get {return super.HasConeOuterRadians&&PBJ._PBJ.ValidateFloat(super.ConeOuterRadians);} } + public float ConeOuterRadians{ get { + if (HasConeOuterRadians) { + return PBJ._PBJ.CastFloat(super.ConeOuterRadians); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int ConeFalloffFieldTag=14; + public bool HasConeFalloff{ get {return super.HasConeFalloff&&PBJ._PBJ.ValidateFloat(super.ConeFalloff);} } + public float ConeFalloff{ get { + if (HasConeFalloff) { + return PBJ._PBJ.CastFloat(super.ConeFalloff); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int TypeFieldTag=15; + public bool HasType{ get {return super.HasType;} } + public Types.LightTypes Type{ get { + if (HasType) { + return (Types.LightTypes)super.Type; + } else { + return new Types.LightTypes(); + } + } + } + public const int CastsShadowFieldTag=16; + public bool HasCastsShadow{ get {return super.HasCastsShadow&&PBJ._PBJ.ValidateBool(super.CastsShadow);} } + public bool CastsShadow{ get { + if (HasCastsShadow) { + return PBJ._PBJ.CastBool(super.CastsShadow); + } else { + return PBJ._PBJ.CastBool(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(LightInfoProperty prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static LightInfoProperty ParseFrom(pb::ByteString data) { + return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data)); + } + public static LightInfoProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er)); + } + public static LightInfoProperty ParseFrom(byte[] data) { + return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data)); + } + public static LightInfoProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er)); + } + public static LightInfoProperty ParseFrom(global::System.IO.Stream data) { + return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data)); + } + public static LightInfoProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er)); + } + public static LightInfoProperty ParseFrom(pb::CodedInputStream data) { + return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data)); + } + public static LightInfoProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.LightInfoProperty.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.LightInfoProperty.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.LightInfoProperty.Builder();} + public Builder(_PBJ_Internal.LightInfoProperty.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(LightInfoProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public LightInfoProperty BuildPartial() {return new LightInfoProperty(super.BuildPartial());} + public LightInfoProperty Build() {if (_HasAllPBJFields) return new LightInfoProperty(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return LightInfoProperty.Descriptor; } } + public Builder ClearDiffuseColor() { super.ClearDiffuseColor();return this;} + public const int DiffuseColorFieldTag=3; + public bool HasDiffuseColor{ get {return super.DiffuseColorCount>=3;} } + public PBJ.Vector3f DiffuseColor{ get { + int index=0; + if (HasDiffuseColor) { + return PBJ._PBJ.CastVector3f(super.GetDiffuseColor(index*3+0),super.GetDiffuseColor(index*3+1),super.GetDiffuseColor(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + set { + super.ClearDiffuseColor(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.AddDiffuseColor(_PBJtempArray[0]); + super.AddDiffuseColor(_PBJtempArray[1]); + super.AddDiffuseColor(_PBJtempArray[2]); + } + } + public Builder ClearSpecularColor() { super.ClearSpecularColor();return this;} + public const int SpecularColorFieldTag=4; + public bool HasSpecularColor{ get {return super.SpecularColorCount>=3;} } + public PBJ.Vector3f SpecularColor{ get { + int index=0; + if (HasSpecularColor) { + return PBJ._PBJ.CastVector3f(super.GetSpecularColor(index*3+0),super.GetSpecularColor(index*3+1),super.GetSpecularColor(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + set { + super.ClearSpecularColor(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.AddSpecularColor(_PBJtempArray[0]); + super.AddSpecularColor(_PBJtempArray[1]); + super.AddSpecularColor(_PBJtempArray[2]); + } + } + public Builder ClearPower() { super.ClearPower();return this;} + public const int PowerFieldTag=5; + public bool HasPower{ get {return super.HasPower&&PBJ._PBJ.ValidateFloat(super.Power);} } + public float Power{ get { + if (HasPower) { + return PBJ._PBJ.CastFloat(super.Power); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.Power=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearAmbientColor() { super.ClearAmbientColor();return this;} + public const int AmbientColorFieldTag=6; + public bool HasAmbientColor{ get {return super.AmbientColorCount>=3;} } + public PBJ.Vector3f AmbientColor{ get { + int index=0; + if (HasAmbientColor) { + return PBJ._PBJ.CastVector3f(super.GetAmbientColor(index*3+0),super.GetAmbientColor(index*3+1),super.GetAmbientColor(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + set { + super.ClearAmbientColor(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.AddAmbientColor(_PBJtempArray[0]); + super.AddAmbientColor(_PBJtempArray[1]); + super.AddAmbientColor(_PBJtempArray[2]); + } + } + public Builder ClearShadowColor() { super.ClearShadowColor();return this;} + public const int ShadowColorFieldTag=7; + public bool HasShadowColor{ get {return super.ShadowColorCount>=3;} } + public PBJ.Vector3f ShadowColor{ get { + int index=0; + if (HasShadowColor) { + return PBJ._PBJ.CastVector3f(super.GetShadowColor(index*3+0),super.GetShadowColor(index*3+1),super.GetShadowColor(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + set { + super.ClearShadowColor(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.AddShadowColor(_PBJtempArray[0]); + super.AddShadowColor(_PBJtempArray[1]); + super.AddShadowColor(_PBJtempArray[2]); + } + } + public Builder ClearLightRange() { super.ClearLightRange();return this;} + public const int LightRangeFieldTag=8; + public bool HasLightRange{ get {return super.HasLightRange&&PBJ._PBJ.ValidateDouble(super.LightRange);} } + public double LightRange{ get { + if (HasLightRange) { + return PBJ._PBJ.CastDouble(super.LightRange); + } else { + return PBJ._PBJ.CastDouble(); + } + } + set { + super.LightRange=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearConstantFalloff() { super.ClearConstantFalloff();return this;} + public const int ConstantFalloffFieldTag=9; + public bool HasConstantFalloff{ get {return super.HasConstantFalloff&&PBJ._PBJ.ValidateFloat(super.ConstantFalloff);} } + public float ConstantFalloff{ get { + if (HasConstantFalloff) { + return PBJ._PBJ.CastFloat(super.ConstantFalloff); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.ConstantFalloff=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearLinearFalloff() { super.ClearLinearFalloff();return this;} + public const int LinearFalloffFieldTag=10; + public bool HasLinearFalloff{ get {return super.HasLinearFalloff&&PBJ._PBJ.ValidateFloat(super.LinearFalloff);} } + public float LinearFalloff{ get { + if (HasLinearFalloff) { + return PBJ._PBJ.CastFloat(super.LinearFalloff); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.LinearFalloff=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearQuadraticFalloff() { super.ClearQuadraticFalloff();return this;} + public const int QuadraticFalloffFieldTag=11; + public bool HasQuadraticFalloff{ get {return super.HasQuadraticFalloff&&PBJ._PBJ.ValidateFloat(super.QuadraticFalloff);} } + public float QuadraticFalloff{ get { + if (HasQuadraticFalloff) { + return PBJ._PBJ.CastFloat(super.QuadraticFalloff); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.QuadraticFalloff=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearConeInnerRadians() { super.ClearConeInnerRadians();return this;} + public const int ConeInnerRadiansFieldTag=12; + public bool HasConeInnerRadians{ get {return super.HasConeInnerRadians&&PBJ._PBJ.ValidateFloat(super.ConeInnerRadians);} } + public float ConeInnerRadians{ get { + if (HasConeInnerRadians) { + return PBJ._PBJ.CastFloat(super.ConeInnerRadians); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.ConeInnerRadians=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearConeOuterRadians() { super.ClearConeOuterRadians();return this;} + public const int ConeOuterRadiansFieldTag=13; + public bool HasConeOuterRadians{ get {return super.HasConeOuterRadians&&PBJ._PBJ.ValidateFloat(super.ConeOuterRadians);} } + public float ConeOuterRadians{ get { + if (HasConeOuterRadians) { + return PBJ._PBJ.CastFloat(super.ConeOuterRadians); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.ConeOuterRadians=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearConeFalloff() { super.ClearConeFalloff();return this;} + public const int ConeFalloffFieldTag=14; + public bool HasConeFalloff{ get {return super.HasConeFalloff&&PBJ._PBJ.ValidateFloat(super.ConeFalloff);} } + public float ConeFalloff{ get { + if (HasConeFalloff) { + return PBJ._PBJ.CastFloat(super.ConeFalloff); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.ConeFalloff=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearType() { super.ClearType();return this;} + public const int TypeFieldTag=15; + public bool HasType{ get {return super.HasType;} } + public Types.LightTypes Type{ get { + if (HasType) { + return (Types.LightTypes)super.Type; + } else { + return new Types.LightTypes(); + } + } + set { + super.Type=((_PBJ_Internal.LightInfoProperty.Types.LightTypes)value); + } + } + public Builder ClearCastsShadow() { super.ClearCastsShadow();return this;} + public const int CastsShadowFieldTag=16; + public bool HasCastsShadow{ get {return super.HasCastsShadow&&PBJ._PBJ.ValidateBool(super.CastsShadow);} } + public bool CastsShadow{ get { + if (HasCastsShadow) { + return PBJ._PBJ.CastBool(super.CastsShadow); + } else { + return PBJ._PBJ.CastBool(); + } + } + set { + super.CastsShadow=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Protocol { + public class ParentProperty : PBJ.IMessage { + protected _PBJ_Internal.ParentProperty super; + public _PBJ_Internal.ParentProperty _PBJSuper{ get { return super;} } + public ParentProperty() { + super=new _PBJ_Internal.ParentProperty(); + } + public ParentProperty(_PBJ_Internal.ParentProperty reference) { + super=reference; + } + public static ParentProperty defaultInstance= new ParentProperty (_PBJ_Internal.ParentProperty.DefaultInstance); + public static ParentProperty DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.ParentProperty.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ValueFieldTag=10; + public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateUuid(super.Value);} } + public PBJ.UUID Value{ get { + if (HasValue) { + return PBJ._PBJ.CastUuid(super.Value); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(ParentProperty prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static ParentProperty ParseFrom(pb::ByteString data) { + return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data)); + } + public static ParentProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er)); + } + public static ParentProperty ParseFrom(byte[] data) { + return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data)); + } + public static ParentProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er)); + } + public static ParentProperty ParseFrom(global::System.IO.Stream data) { + return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data)); + } + public static ParentProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er)); + } + public static ParentProperty ParseFrom(pb::CodedInputStream data) { + return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data)); + } + public static ParentProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.ParentProperty.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.ParentProperty.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.ParentProperty.Builder();} + public Builder(_PBJ_Internal.ParentProperty.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(ParentProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public ParentProperty BuildPartial() {return new ParentProperty(super.BuildPartial());} + public ParentProperty Build() {if (_HasAllPBJFields) return new ParentProperty(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return ParentProperty.Descriptor; } } + public Builder ClearValue() { super.ClearValue();return this;} + public const int ValueFieldTag=10; + public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateUuid(super.Value);} } + public PBJ.UUID Value{ get { + if (HasValue) { + return PBJ._PBJ.CastUuid(super.Value); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.Value=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Protocol { + public class UUIDListProperty : PBJ.IMessage { + protected _PBJ_Internal.UUIDListProperty super; + public _PBJ_Internal.UUIDListProperty _PBJSuper{ get { return super;} } + public UUIDListProperty() { + super=new _PBJ_Internal.UUIDListProperty(); + } + public UUIDListProperty(_PBJ_Internal.UUIDListProperty reference) { + super=reference; + } + public static UUIDListProperty defaultInstance= new UUIDListProperty (_PBJ_Internal.UUIDListProperty.DefaultInstance); + public static UUIDListProperty DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.UUIDListProperty.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ValueFieldTag=10; + public int ValueCount { get { return super.ValueCount;} } + public bool HasValue(int index) {return PBJ._PBJ.ValidateUuid(super.GetValue(index));} + public PBJ.UUID Value(int index) { + return (PBJ.UUID)PBJ._PBJ.CastUuid(super.GetValue(index)); + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(UUIDListProperty prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static UUIDListProperty ParseFrom(pb::ByteString data) { + return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data)); + } + public static UUIDListProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er)); + } + public static UUIDListProperty ParseFrom(byte[] data) { + return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data)); + } + public static UUIDListProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er)); + } + public static UUIDListProperty ParseFrom(global::System.IO.Stream data) { + return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data)); + } + public static UUIDListProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er)); + } + public static UUIDListProperty ParseFrom(pb::CodedInputStream data) { + return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data)); + } + public static UUIDListProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.UUIDListProperty.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.UUIDListProperty.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.UUIDListProperty.Builder();} + public Builder(_PBJ_Internal.UUIDListProperty.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(UUIDListProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public UUIDListProperty BuildPartial() {return new UUIDListProperty(super.BuildPartial());} + public UUIDListProperty Build() {if (_HasAllPBJFields) return new UUIDListProperty(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return UUIDListProperty.Descriptor; } } + public Builder ClearValue() { super.ClearValue();return this;} + public Builder SetValue(int index, PBJ.UUID value) { + super.SetValue(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int ValueFieldTag=10; + public int ValueCount { get { return super.ValueCount;} } + public bool HasValue(int index) {return PBJ._PBJ.ValidateUuid(super.GetValue(index));} + public PBJ.UUID Value(int index) { + return (PBJ.UUID)PBJ._PBJ.CastUuid(super.GetValue(index)); + } + public Builder AddValue(PBJ.UUID value) { + super.AddValue(PBJ._PBJ.Construct(value)); + return this; + } + } + } +} +namespace Sirikata.Protocol { + public class ConnectToSpace : PBJ.IMessage { + protected _PBJ_Internal.ConnectToSpace super; + public _PBJ_Internal.ConnectToSpace _PBJSuper{ get { return super;} } + public ConnectToSpace() { + super=new _PBJ_Internal.ConnectToSpace(); + } + public ConnectToSpace(_PBJ_Internal.ConnectToSpace reference) { + super=reference; + } + public static ConnectToSpace defaultInstance= new ConnectToSpace (_PBJ_Internal.ConnectToSpace.DefaultInstance); + public static ConnectToSpace DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.ConnectToSpace.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int SpaceIdFieldTag=1; + public bool HasSpaceId{ get {return super.HasSpaceId&&PBJ._PBJ.ValidateUuid(super.SpaceId);} } + public PBJ.UUID SpaceId{ get { + if (HasSpaceId) { + return PBJ._PBJ.CastUuid(super.SpaceId); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int ObjectUuidEvidenceFieldTag=2; + public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} } + public PBJ.UUID ObjectUuidEvidence{ get { + if (HasObjectUuidEvidence) { + return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int RequestedObjectLocFieldTag=3; + public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} } + public ObjLoc RequestedObjectLoc{ get { + if (HasRequestedObjectLoc) { + return new ObjLoc(super.RequestedObjectLoc); + } else { + return new ObjLoc(); + } + } + } + public const int BoundingSphereFieldTag=4; + public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} } + public PBJ.BoundingSphere3f BoundingSphere{ get { + int index=0; + if (HasBoundingSphere) { + return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3)); + } else { + return PBJ._PBJ.CastBoundingsphere3f(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(ConnectToSpace prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static ConnectToSpace ParseFrom(pb::ByteString data) { + return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data)); + } + public static ConnectToSpace ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er)); + } + public static ConnectToSpace ParseFrom(byte[] data) { + return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data)); + } + public static ConnectToSpace ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er)); + } + public static ConnectToSpace ParseFrom(global::System.IO.Stream data) { + return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data)); + } + public static ConnectToSpace ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er)); + } + public static ConnectToSpace ParseFrom(pb::CodedInputStream data) { + return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data)); + } + public static ConnectToSpace ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.ConnectToSpace.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.ConnectToSpace.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.ConnectToSpace.Builder();} + public Builder(_PBJ_Internal.ConnectToSpace.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(ConnectToSpace prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public ConnectToSpace BuildPartial() {return new ConnectToSpace(super.BuildPartial());} + public ConnectToSpace Build() {if (_HasAllPBJFields) return new ConnectToSpace(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return ConnectToSpace.Descriptor; } } + public Builder ClearSpaceId() { super.ClearSpaceId();return this;} + public const int SpaceIdFieldTag=1; + public bool HasSpaceId{ get {return super.HasSpaceId&&PBJ._PBJ.ValidateUuid(super.SpaceId);} } + public PBJ.UUID SpaceId{ get { + if (HasSpaceId) { + return PBJ._PBJ.CastUuid(super.SpaceId); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.SpaceId=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearObjectUuidEvidence() { super.ClearObjectUuidEvidence();return this;} + public const int ObjectUuidEvidenceFieldTag=2; + public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} } + public PBJ.UUID ObjectUuidEvidence{ get { + if (HasObjectUuidEvidence) { + return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.ObjectUuidEvidence=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearRequestedObjectLoc() { super.ClearRequestedObjectLoc();return this;} + public const int RequestedObjectLocFieldTag=3; + public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} } + public ObjLoc RequestedObjectLoc{ get { + if (HasRequestedObjectLoc) { + return new ObjLoc(super.RequestedObjectLoc); + } else { + return new ObjLoc(); + } + } + set { + super.RequestedObjectLoc=value._PBJSuper; + } + } + public Builder ClearBoundingSphere() { super.ClearBoundingSphere();return this;} + public const int BoundingSphereFieldTag=4; + public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} } + public PBJ.BoundingSphere3f BoundingSphere{ get { + int index=0; + if (HasBoundingSphere) { + return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3)); + } else { + return PBJ._PBJ.CastBoundingsphere3f(); + } + } + set { + super.ClearBoundingSphere(); + float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value); + super.AddBoundingSphere(_PBJtempArray[0]); + super.AddBoundingSphere(_PBJtempArray[1]); + super.AddBoundingSphere(_PBJtempArray[2]); + super.AddBoundingSphere(_PBJtempArray[3]); + } + } + } + } +} +namespace Sirikata.Protocol { + public class CreateObject : PBJ.IMessage { + protected _PBJ_Internal.CreateObject super; + public _PBJ_Internal.CreateObject _PBJSuper{ get { return super;} } + public CreateObject() { + super=new _PBJ_Internal.CreateObject(); + } + public CreateObject(_PBJ_Internal.CreateObject reference) { + super=reference; + } + public static CreateObject defaultInstance= new CreateObject (_PBJ_Internal.CreateObject.DefaultInstance); + public static CreateObject DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.CreateObject.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ObjectUuidFieldTag=1; + public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } + public PBJ.UUID ObjectUuid{ get { + if (HasObjectUuid) { + return PBJ._PBJ.CastUuid(super.ObjectUuid); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int SpacePropertiesFieldTag=2; + public int SpacePropertiesCount { get { return super.SpacePropertiesCount;} } + public bool HasSpaceProperties(int index) {return true;} + public ConnectToSpace SpaceProperties(int index) { + return new ConnectToSpace(super.GetSpaceProperties(index)); + } + public const int MeshFieldTag=3; + public bool HasMesh{ get {return super.HasMesh&&PBJ._PBJ.ValidateString(super.Mesh);} } + public string Mesh{ get { + if (HasMesh) { + return PBJ._PBJ.CastString(super.Mesh); + } else { + return PBJ._PBJ.CastString(); + } + } + } + public const int ScaleFieldTag=4; + public bool HasScale{ get {return super.ScaleCount>=3;} } + public PBJ.Vector3f Scale{ get { + int index=0; + if (HasScale) { + return PBJ._PBJ.CastVector3f(super.GetScale(index*3+0),super.GetScale(index*3+1),super.GetScale(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + } + public const int WeburlFieldTag=5; + public bool HasWeburl{ get {return super.HasWeburl&&PBJ._PBJ.ValidateString(super.Weburl);} } + public string Weburl{ get { + if (HasWeburl) { + return PBJ._PBJ.CastString(super.Weburl); + } else { + return PBJ._PBJ.CastString(); + } + } + } + public const int LightInfoFieldTag=6; + public bool HasLightInfo{ get {return super.HasLightInfo;} } + public LightInfoProperty LightInfo{ get { + if (HasLightInfo) { + return new LightInfoProperty(super.LightInfo); + } else { + return new LightInfoProperty(); + } + } + } + public const int CameraFieldTag=7; + public bool HasCamera{ get {return super.HasCamera&&PBJ._PBJ.ValidateBool(super.Camera);} } + public bool Camera{ get { + if (HasCamera) { + return PBJ._PBJ.CastBool(super.Camera); + } else { + return PBJ._PBJ.CastBool(); + } + } + } + public const int PhysicalFieldTag=8; + public bool HasPhysical{ get {return super.HasPhysical;} } + public PhysicalParameters Physical{ get { + if (HasPhysical) { + return new PhysicalParameters(super.Physical); + } else { + return new PhysicalParameters(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(CreateObject prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static CreateObject ParseFrom(pb::ByteString data) { + return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data)); + } + public static CreateObject ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er)); + } + public static CreateObject ParseFrom(byte[] data) { + return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data)); + } + public static CreateObject ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er)); + } + public static CreateObject ParseFrom(global::System.IO.Stream data) { + return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data)); + } + public static CreateObject ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er)); + } + public static CreateObject ParseFrom(pb::CodedInputStream data) { + return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data)); + } + public static CreateObject ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.CreateObject.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.CreateObject.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.CreateObject.Builder();} + public Builder(_PBJ_Internal.CreateObject.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(CreateObject prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public CreateObject BuildPartial() {return new CreateObject(super.BuildPartial());} + public CreateObject Build() {if (_HasAllPBJFields) return new CreateObject(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return CreateObject.Descriptor; } } + public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;} + public const int ObjectUuidFieldTag=1; + public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } + public PBJ.UUID ObjectUuid{ get { + if (HasObjectUuid) { + return PBJ._PBJ.CastUuid(super.ObjectUuid); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.ObjectUuid=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearSpaceProperties() { super.ClearSpaceProperties();return this;} + public Builder SetSpaceProperties(int index,ConnectToSpace value) { + super.SetSpaceProperties(index,value._PBJSuper); + return this; + } + public const int SpacePropertiesFieldTag=2; + public int SpacePropertiesCount { get { return super.SpacePropertiesCount;} } + public bool HasSpaceProperties(int index) {return true;} + public ConnectToSpace SpaceProperties(int index) { + return new ConnectToSpace(super.GetSpaceProperties(index)); + } + public Builder AddSpaceProperties(ConnectToSpace value ) { + super.AddSpaceProperties(value._PBJSuper); + return this; + } + public Builder ClearMesh() { super.ClearMesh();return this;} + public const int MeshFieldTag=3; + public bool HasMesh{ get {return super.HasMesh&&PBJ._PBJ.ValidateString(super.Mesh);} } + public string Mesh{ get { + if (HasMesh) { + return PBJ._PBJ.CastString(super.Mesh); + } else { + return PBJ._PBJ.CastString(); + } + } + set { + super.Mesh=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearScale() { super.ClearScale();return this;} + public const int ScaleFieldTag=4; + public bool HasScale{ get {return super.ScaleCount>=3;} } + public PBJ.Vector3f Scale{ get { + int index=0; + if (HasScale) { + return PBJ._PBJ.CastVector3f(super.GetScale(index*3+0),super.GetScale(index*3+1),super.GetScale(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + set { + super.ClearScale(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.AddScale(_PBJtempArray[0]); + super.AddScale(_PBJtempArray[1]); + super.AddScale(_PBJtempArray[2]); + } + } + public Builder ClearWeburl() { super.ClearWeburl();return this;} + public const int WeburlFieldTag=5; + public bool HasWeburl{ get {return super.HasWeburl&&PBJ._PBJ.ValidateString(super.Weburl);} } + public string Weburl{ get { + if (HasWeburl) { + return PBJ._PBJ.CastString(super.Weburl); + } else { + return PBJ._PBJ.CastString(); + } + } + set { + super.Weburl=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearLightInfo() { super.ClearLightInfo();return this;} + public const int LightInfoFieldTag=6; + public bool HasLightInfo{ get {return super.HasLightInfo;} } + public LightInfoProperty LightInfo{ get { + if (HasLightInfo) { + return new LightInfoProperty(super.LightInfo); + } else { + return new LightInfoProperty(); + } + } + set { + super.LightInfo=value._PBJSuper; + } + } + public Builder ClearCamera() { super.ClearCamera();return this;} + public const int CameraFieldTag=7; + public bool HasCamera{ get {return super.HasCamera&&PBJ._PBJ.ValidateBool(super.Camera);} } + public bool Camera{ get { + if (HasCamera) { + return PBJ._PBJ.CastBool(super.Camera); + } else { + return PBJ._PBJ.CastBool(); + } + } + set { + super.Camera=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearPhysical() { super.ClearPhysical();return this;} + public const int PhysicalFieldTag=8; + public bool HasPhysical{ get {return super.HasPhysical;} } + public PhysicalParameters Physical{ get { + if (HasPhysical) { + return new PhysicalParameters(super.Physical); + } else { + return new PhysicalParameters(); + } + } + set { + super.Physical=value._PBJSuper; + } + } + } + } +} diff --git a/OpenSim/Client/Sirikata/Protocol/Subscription.cs b/OpenSim/Client/Sirikata/Protocol/Subscription.cs new file mode 100644 index 0000000..06ac8a2 --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Subscription.cs @@ -0,0 +1,856 @@ +// 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.Subscription.Protocol._PBJ_Internal { + + public static partial class Subscription { + + #region Extension registration + public static void RegisterAllExtensions(pb::ExtensionRegistry registry) { + } + #endregion + #region Static variables + internal static pbd::MessageDescriptor internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__FieldAccessorTable; + #endregion + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbd::FileDescriptor descriptor; + + static Subscription() { + byte[] descriptorData = global::System.Convert.FromBase64String( + "ChJTdWJzY3JpcHRpb24ucHJvdG8SLFNpcmlrYXRhLlN1YnNjcmlwdGlvbi5Q" + + "cm90b2NvbC5fUEJKX0ludGVybmFsIiwKB0FkZHJlc3MSEAoIaG9zdG5hbWUY" + + "ASABKAkSDwoHc2VydmljZRgCIAEoCSKMAQoJU3Vic2NyaWJlElAKEWJyb2Fk" + + "Y2FzdF9hZGRyZXNzGAcgASgLMjUuU2lyaWthdGEuU3Vic2NyaXB0aW9uLlBy" + + "b3RvY29sLl9QQkpfSW50ZXJuYWwuQWRkcmVzcxIWCg5icm9hZGNhc3RfbmFt" + + "ZRgIIAEoDBIVCg11cGRhdGVfcGVyaW9kGAkgASgQIiMKCUJyb2FkY2FzdBIW" + + "Cg5icm9hZGNhc3RfbmFtZRgHIAEoDA=="); + pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { + descriptor = root; + internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__Descriptor = Descriptor.MessageTypes[0]; + internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__Descriptor, + new string[] { "Hostname", "Service", }); + internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__Descriptor = Descriptor.MessageTypes[1]; + internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__Descriptor, + new string[] { "BroadcastAddress", "BroadcastName", "UpdatePeriod", }); + internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__Descriptor = Descriptor.MessageTypes[2]; + internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__Descriptor, + new string[] { "BroadcastName", }); + return null; + }; + pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, + new pbd::FileDescriptor[] { + }, assigner); + } + #endregion + + } + #region Messages + public sealed partial class Address : pb::GeneratedMessage { + private static readonly Address defaultInstance = new Builder().BuildPartial(); + public static Address DefaultInstance { + get { return defaultInstance; } + } + + public override Address DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Address ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__FieldAccessorTable; } + } + + public const int HostnameFieldNumber = 1; + private bool hasHostname; + private string hostname_ = ""; + public bool HasHostname { + get { return hasHostname; } + } + public string Hostname { + get { return hostname_; } + } + + public const int ServiceFieldNumber = 2; + private bool hasService; + private string service_ = ""; + public bool HasService { + get { return hasService; } + } + public string Service { + get { return service_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasHostname) { + output.WriteString(1, Hostname); + } + if (HasService) { + output.WriteString(2, Service); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasHostname) { + size += pb::CodedOutputStream.ComputeStringSize(1, Hostname); + } + if (HasService) { + size += pb::CodedOutputStream.ComputeStringSize(2, Service); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Address ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Address ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Address ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Address ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Address ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Address ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Address ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static Address ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static Address ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Address 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(Address prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Address result = new Address(); + + protected override Address MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Address(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.Descriptor; } + } + + public override Address DefaultInstanceForType { + get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.DefaultInstance; } + } + + public override Address BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + Address returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Address) { + return MergeFrom((Address) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Address other) { + if (other == global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.DefaultInstance) return this; + if (other.HasHostname) { + Hostname = other.Hostname; + } + if (other.HasService) { + Service = other.Service; + } + 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: { + Hostname = input.ReadString(); + break; + } + case 18: { + Service = input.ReadString(); + break; + } + } + } + } + + + public bool HasHostname { + get { return result.HasHostname; } + } + public string Hostname { + get { return result.Hostname; } + set { SetHostname(value); } + } + public Builder SetHostname(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasHostname = true; + result.hostname_ = value; + return this; + } + public Builder ClearHostname() { + result.hasHostname = false; + result.hostname_ = ""; + return this; + } + + public bool HasService { + get { return result.HasService; } + } + public string Service { + get { return result.Service; } + set { SetService(value); } + } + public Builder SetService(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasService = true; + result.service_ = value; + return this; + } + public Builder ClearService() { + result.hasService = false; + result.service_ = ""; + return this; + } + } + static Address() { + object.ReferenceEquals(global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.Descriptor, null); + } + } + + public sealed partial class Subscribe : pb::GeneratedMessage { + private static readonly Subscribe defaultInstance = new Builder().BuildPartial(); + public static Subscribe DefaultInstance { + get { return defaultInstance; } + } + + public override Subscribe DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Subscribe ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__FieldAccessorTable; } + } + + public const int BroadcastAddressFieldNumber = 7; + private bool hasBroadcastAddress; + private global::Sirikata.Subscription.Protocol._PBJ_Internal.Address broadcastAddress_ = global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.DefaultInstance; + public bool HasBroadcastAddress { + get { return hasBroadcastAddress; } + } + public global::Sirikata.Subscription.Protocol._PBJ_Internal.Address BroadcastAddress { + get { return broadcastAddress_; } + } + + public const int BroadcastNameFieldNumber = 8; + private bool hasBroadcastName; + private pb::ByteString broadcastName_ = pb::ByteString.Empty; + public bool HasBroadcastName { + get { return hasBroadcastName; } + } + public pb::ByteString BroadcastName { + get { return broadcastName_; } + } + + public const int UpdatePeriodFieldNumber = 9; + private bool hasUpdatePeriod; + private long updatePeriod_ = 0; + public bool HasUpdatePeriod { + get { return hasUpdatePeriod; } + } + public long UpdatePeriod { + get { return updatePeriod_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasBroadcastAddress) { + output.WriteMessage(7, BroadcastAddress); + } + if (HasBroadcastName) { + output.WriteBytes(8, BroadcastName); + } + if (HasUpdatePeriod) { + output.WriteSFixed64(9, UpdatePeriod); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasBroadcastAddress) { + size += pb::CodedOutputStream.ComputeMessageSize(7, BroadcastAddress); + } + if (HasBroadcastName) { + size += pb::CodedOutputStream.ComputeBytesSize(8, BroadcastName); + } + if (HasUpdatePeriod) { + size += pb::CodedOutputStream.ComputeSFixed64Size(9, UpdatePeriod); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Subscribe ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Subscribe ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Subscribe ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Subscribe ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Subscribe ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Subscribe ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Subscribe ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static Subscribe ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static Subscribe ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Subscribe 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(Subscribe prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Subscribe result = new Subscribe(); + + protected override Subscribe MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Subscribe(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscribe.Descriptor; } + } + + public override Subscribe DefaultInstanceForType { + get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscribe.DefaultInstance; } + } + + public override Subscribe BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + Subscribe returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Subscribe) { + return MergeFrom((Subscribe) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Subscribe other) { + if (other == global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscribe.DefaultInstance) return this; + if (other.HasBroadcastAddress) { + MergeBroadcastAddress(other.BroadcastAddress); + } + if (other.HasBroadcastName) { + BroadcastName = other.BroadcastName; + } + if (other.HasUpdatePeriod) { + UpdatePeriod = other.UpdatePeriod; + } + 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 58: { + global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.Builder subBuilder = global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.CreateBuilder(); + if (HasBroadcastAddress) { + subBuilder.MergeFrom(BroadcastAddress); + } + input.ReadMessage(subBuilder, extensionRegistry); + BroadcastAddress = subBuilder.BuildPartial(); + break; + } + case 66: { + BroadcastName = input.ReadBytes(); + break; + } + case 73: { + UpdatePeriod = input.ReadSFixed64(); + break; + } + } + } + } + + + public bool HasBroadcastAddress { + get { return result.HasBroadcastAddress; } + } + public global::Sirikata.Subscription.Protocol._PBJ_Internal.Address BroadcastAddress { + get { return result.BroadcastAddress; } + set { SetBroadcastAddress(value); } + } + public Builder SetBroadcastAddress(global::Sirikata.Subscription.Protocol._PBJ_Internal.Address value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasBroadcastAddress = true; + result.broadcastAddress_ = value; + return this; + } + public Builder SetBroadcastAddress(global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasBroadcastAddress = true; + result.broadcastAddress_ = builderForValue.Build(); + return this; + } + public Builder MergeBroadcastAddress(global::Sirikata.Subscription.Protocol._PBJ_Internal.Address value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasBroadcastAddress && + result.broadcastAddress_ != global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.DefaultInstance) { + result.broadcastAddress_ = global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.CreateBuilder(result.broadcastAddress_).MergeFrom(value).BuildPartial(); + } else { + result.broadcastAddress_ = value; + } + result.hasBroadcastAddress = true; + return this; + } + public Builder ClearBroadcastAddress() { + result.hasBroadcastAddress = false; + result.broadcastAddress_ = global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.DefaultInstance; + return this; + } + + public bool HasBroadcastName { + get { return result.HasBroadcastName; } + } + public pb::ByteString BroadcastName { + get { return result.BroadcastName; } + set { SetBroadcastName(value); } + } + public Builder SetBroadcastName(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasBroadcastName = true; + result.broadcastName_ = value; + return this; + } + public Builder ClearBroadcastName() { + result.hasBroadcastName = false; + result.broadcastName_ = pb::ByteString.Empty; + return this; + } + + public bool HasUpdatePeriod { + get { return result.HasUpdatePeriod; } + } + public long UpdatePeriod { + get { return result.UpdatePeriod; } + set { SetUpdatePeriod(value); } + } + public Builder SetUpdatePeriod(long value) { + result.hasUpdatePeriod = true; + result.updatePeriod_ = value; + return this; + } + public Builder ClearUpdatePeriod() { + result.hasUpdatePeriod = false; + result.updatePeriod_ = 0; + return this; + } + } + static Subscribe() { + object.ReferenceEquals(global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.Descriptor, null); + } + } + + public sealed partial class Broadcast : pb::GeneratedMessage { + private static readonly Broadcast defaultInstance = new Builder().BuildPartial(); + public static Broadcast DefaultInstance { + get { return defaultInstance; } + } + + public override Broadcast DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Broadcast ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__FieldAccessorTable; } + } + + public const int BroadcastNameFieldNumber = 7; + private bool hasBroadcastName; + private pb::ByteString broadcastName_ = pb::ByteString.Empty; + public bool HasBroadcastName { + get { return hasBroadcastName; } + } + public pb::ByteString BroadcastName { + get { return broadcastName_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasBroadcastName) { + output.WriteBytes(7, BroadcastName); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasBroadcastName) { + size += pb::CodedOutputStream.ComputeBytesSize(7, BroadcastName); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Broadcast ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Broadcast ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Broadcast ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Broadcast ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Broadcast ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Broadcast ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Broadcast ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static Broadcast ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static Broadcast ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Broadcast 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(Broadcast prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Broadcast result = new Broadcast(); + + protected override Broadcast MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Broadcast(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Broadcast.Descriptor; } + } + + public override Broadcast DefaultInstanceForType { + get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Broadcast.DefaultInstance; } + } + + public override Broadcast BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + Broadcast returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Broadcast) { + return MergeFrom((Broadcast) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Broadcast other) { + if (other == global::Sirikata.Subscription.Protocol._PBJ_Internal.Broadcast.DefaultInstance) return this; + if (other.HasBroadcastName) { + BroadcastName = other.BroadcastName; + } + 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 58: { + BroadcastName = input.ReadBytes(); + break; + } + } + } + } + + + public bool HasBroadcastName { + get { return result.HasBroadcastName; } + } + public pb::ByteString BroadcastName { + get { return result.BroadcastName; } + set { SetBroadcastName(value); } + } + public Builder SetBroadcastName(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasBroadcastName = true; + result.broadcastName_ = value; + return this; + } + public Builder ClearBroadcastName() { + result.hasBroadcastName = false; + result.broadcastName_ = pb::ByteString.Empty; + return this; + } + } + static Broadcast() { + object.ReferenceEquals(global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.Descriptor, null); + } + } + + #endregion + +} diff --git a/OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs new file mode 100644 index 0000000..ca6c7e8 --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs @@ -0,0 +1,404 @@ +using pbd = global::Google.ProtocolBuffers.Descriptors; +using pb = global::Google.ProtocolBuffers; +namespace Sirikata.Subscription.Protocol { + public class Address : PBJ.IMessage { + protected _PBJ_Internal.Address super; + public _PBJ_Internal.Address _PBJSuper{ get { return super;} } + public Address() { + super=new _PBJ_Internal.Address(); + } + public Address(_PBJ_Internal.Address reference) { + super=reference; + } + public static Address defaultInstance= new Address (_PBJ_Internal.Address.DefaultInstance); + public static Address DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.Address.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int HostnameFieldTag=1; + public bool HasHostname{ get {return super.HasHostname&&PBJ._PBJ.ValidateString(super.Hostname);} } + public string Hostname{ get { + if (HasHostname) { + return PBJ._PBJ.CastString(super.Hostname); + } else { + return PBJ._PBJ.CastString(); + } + } + } + public const int ServiceFieldTag=2; + public bool HasService{ get {return super.HasService&&PBJ._PBJ.ValidateString(super.Service);} } + public string Service{ get { + if (HasService) { + return PBJ._PBJ.CastString(super.Service); + } else { + return PBJ._PBJ.CastString(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(Address prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static Address ParseFrom(pb::ByteString data) { + return new Address(_PBJ_Internal.Address.ParseFrom(data)); + } + public static Address ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new Address(_PBJ_Internal.Address.ParseFrom(data,er)); + } + public static Address ParseFrom(byte[] data) { + return new Address(_PBJ_Internal.Address.ParseFrom(data)); + } + public static Address ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new Address(_PBJ_Internal.Address.ParseFrom(data,er)); + } + public static Address ParseFrom(global::System.IO.Stream data) { + return new Address(_PBJ_Internal.Address.ParseFrom(data)); + } + public static Address ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new Address(_PBJ_Internal.Address.ParseFrom(data,er)); + } + public static Address ParseFrom(pb::CodedInputStream data) { + return new Address(_PBJ_Internal.Address.ParseFrom(data)); + } + public static Address ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new Address(_PBJ_Internal.Address.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.Address.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.Address.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.Address.Builder();} + public Builder(_PBJ_Internal.Address.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(Address prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public Address BuildPartial() {return new Address(super.BuildPartial());} + public Address Build() {if (_HasAllPBJFields) return new Address(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return Address.Descriptor; } } + public Builder ClearHostname() { super.ClearHostname();return this;} + public const int HostnameFieldTag=1; + public bool HasHostname{ get {return super.HasHostname&&PBJ._PBJ.ValidateString(super.Hostname);} } + public string Hostname{ get { + if (HasHostname) { + return PBJ._PBJ.CastString(super.Hostname); + } else { + return PBJ._PBJ.CastString(); + } + } + set { + super.Hostname=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearService() { super.ClearService();return this;} + public const int ServiceFieldTag=2; + public bool HasService{ get {return super.HasService&&PBJ._PBJ.ValidateString(super.Service);} } + public string Service{ get { + if (HasService) { + return PBJ._PBJ.CastString(super.Service); + } else { + return PBJ._PBJ.CastString(); + } + } + set { + super.Service=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Subscription.Protocol { + public class Subscribe : PBJ.IMessage { + protected _PBJ_Internal.Subscribe super; + public _PBJ_Internal.Subscribe _PBJSuper{ get { return super;} } + public Subscribe() { + super=new _PBJ_Internal.Subscribe(); + } + public Subscribe(_PBJ_Internal.Subscribe reference) { + super=reference; + } + public static Subscribe defaultInstance= new Subscribe (_PBJ_Internal.Subscribe.DefaultInstance); + public static Subscribe DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.Subscribe.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=6)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int BroadcastAddressFieldTag=7; + public bool HasBroadcastAddress{ get {return super.HasBroadcastAddress;} } + public Address BroadcastAddress{ get { + if (HasBroadcastAddress) { + return new Address(super.BroadcastAddress); + } else { + return new Address(); + } + } + } + public const int BroadcastNameFieldTag=8; + public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} } + public PBJ.UUID BroadcastName{ get { + if (HasBroadcastName) { + return PBJ._PBJ.CastUuid(super.BroadcastName); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int UpdatePeriodFieldTag=9; + public bool HasUpdatePeriod{ get {return super.HasUpdatePeriod&&PBJ._PBJ.ValidateDuration(super.UpdatePeriod);} } + public PBJ.Duration UpdatePeriod{ get { + if (HasUpdatePeriod) { + return PBJ._PBJ.CastDuration(super.UpdatePeriod); + } else { + return PBJ._PBJ.CastDuration(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(Subscribe prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static Subscribe ParseFrom(pb::ByteString data) { + return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data)); + } + public static Subscribe ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er)); + } + public static Subscribe ParseFrom(byte[] data) { + return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data)); + } + public static Subscribe ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er)); + } + public static Subscribe ParseFrom(global::System.IO.Stream data) { + return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data)); + } + public static Subscribe ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er)); + } + public static Subscribe ParseFrom(pb::CodedInputStream data) { + return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data)); + } + public static Subscribe ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.Subscribe.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.Subscribe.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.Subscribe.Builder();} + public Builder(_PBJ_Internal.Subscribe.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(Subscribe prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public Subscribe BuildPartial() {return new Subscribe(super.BuildPartial());} + public Subscribe Build() {if (_HasAllPBJFields) return new Subscribe(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return Subscribe.Descriptor; } } + public Builder ClearBroadcastAddress() { super.ClearBroadcastAddress();return this;} + public const int BroadcastAddressFieldTag=7; + public bool HasBroadcastAddress{ get {return super.HasBroadcastAddress;} } + public Address BroadcastAddress{ get { + if (HasBroadcastAddress) { + return new Address(super.BroadcastAddress); + } else { + return new Address(); + } + } + set { + super.BroadcastAddress=value._PBJSuper; + } + } + public Builder ClearBroadcastName() { super.ClearBroadcastName();return this;} + public const int BroadcastNameFieldTag=8; + public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} } + public PBJ.UUID BroadcastName{ get { + if (HasBroadcastName) { + return PBJ._PBJ.CastUuid(super.BroadcastName); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.BroadcastName=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearUpdatePeriod() { super.ClearUpdatePeriod();return this;} + public const int UpdatePeriodFieldTag=9; + public bool HasUpdatePeriod{ get {return super.HasUpdatePeriod&&PBJ._PBJ.ValidateDuration(super.UpdatePeriod);} } + public PBJ.Duration UpdatePeriod{ get { + if (HasUpdatePeriod) { + return PBJ._PBJ.CastDuration(super.UpdatePeriod); + } else { + return PBJ._PBJ.CastDuration(); + } + } + set { + super.UpdatePeriod=(PBJ._PBJ.Construct(value)); + } + } + } + } +} +namespace Sirikata.Subscription.Protocol { + public class Broadcast : PBJ.IMessage { + protected _PBJ_Internal.Broadcast super; + public _PBJ_Internal.Broadcast _PBJSuper{ get { return super;} } + public Broadcast() { + super=new _PBJ_Internal.Broadcast(); + } + public Broadcast(_PBJ_Internal.Broadcast reference) { + super=reference; + } + public static Broadcast defaultInstance= new Broadcast (_PBJ_Internal.Broadcast.DefaultInstance); + public static Broadcast DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.Broadcast.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=6)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int BroadcastNameFieldTag=7; + public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} } + public PBJ.UUID BroadcastName{ get { + if (HasBroadcastName) { + return PBJ._PBJ.CastUuid(super.BroadcastName); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(Broadcast prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static Broadcast ParseFrom(pb::ByteString data) { + return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data)); + } + public static Broadcast ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er)); + } + public static Broadcast ParseFrom(byte[] data) { + return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data)); + } + public static Broadcast ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er)); + } + public static Broadcast ParseFrom(global::System.IO.Stream data) { + return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data)); + } + public static Broadcast ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er)); + } + public static Broadcast ParseFrom(pb::CodedInputStream data) { + return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data)); + } + public static Broadcast ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.Broadcast.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.Broadcast.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.Broadcast.Builder();} + public Builder(_PBJ_Internal.Broadcast.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(Broadcast prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public Broadcast BuildPartial() {return new Broadcast(super.BuildPartial());} + public Broadcast Build() {if (_HasAllPBJFields) return new Broadcast(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return Broadcast.Descriptor; } } + public Builder ClearBroadcastName() { super.ClearBroadcastName();return this;} + public const int BroadcastNameFieldTag=7; + public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} } + public PBJ.UUID BroadcastName{ get { + if (HasBroadcastName) { + return PBJ._PBJ.CastUuid(super.BroadcastName); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.BroadcastName=(PBJ._PBJ.Construct(value)); + } + } + } + } +} diff --git a/OpenSim/Client/Sirikata/Protocol/Test.cs b/OpenSim/Client/Sirikata/Protocol/Test.cs new file mode 100644 index 0000000..0e1372a --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Test.cs @@ -0,0 +1,3773 @@ +// 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.PB._PBJ_Internal { + + public static partial class Test { + + #region Extension registration + public static void RegisterAllExtensions(pb::ExtensionRegistry registry) { + registry.Add(global::Sirikata.PB._PBJ_Internal.Test.Extensionbbox); + registry.Add(global::Sirikata.PB._PBJ_Internal.Test.Extensionvector); + } + #endregion + #region Extensions + public const int ExtensionbboxFieldNumber = 100; + public static pb::GeneratedExtensionBase> Extensionbbox; + public const int ExtensionvectorFieldNumber = 101; + public static pb::GeneratedExtensionBase> Extensionvector; + #endregion + + #region Static variables + internal static pbd::MessageDescriptor internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_PB__PBJ_Internal_TestMessage__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__FieldAccessorTable; + #endregion + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbd::FileDescriptor descriptor; + + static Test() { + byte[] descriptorData = global::System.Convert.FromBase64String( + "CgpUZXN0LnByb3RvEhlTaXJpa2F0YS5QQi5fUEJKX0ludGVybmFsIuwCCg9F" + + "eHRlcm5hbE1lc3NhZ2USFQoHaXNfdHJ1ZRgoIAEoCDoEdHJ1ZRIPCgN2MmYY" + + "AiADKAJCAhABEkYKB3N1Yl9tZXMYHiABKAsyNS5TaXJpa2F0YS5QQi5fUEJK" + + "X0ludGVybmFsLkV4dGVybmFsTWVzc2FnZS5TdWJNZXNzYWdlEkkKCnN1Ym1l" + + "c3NlcnMYHyADKAsyNS5TaXJpa2F0YS5QQi5fUEJKX0ludGVybmFsLkV4dGVy" + + "bmFsTWVzc2FnZS5TdWJNZXNzYWdlEgsKA3NoYRggIAEoDBIMCgRzaGFzGCEg" + + "AygMEg8KA3YzZhgEIAMoAkICEAESEAoEdjNmZhgFIAMoAkICEAEaYAoKU3Vi" + + "TWVzc2FnZRIPCgdzdWJ1dWlkGAEgASgMEhUKCXN1YnZlY3RvchgCIAMoAUIC" + + "EAESEwoLc3ViZHVyYXRpb24YAyABKBASFQoJc3Vibm9ybWFsGAQgAygCQgIQ" + + "ASLmCAoLVGVzdE1lc3NhZ2USEQoDeHhkGBQgASgBOgQxMC4zEgsKA3h4ZhgV" + + "IAEoAhINCgV4eHUzMhgWIAEoDRILCgN4eHMYFyABKAkSCwoDeHhiGBggASgM" + + "EgwKBHh4c3MYGSADKAkSDAoEeHhiYhgaIAMoDBIQCgR4eGZmGBsgAygCQgIQ" + + "ARIQCgR4eG5uGB0gAygCQgIQARIMCgR4eGZyGBwgAigCEg0KAW4YASADKAJC" + + "AhABEg8KA3YyZhgCIAMoAkICEAESDwoDdjJkGAMgAygBQgIQARIPCgN2M2YY" + + "BCADKAJCAhABEg8KA3YzZBgFIAMoAUICEAESDwoDdjRmGAYgAygCQgIQARIP" + + "CgN2NGQYByADKAFCAhABEg0KAXEYCCADKAJCAhABEgkKAXUYCSABKAwSCQoB" + + "YRgKIAEoAhIJCgF0GAsgASgGEgkKAWQYDCABKBASCwoDZjMyGA0gASgNEgsK" + + "A2Y2NBgOIAEoBBIPCgNic2YYDyADKAJCAhABEg8KA2JzZBgQIAMoAUICEAES" + + "DwoDYmJmGBEgAygCQgIQARIPCgNiYmQYEiADKAFCAhABEjoKA2UzMhgTIAEo" + + "DjItLlNpcmlrYXRhLlBCLl9QQkpfSW50ZXJuYWwuVGVzdE1lc3NhZ2UuRW51" + + "bTMyEkEKBnN1Ym1lcxgeIAEoCzIxLlNpcmlrYXRhLlBCLl9QQkpfSW50ZXJu" + + "YWwuVGVzdE1lc3NhZ2UuU3ViTWVzc2FnZRJFCgpzdWJtZXNzZXJzGB8gAygL" + + "MjEuU2lyaWthdGEuUEIuX1BCSl9JbnRlcm5hbC5UZXN0TWVzc2FnZS5TdWJN" + + "ZXNzYWdlEgsKA3NoYRggIAEoDBIMCgRzaGFzGCEgAygMEjoKBmV4dG1lcxgi" + + "IAEoCzIqLlNpcmlrYXRhLlBCLl9QQkpfSW50ZXJuYWwuRXh0ZXJuYWxNZXNz" + + "YWdlEj4KCmV4dG1lc3NlcnMYIyADKAsyKi5TaXJpa2F0YS5QQi5fUEJKX0lu" + + "dGVybmFsLkV4dGVybmFsTWVzc2FnZRI9CglleHRtZXNzZXIYJCACKAsyKi5T" + + "aXJpa2F0YS5QQi5fUEJKX0ludGVybmFsLkV4dGVybmFsTWVzc2FnZRpgCgpT" + + "dWJNZXNzYWdlEg8KB3N1YnV1aWQYASABKAwSFQoJc3VidmVjdG9yGAIgAygB" + + "QgIQARITCgtzdWJkdXJhdGlvbhgDIAEoEBIVCglzdWJub3JtYWwYBCADKAJC" + + "AhABIjUKCEZsYWdzZjMyEgwKCFVOSVZFUlNBEAASBgoCV0UQARIJCgVJTUFH" + + "RRACEggKBExPQ0EQAyI5CghGbGFnc2Y2NBINCglVTklWRVJTQUwQABIHCgNX" + + "RUIQARIKCgZJTUFHRVMQAhIJCgVMT0NBTBADIjsKBkVudW0zMhIOCgpVTklW" + + "RVJTQUwxEAASCAoEV0VCMRABEgsKB0lNQUdFUzEQAhIKCgZMT0NBTDEQAyoF" + + "CGQQyAE6QQoNZXh0ZW5zaW9uYmJveBImLlNpcmlrYXRhLlBCLl9QQkpfSW50" + + "ZXJuYWwuVGVzdE1lc3NhZ2UYZCADKAJCAhABOkMKD2V4dGVuc2lvbnZlY3Rv" + + "chImLlNpcmlrYXRhLlBCLl9QQkpfSW50ZXJuYWwuVGVzdE1lc3NhZ2UYZSAD" + + "KAJCAhAB"); + pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { + descriptor = root; + internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor = Descriptor.MessageTypes[0]; + internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor, + new string[] { "IsTrue", "V2F", "SubMes", "Submessers", "Sha", "Shas", "V3F", "V3Ff", }); + internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__Descriptor = internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor.NestedTypes[0]; + internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__Descriptor, + new string[] { "Subuuid", "Subvector", "Subduration", "Subnormal", }); + internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor = Descriptor.MessageTypes[1]; + internal__static_Sirikata_PB__PBJ_Internal_TestMessage__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor, + new string[] { "Xxd", "Xxf", "Xxu32", "Xxs", "Xxb", "Xxss", "Xxbb", "Xxff", "Xxnn", "Xxfr", "N", "V2F", "V2D", "V3F", "V3D", "V4F", "V4D", "Q", "U", "A", "T", "D", "F32", "F64", "Bsf", "Bsd", "Bbf", "Bbd", "E32", "Submes", "Submessers", "Sha", "Shas", "Extmes", "Extmessers", "Extmesser", }); + internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__Descriptor = internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor.NestedTypes[0]; + internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__Descriptor, + new string[] { "Subuuid", "Subvector", "Subduration", "Subnormal", }); + global::Sirikata.PB._PBJ_Internal.Test.Extensionbbox = pb::GeneratedRepeatExtension.CreateInstance(global::Sirikata.PB._PBJ_Internal.Test.Descriptor.Extensions[0]); + global::Sirikata.PB._PBJ_Internal.Test.Extensionvector = pb::GeneratedRepeatExtension.CreateInstance(global::Sirikata.PB._PBJ_Internal.Test.Descriptor.Extensions[1]); + return null; + }; + pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, + new pbd::FileDescriptor[] { + }, assigner); + } + #endregion + + } + #region Messages + public sealed partial class ExternalMessage : pb::GeneratedMessage { + private static readonly ExternalMessage defaultInstance = new Builder().BuildPartial(); + public static ExternalMessage DefaultInstance { + get { return defaultInstance; } + } + + public override ExternalMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ExternalMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class SubMessage : pb::GeneratedMessage { + private static readonly SubMessage defaultInstance = new Builder().BuildPartial(); + public static SubMessage DefaultInstance { + get { return defaultInstance; } + } + + public override SubMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override SubMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__FieldAccessorTable; } + } + + public const int SubuuidFieldNumber = 1; + private bool hasSubuuid; + private pb::ByteString subuuid_ = pb::ByteString.Empty; + public bool HasSubuuid { + get { return hasSubuuid; } + } + public pb::ByteString Subuuid { + get { return subuuid_; } + } + + public const int SubvectorFieldNumber = 2; + private int subvectorMemoizedSerializedSize; + private pbc::PopsicleList subvector_ = new pbc::PopsicleList(); + public scg::IList SubvectorList { + get { return pbc::Lists.AsReadOnly(subvector_); } + } + public int SubvectorCount { + get { return subvector_.Count; } + } + public double GetSubvector(int index) { + return subvector_[index]; + } + + public const int SubdurationFieldNumber = 3; + private bool hasSubduration; + private long subduration_ = 0; + public bool HasSubduration { + get { return hasSubduration; } + } + public long Subduration { + get { return subduration_; } + } + + public const int SubnormalFieldNumber = 4; + private int subnormalMemoizedSerializedSize; + private pbc::PopsicleList subnormal_ = new pbc::PopsicleList(); + public scg::IList SubnormalList { + get { return pbc::Lists.AsReadOnly(subnormal_); } + } + public int SubnormalCount { + get { return subnormal_.Count; } + } + public float GetSubnormal(int index) { + return subnormal_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasSubuuid) { + output.WriteBytes(1, Subuuid); + } + if (subvector_.Count > 0) { + output.WriteRawVarint32(18); + output.WriteRawVarint32((uint) subvectorMemoizedSerializedSize); + foreach (double element in subvector_) { + output.WriteDoubleNoTag(element); + } + } + if (HasSubduration) { + output.WriteSFixed64(3, Subduration); + } + if (subnormal_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) subnormalMemoizedSerializedSize); + foreach (float element in subnormal_) { + output.WriteFloatNoTag(element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasSubuuid) { + size += pb::CodedOutputStream.ComputeBytesSize(1, Subuuid); + } + { + int dataSize = 0; + dataSize = 8 * subvector_.Count; + size += dataSize; + if (subvector_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + subvectorMemoizedSerializedSize = dataSize; + } + if (HasSubduration) { + size += pb::CodedOutputStream.ComputeSFixed64Size(3, Subduration); + } + { + int dataSize = 0; + dataSize = 4 * subnormal_.Count; + size += dataSize; + if (subnormal_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + subnormalMemoizedSerializedSize = dataSize; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static SubMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SubMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SubMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SubMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SubMessage ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static SubMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static SubMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SubMessage 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(SubMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + SubMessage result = new SubMessage(); + + protected override SubMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new SubMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Descriptor; } + } + + public override SubMessage DefaultInstanceForType { + get { return global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance; } + } + + public override SubMessage BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.subvector_.MakeReadOnly(); + result.subnormal_.MakeReadOnly(); + SubMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is SubMessage) { + return MergeFrom((SubMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(SubMessage other) { + if (other == global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance) return this; + if (other.HasSubuuid) { + Subuuid = other.Subuuid; + } + if (other.subvector_.Count != 0) { + base.AddRange(other.subvector_, result.subvector_); + } + if (other.HasSubduration) { + Subduration = other.Subduration; + } + if (other.subnormal_.Count != 0) { + base.AddRange(other.subnormal_, result.subnormal_); + } + 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: { + Subuuid = input.ReadBytes(); + break; + } + case 18: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddSubvector(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 25: { + Subduration = input.ReadSFixed64(); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddSubnormal(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + } + } + } + + + public bool HasSubuuid { + get { return result.HasSubuuid; } + } + public pb::ByteString Subuuid { + get { return result.Subuuid; } + set { SetSubuuid(value); } + } + public Builder SetSubuuid(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasSubuuid = true; + result.subuuid_ = value; + return this; + } + public Builder ClearSubuuid() { + result.hasSubuuid = false; + result.subuuid_ = pb::ByteString.Empty; + return this; + } + + public pbc::IPopsicleList SubvectorList { + get { return result.subvector_; } + } + public int SubvectorCount { + get { return result.SubvectorCount; } + } + public double GetSubvector(int index) { + return result.GetSubvector(index); + } + public Builder SetSubvector(int index, double value) { + result.subvector_[index] = value; + return this; + } + public Builder AddSubvector(double value) { + result.subvector_.Add(value); + return this; + } + public Builder AddRangeSubvector(scg::IEnumerable values) { + base.AddRange(values, result.subvector_); + return this; + } + public Builder ClearSubvector() { + result.subvector_.Clear(); + return this; + } + + public bool HasSubduration { + get { return result.HasSubduration; } + } + public long Subduration { + get { return result.Subduration; } + set { SetSubduration(value); } + } + public Builder SetSubduration(long value) { + result.hasSubduration = true; + result.subduration_ = value; + return this; + } + public Builder ClearSubduration() { + result.hasSubduration = false; + result.subduration_ = 0; + return this; + } + + public pbc::IPopsicleList SubnormalList { + get { return result.subnormal_; } + } + public int SubnormalCount { + get { return result.SubnormalCount; } + } + public float GetSubnormal(int index) { + return result.GetSubnormal(index); + } + public Builder SetSubnormal(int index, float value) { + result.subnormal_[index] = value; + return this; + } + public Builder AddSubnormal(float value) { + result.subnormal_.Add(value); + return this; + } + public Builder AddRangeSubnormal(scg::IEnumerable values) { + base.AddRange(values, result.subnormal_); + return this; + } + public Builder ClearSubnormal() { + result.subnormal_.Clear(); + return this; + } + } + static SubMessage() { + object.ReferenceEquals(global::Sirikata.PB._PBJ_Internal.Test.Descriptor, null); + } + } + + } + #endregion + + public const int IsTrueFieldNumber = 40; + private bool hasIsTrue; + private bool isTrue_ = true; + public bool HasIsTrue { + get { return hasIsTrue; } + } + public bool IsTrue { + get { return isTrue_; } + } + + public const int V2FFieldNumber = 2; + private int v2FMemoizedSerializedSize; + private pbc::PopsicleList v2F_ = new pbc::PopsicleList(); + public scg::IList V2FList { + get { return pbc::Lists.AsReadOnly(v2F_); } + } + public int V2FCount { + get { return v2F_.Count; } + } + public float GetV2F(int index) { + return v2F_[index]; + } + + public const int SubMesFieldNumber = 30; + private bool hasSubMes; + private global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage subMes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance; + public bool HasSubMes { + get { return hasSubMes; } + } + public global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage SubMes { + get { return subMes_; } + } + + public const int SubmessersFieldNumber = 31; + private pbc::PopsicleList submessers_ = new pbc::PopsicleList(); + public scg::IList SubmessersList { + get { return submessers_; } + } + public int SubmessersCount { + get { return submessers_.Count; } + } + public global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage GetSubmessers(int index) { + return submessers_[index]; + } + + public const int ShaFieldNumber = 32; + private bool hasSha; + private pb::ByteString sha_ = pb::ByteString.Empty; + public bool HasSha { + get { return hasSha; } + } + public pb::ByteString Sha { + get { return sha_; } + } + + public const int ShasFieldNumber = 33; + private pbc::PopsicleList shas_ = new pbc::PopsicleList(); + public scg::IList ShasList { + get { return pbc::Lists.AsReadOnly(shas_); } + } + public int ShasCount { + get { return shas_.Count; } + } + public pb::ByteString GetShas(int index) { + return shas_[index]; + } + + public const int V3FFieldNumber = 4; + private int v3FMemoizedSerializedSize; + private pbc::PopsicleList v3F_ = new pbc::PopsicleList(); + public scg::IList V3FList { + get { return pbc::Lists.AsReadOnly(v3F_); } + } + public int V3FCount { + get { return v3F_.Count; } + } + public float GetV3F(int index) { + return v3F_[index]; + } + + public const int V3FfFieldNumber = 5; + private int v3FfMemoizedSerializedSize; + private pbc::PopsicleList v3Ff_ = new pbc::PopsicleList(); + public scg::IList V3FfList { + get { return pbc::Lists.AsReadOnly(v3Ff_); } + } + public int V3FfCount { + get { return v3Ff_.Count; } + } + public float GetV3Ff(int index) { + return v3Ff_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (v2F_.Count > 0) { + output.WriteRawVarint32(18); + output.WriteRawVarint32((uint) v2FMemoizedSerializedSize); + foreach (float element in v2F_) { + output.WriteFloatNoTag(element); + } + } + if (v3F_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) v3FMemoizedSerializedSize); + foreach (float element in v3F_) { + output.WriteFloatNoTag(element); + } + } + if (v3Ff_.Count > 0) { + output.WriteRawVarint32(42); + output.WriteRawVarint32((uint) v3FfMemoizedSerializedSize); + foreach (float element in v3Ff_) { + output.WriteFloatNoTag(element); + } + } + if (HasSubMes) { + output.WriteMessage(30, SubMes); + } + foreach (global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage element in SubmessersList) { + output.WriteMessage(31, element); + } + if (HasSha) { + output.WriteBytes(32, Sha); + } + if (shas_.Count > 0) { + foreach (pb::ByteString element in shas_) { + output.WriteBytes(33, element); + } + } + if (HasIsTrue) { + output.WriteBool(40, IsTrue); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasIsTrue) { + size += pb::CodedOutputStream.ComputeBoolSize(40, IsTrue); + } + { + int dataSize = 0; + dataSize = 4 * v2F_.Count; + size += dataSize; + if (v2F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + v2FMemoizedSerializedSize = dataSize; + } + if (HasSubMes) { + size += pb::CodedOutputStream.ComputeMessageSize(30, SubMes); + } + foreach (global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage element in SubmessersList) { + size += pb::CodedOutputStream.ComputeMessageSize(31, element); + } + if (HasSha) { + size += pb::CodedOutputStream.ComputeBytesSize(32, Sha); + } + { + int dataSize = 0; + foreach (pb::ByteString element in ShasList) { + dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); + } + size += dataSize; + size += 2 * shas_.Count; + } + { + int dataSize = 0; + dataSize = 4 * v3F_.Count; + size += dataSize; + if (v3F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + v3FMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * v3Ff_.Count; + size += dataSize; + if (v3Ff_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + v3FfMemoizedSerializedSize = dataSize; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ExternalMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ExternalMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ExternalMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ExternalMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ExternalMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ExternalMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ExternalMessage ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ExternalMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ExternalMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ExternalMessage 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(ExternalMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ExternalMessage result = new ExternalMessage(); + + protected override ExternalMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ExternalMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.PB._PBJ_Internal.ExternalMessage.Descriptor; } + } + + public override ExternalMessage DefaultInstanceForType { + get { return global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance; } + } + + public override ExternalMessage BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.v2F_.MakeReadOnly(); + result.submessers_.MakeReadOnly(); + result.shas_.MakeReadOnly(); + result.v3F_.MakeReadOnly(); + result.v3Ff_.MakeReadOnly(); + ExternalMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ExternalMessage) { + return MergeFrom((ExternalMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ExternalMessage other) { + if (other == global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance) return this; + if (other.HasIsTrue) { + IsTrue = other.IsTrue; + } + if (other.v2F_.Count != 0) { + base.AddRange(other.v2F_, result.v2F_); + } + if (other.HasSubMes) { + MergeSubMes(other.SubMes); + } + if (other.submessers_.Count != 0) { + base.AddRange(other.submessers_, result.submessers_); + } + if (other.HasSha) { + Sha = other.Sha; + } + if (other.shas_.Count != 0) { + base.AddRange(other.shas_, result.shas_); + } + if (other.v3F_.Count != 0) { + base.AddRange(other.v3F_, result.v3F_); + } + if (other.v3Ff_.Count != 0) { + base.AddRange(other.v3Ff_, result.v3Ff_); + } + 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 18: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddV2F(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddV3F(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 42: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddV3Ff(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 242: { + global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.CreateBuilder(); + if (HasSubMes) { + subBuilder.MergeFrom(SubMes); + } + input.ReadMessage(subBuilder, extensionRegistry); + SubMes = subBuilder.BuildPartial(); + break; + } + case 250: { + global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddSubmessers(subBuilder.BuildPartial()); + break; + } + case 258: { + Sha = input.ReadBytes(); + break; + } + case 266: { + AddShas(input.ReadBytes()); + break; + } + case 320: { + IsTrue = input.ReadBool(); + break; + } + } + } + } + + + public bool HasIsTrue { + get { return result.HasIsTrue; } + } + public bool IsTrue { + get { return result.IsTrue; } + set { SetIsTrue(value); } + } + public Builder SetIsTrue(bool value) { + result.hasIsTrue = true; + result.isTrue_ = value; + return this; + } + public Builder ClearIsTrue() { + result.hasIsTrue = false; + result.isTrue_ = true; + return this; + } + + public pbc::IPopsicleList V2FList { + get { return result.v2F_; } + } + public int V2FCount { + get { return result.V2FCount; } + } + public float GetV2F(int index) { + return result.GetV2F(index); + } + public Builder SetV2F(int index, float value) { + result.v2F_[index] = value; + return this; + } + public Builder AddV2F(float value) { + result.v2F_.Add(value); + return this; + } + public Builder AddRangeV2F(scg::IEnumerable values) { + base.AddRange(values, result.v2F_); + return this; + } + public Builder ClearV2F() { + result.v2F_.Clear(); + return this; + } + + public bool HasSubMes { + get { return result.HasSubMes; } + } + public global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage SubMes { + get { return result.SubMes; } + set { SetSubMes(value); } + } + public Builder SetSubMes(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasSubMes = true; + result.subMes_ = value; + return this; + } + public Builder SetSubMes(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasSubMes = true; + result.subMes_ = builderForValue.Build(); + return this; + } + public Builder MergeSubMes(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasSubMes && + result.subMes_ != global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance) { + result.subMes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.CreateBuilder(result.subMes_).MergeFrom(value).BuildPartial(); + } else { + result.subMes_ = value; + } + result.hasSubMes = true; + return this; + } + public Builder ClearSubMes() { + result.hasSubMes = false; + result.subMes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance; + return this; + } + + public pbc::IPopsicleList SubmessersList { + get { return result.submessers_; } + } + public int SubmessersCount { + get { return result.SubmessersCount; } + } + public global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage GetSubmessers(int index) { + return result.GetSubmessers(index); + } + public Builder SetSubmessers(int index, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.submessers_[index] = value; + return this; + } + public Builder SetSubmessers(int index, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.submessers_[index] = builderForValue.Build(); + return this; + } + public Builder AddSubmessers(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.submessers_.Add(value); + return this; + } + public Builder AddSubmessers(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.submessers_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeSubmessers(scg::IEnumerable values) { + base.AddRange(values, result.submessers_); + return this; + } + public Builder ClearSubmessers() { + result.submessers_.Clear(); + return this; + } + + public bool HasSha { + get { return result.HasSha; } + } + public pb::ByteString Sha { + get { return result.Sha; } + set { SetSha(value); } + } + public Builder SetSha(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasSha = true; + result.sha_ = value; + return this; + } + public Builder ClearSha() { + result.hasSha = false; + result.sha_ = pb::ByteString.Empty; + return this; + } + + public pbc::IPopsicleList ShasList { + get { return result.shas_; } + } + public int ShasCount { + get { return result.ShasCount; } + } + public pb::ByteString GetShas(int index) { + return result.GetShas(index); + } + public Builder SetShas(int index, pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.shas_[index] = value; + return this; + } + public Builder AddShas(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.shas_.Add(value); + return this; + } + public Builder AddRangeShas(scg::IEnumerable values) { + base.AddRange(values, result.shas_); + return this; + } + public Builder ClearShas() { + result.shas_.Clear(); + return this; + } + + public pbc::IPopsicleList V3FList { + get { return result.v3F_; } + } + public int V3FCount { + get { return result.V3FCount; } + } + public float GetV3F(int index) { + return result.GetV3F(index); + } + public Builder SetV3F(int index, float value) { + result.v3F_[index] = value; + return this; + } + public Builder AddV3F(float value) { + result.v3F_.Add(value); + return this; + } + public Builder AddRangeV3F(scg::IEnumerable values) { + base.AddRange(values, result.v3F_); + return this; + } + public Builder ClearV3F() { + result.v3F_.Clear(); + return this; + } + + public pbc::IPopsicleList V3FfList { + get { return result.v3Ff_; } + } + public int V3FfCount { + get { return result.V3FfCount; } + } + public float GetV3Ff(int index) { + return result.GetV3Ff(index); + } + public Builder SetV3Ff(int index, float value) { + result.v3Ff_[index] = value; + return this; + } + public Builder AddV3Ff(float value) { + result.v3Ff_.Add(value); + return this; + } + public Builder AddRangeV3Ff(scg::IEnumerable values) { + base.AddRange(values, result.v3Ff_); + return this; + } + public Builder ClearV3Ff() { + result.v3Ff_.Clear(); + return this; + } + } + static ExternalMessage() { + object.ReferenceEquals(global::Sirikata.PB._PBJ_Internal.Test.Descriptor, null); + } + } + + public sealed partial class TestMessage : pb::ExtendableMessage { + private static readonly TestMessage defaultInstance = new Builder().BuildPartial(); + public static TestMessage DefaultInstance { + get { return defaultInstance; } + } + + public override TestMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_TestMessage__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum Flagsf32 { + UNIVERSA = 0, + WE = 1, + IMAGE = 2, + LOCA = 3, + } + + public enum Flagsf64 { + UNIVERSAL = 0, + WEB = 1, + IMAGES = 2, + LOCAL = 3, + } + + public enum Enum32 { + UNIVERSAL1 = 0, + WEB1 = 1, + IMAGES1 = 2, + LOCAL1 = 3, + } + + public sealed partial class SubMessage : pb::GeneratedMessage { + private static readonly SubMessage defaultInstance = new Builder().BuildPartial(); + public static SubMessage DefaultInstance { + get { return defaultInstance; } + } + + public override SubMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override SubMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__FieldAccessorTable; } + } + + public const int SubuuidFieldNumber = 1; + private bool hasSubuuid; + private pb::ByteString subuuid_ = pb::ByteString.Empty; + public bool HasSubuuid { + get { return hasSubuuid; } + } + public pb::ByteString Subuuid { + get { return subuuid_; } + } + + public const int SubvectorFieldNumber = 2; + private int subvectorMemoizedSerializedSize; + private pbc::PopsicleList subvector_ = new pbc::PopsicleList(); + public scg::IList SubvectorList { + get { return pbc::Lists.AsReadOnly(subvector_); } + } + public int SubvectorCount { + get { return subvector_.Count; } + } + public double GetSubvector(int index) { + return subvector_[index]; + } + + public const int SubdurationFieldNumber = 3; + private bool hasSubduration; + private long subduration_ = 0; + public bool HasSubduration { + get { return hasSubduration; } + } + public long Subduration { + get { return subduration_; } + } + + public const int SubnormalFieldNumber = 4; + private int subnormalMemoizedSerializedSize; + private pbc::PopsicleList subnormal_ = new pbc::PopsicleList(); + public scg::IList SubnormalList { + get { return pbc::Lists.AsReadOnly(subnormal_); } + } + public int SubnormalCount { + get { return subnormal_.Count; } + } + public float GetSubnormal(int index) { + return subnormal_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasSubuuid) { + output.WriteBytes(1, Subuuid); + } + if (subvector_.Count > 0) { + output.WriteRawVarint32(18); + output.WriteRawVarint32((uint) subvectorMemoizedSerializedSize); + foreach (double element in subvector_) { + output.WriteDoubleNoTag(element); + } + } + if (HasSubduration) { + output.WriteSFixed64(3, Subduration); + } + if (subnormal_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) subnormalMemoizedSerializedSize); + foreach (float element in subnormal_) { + output.WriteFloatNoTag(element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasSubuuid) { + size += pb::CodedOutputStream.ComputeBytesSize(1, Subuuid); + } + { + int dataSize = 0; + dataSize = 8 * subvector_.Count; + size += dataSize; + if (subvector_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + subvectorMemoizedSerializedSize = dataSize; + } + if (HasSubduration) { + size += pb::CodedOutputStream.ComputeSFixed64Size(3, Subduration); + } + { + int dataSize = 0; + dataSize = 4 * subnormal_.Count; + size += dataSize; + if (subnormal_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + subnormalMemoizedSerializedSize = dataSize; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static SubMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SubMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SubMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SubMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SubMessage ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static SubMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static SubMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SubMessage 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(SubMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + SubMessage result = new SubMessage(); + + protected override SubMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new SubMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Descriptor; } + } + + public override SubMessage DefaultInstanceForType { + get { return global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance; } + } + + public override SubMessage BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.subvector_.MakeReadOnly(); + result.subnormal_.MakeReadOnly(); + SubMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is SubMessage) { + return MergeFrom((SubMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(SubMessage other) { + if (other == global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance) return this; + if (other.HasSubuuid) { + Subuuid = other.Subuuid; + } + if (other.subvector_.Count != 0) { + base.AddRange(other.subvector_, result.subvector_); + } + if (other.HasSubduration) { + Subduration = other.Subduration; + } + if (other.subnormal_.Count != 0) { + base.AddRange(other.subnormal_, result.subnormal_); + } + 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: { + Subuuid = input.ReadBytes(); + break; + } + case 18: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddSubvector(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 25: { + Subduration = input.ReadSFixed64(); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddSubnormal(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + } + } + } + + + public bool HasSubuuid { + get { return result.HasSubuuid; } + } + public pb::ByteString Subuuid { + get { return result.Subuuid; } + set { SetSubuuid(value); } + } + public Builder SetSubuuid(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasSubuuid = true; + result.subuuid_ = value; + return this; + } + public Builder ClearSubuuid() { + result.hasSubuuid = false; + result.subuuid_ = pb::ByteString.Empty; + return this; + } + + public pbc::IPopsicleList SubvectorList { + get { return result.subvector_; } + } + public int SubvectorCount { + get { return result.SubvectorCount; } + } + public double GetSubvector(int index) { + return result.GetSubvector(index); + } + public Builder SetSubvector(int index, double value) { + result.subvector_[index] = value; + return this; + } + public Builder AddSubvector(double value) { + result.subvector_.Add(value); + return this; + } + public Builder AddRangeSubvector(scg::IEnumerable values) { + base.AddRange(values, result.subvector_); + return this; + } + public Builder ClearSubvector() { + result.subvector_.Clear(); + return this; + } + + public bool HasSubduration { + get { return result.HasSubduration; } + } + public long Subduration { + get { return result.Subduration; } + set { SetSubduration(value); } + } + public Builder SetSubduration(long value) { + result.hasSubduration = true; + result.subduration_ = value; + return this; + } + public Builder ClearSubduration() { + result.hasSubduration = false; + result.subduration_ = 0; + return this; + } + + public pbc::IPopsicleList SubnormalList { + get { return result.subnormal_; } + } + public int SubnormalCount { + get { return result.SubnormalCount; } + } + public float GetSubnormal(int index) { + return result.GetSubnormal(index); + } + public Builder SetSubnormal(int index, float value) { + result.subnormal_[index] = value; + return this; + } + public Builder AddSubnormal(float value) { + result.subnormal_.Add(value); + return this; + } + public Builder AddRangeSubnormal(scg::IEnumerable values) { + base.AddRange(values, result.subnormal_); + return this; + } + public Builder ClearSubnormal() { + result.subnormal_.Clear(); + return this; + } + } + static SubMessage() { + object.ReferenceEquals(global::Sirikata.PB._PBJ_Internal.Test.Descriptor, null); + } + } + + } + #endregion + + public const int XxdFieldNumber = 20; + private bool hasXxd; + private double xxd_ = 10.3D; + public bool HasXxd { + get { return hasXxd; } + } + public double Xxd { + get { return xxd_; } + } + + public const int XxfFieldNumber = 21; + private bool hasXxf; + private float xxf_ = 0F; + public bool HasXxf { + get { return hasXxf; } + } + public float Xxf { + get { return xxf_; } + } + + public const int Xxu32FieldNumber = 22; + private bool hasXxu32; + private uint xxu32_ = 0; + public bool HasXxu32 { + get { return hasXxu32; } + } + [global::System.CLSCompliant(false)] + public uint Xxu32 { + get { return xxu32_; } + } + + public const int XxsFieldNumber = 23; + private bool hasXxs; + private string xxs_ = ""; + public bool HasXxs { + get { return hasXxs; } + } + public string Xxs { + get { return xxs_; } + } + + public const int XxbFieldNumber = 24; + private bool hasXxb; + private pb::ByteString xxb_ = pb::ByteString.Empty; + public bool HasXxb { + get { return hasXxb; } + } + public pb::ByteString Xxb { + get { return xxb_; } + } + + public const int XxssFieldNumber = 25; + private pbc::PopsicleList xxss_ = new pbc::PopsicleList(); + public scg::IList XxssList { + get { return pbc::Lists.AsReadOnly(xxss_); } + } + public int XxssCount { + get { return xxss_.Count; } + } + public string GetXxss(int index) { + return xxss_[index]; + } + + public const int XxbbFieldNumber = 26; + private pbc::PopsicleList xxbb_ = new pbc::PopsicleList(); + public scg::IList XxbbList { + get { return pbc::Lists.AsReadOnly(xxbb_); } + } + public int XxbbCount { + get { return xxbb_.Count; } + } + public pb::ByteString GetXxbb(int index) { + return xxbb_[index]; + } + + public const int XxffFieldNumber = 27; + private int xxffMemoizedSerializedSize; + private pbc::PopsicleList xxff_ = new pbc::PopsicleList(); + public scg::IList XxffList { + get { return pbc::Lists.AsReadOnly(xxff_); } + } + public int XxffCount { + get { return xxff_.Count; } + } + public float GetXxff(int index) { + return xxff_[index]; + } + + public const int XxnnFieldNumber = 29; + private int xxnnMemoizedSerializedSize; + private pbc::PopsicleList xxnn_ = new pbc::PopsicleList(); + public scg::IList XxnnList { + get { return pbc::Lists.AsReadOnly(xxnn_); } + } + public int XxnnCount { + get { return xxnn_.Count; } + } + public float GetXxnn(int index) { + return xxnn_[index]; + } + + public const int XxfrFieldNumber = 28; + private bool hasXxfr; + private float xxfr_ = 0F; + public bool HasXxfr { + get { return hasXxfr; } + } + public float Xxfr { + get { return xxfr_; } + } + + public const int NFieldNumber = 1; + private int nMemoizedSerializedSize; + private pbc::PopsicleList n_ = new pbc::PopsicleList(); + public scg::IList NList { + get { return pbc::Lists.AsReadOnly(n_); } + } + public int NCount { + get { return n_.Count; } + } + public float GetN(int index) { + return n_[index]; + } + + public const int V2FFieldNumber = 2; + private int v2FMemoizedSerializedSize; + private pbc::PopsicleList v2F_ = new pbc::PopsicleList(); + public scg::IList V2FList { + get { return pbc::Lists.AsReadOnly(v2F_); } + } + public int V2FCount { + get { return v2F_.Count; } + } + public float GetV2F(int index) { + return v2F_[index]; + } + + public const int V2DFieldNumber = 3; + private int v2DMemoizedSerializedSize; + private pbc::PopsicleList v2D_ = new pbc::PopsicleList(); + public scg::IList V2DList { + get { return pbc::Lists.AsReadOnly(v2D_); } + } + public int V2DCount { + get { return v2D_.Count; } + } + public double GetV2D(int index) { + return v2D_[index]; + } + + public const int V3FFieldNumber = 4; + private int v3FMemoizedSerializedSize; + private pbc::PopsicleList v3F_ = new pbc::PopsicleList(); + public scg::IList V3FList { + get { return pbc::Lists.AsReadOnly(v3F_); } + } + public int V3FCount { + get { return v3F_.Count; } + } + public float GetV3F(int index) { + return v3F_[index]; + } + + public const int V3DFieldNumber = 5; + private int v3DMemoizedSerializedSize; + private pbc::PopsicleList v3D_ = new pbc::PopsicleList(); + public scg::IList V3DList { + get { return pbc::Lists.AsReadOnly(v3D_); } + } + public int V3DCount { + get { return v3D_.Count; } + } + public double GetV3D(int index) { + return v3D_[index]; + } + + public const int V4FFieldNumber = 6; + private int v4FMemoizedSerializedSize; + private pbc::PopsicleList v4F_ = new pbc::PopsicleList(); + public scg::IList V4FList { + get { return pbc::Lists.AsReadOnly(v4F_); } + } + public int V4FCount { + get { return v4F_.Count; } + } + public float GetV4F(int index) { + return v4F_[index]; + } + + public const int V4DFieldNumber = 7; + private int v4DMemoizedSerializedSize; + private pbc::PopsicleList v4D_ = new pbc::PopsicleList(); + public scg::IList V4DList { + get { return pbc::Lists.AsReadOnly(v4D_); } + } + public int V4DCount { + get { return v4D_.Count; } + } + public double GetV4D(int index) { + return v4D_[index]; + } + + public const int QFieldNumber = 8; + private int qMemoizedSerializedSize; + private pbc::PopsicleList q_ = new pbc::PopsicleList(); + public scg::IList QList { + get { return pbc::Lists.AsReadOnly(q_); } + } + public int QCount { + get { return q_.Count; } + } + public float GetQ(int index) { + return q_[index]; + } + + public const int UFieldNumber = 9; + private bool hasU; + private pb::ByteString u_ = pb::ByteString.Empty; + public bool HasU { + get { return hasU; } + } + public pb::ByteString U { + get { return u_; } + } + + public const int AFieldNumber = 10; + private bool hasA; + private float a_ = 0F; + public bool HasA { + get { return hasA; } + } + public float A { + get { return a_; } + } + + public const int TFieldNumber = 11; + private bool hasT; + private ulong t_ = 0; + public bool HasT { + get { return hasT; } + } + [global::System.CLSCompliant(false)] + public ulong T { + get { return t_; } + } + + public const int DFieldNumber = 12; + private bool hasD; + private long d_ = 0; + public bool HasD { + get { return hasD; } + } + public long D { + get { return d_; } + } + + public const int F32FieldNumber = 13; + private bool hasF32; + private uint f32_ = 0; + public bool HasF32 { + get { return hasF32; } + } + [global::System.CLSCompliant(false)] + public uint F32 { + get { return f32_; } + } + + public const int F64FieldNumber = 14; + private bool hasF64; + private ulong f64_ = 0UL; + public bool HasF64 { + get { return hasF64; } + } + [global::System.CLSCompliant(false)] + public ulong F64 { + get { return f64_; } + } + + public const int BsfFieldNumber = 15; + private int bsfMemoizedSerializedSize; + private pbc::PopsicleList bsf_ = new pbc::PopsicleList(); + public scg::IList BsfList { + get { return pbc::Lists.AsReadOnly(bsf_); } + } + public int BsfCount { + get { return bsf_.Count; } + } + public float GetBsf(int index) { + return bsf_[index]; + } + + public const int BsdFieldNumber = 16; + private int bsdMemoizedSerializedSize; + private pbc::PopsicleList bsd_ = new pbc::PopsicleList(); + public scg::IList BsdList { + get { return pbc::Lists.AsReadOnly(bsd_); } + } + public int BsdCount { + get { return bsd_.Count; } + } + public double GetBsd(int index) { + return bsd_[index]; + } + + public const int BbfFieldNumber = 17; + private int bbfMemoizedSerializedSize; + private pbc::PopsicleList bbf_ = new pbc::PopsicleList(); + public scg::IList BbfList { + get { return pbc::Lists.AsReadOnly(bbf_); } + } + public int BbfCount { + get { return bbf_.Count; } + } + public float GetBbf(int index) { + return bbf_[index]; + } + + public const int BbdFieldNumber = 18; + private int bbdMemoizedSerializedSize; + private pbc::PopsicleList bbd_ = new pbc::PopsicleList(); + public scg::IList BbdList { + get { return pbc::Lists.AsReadOnly(bbd_); } + } + public int BbdCount { + get { return bbd_.Count; } + } + public double GetBbd(int index) { + return bbd_[index]; + } + + public const int E32FieldNumber = 19; + private bool hasE32; + private global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32 e32_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32.UNIVERSAL1; + public bool HasE32 { + get { return hasE32; } + } + public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32 E32 { + get { return e32_; } + } + + public const int SubmesFieldNumber = 30; + private bool hasSubmes; + private global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage submes_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance; + public bool HasSubmes { + get { return hasSubmes; } + } + public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage Submes { + get { return submes_; } + } + + public const int SubmessersFieldNumber = 31; + private pbc::PopsicleList submessers_ = new pbc::PopsicleList(); + public scg::IList SubmessersList { + get { return submessers_; } + } + public int SubmessersCount { + get { return submessers_.Count; } + } + public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage GetSubmessers(int index) { + return submessers_[index]; + } + + public const int ShaFieldNumber = 32; + private bool hasSha; + private pb::ByteString sha_ = pb::ByteString.Empty; + public bool HasSha { + get { return hasSha; } + } + public pb::ByteString Sha { + get { return sha_; } + } + + public const int ShasFieldNumber = 33; + private pbc::PopsicleList shas_ = new pbc::PopsicleList(); + public scg::IList ShasList { + get { return pbc::Lists.AsReadOnly(shas_); } + } + public int ShasCount { + get { return shas_.Count; } + } + public pb::ByteString GetShas(int index) { + return shas_[index]; + } + + public const int ExtmesFieldNumber = 34; + private bool hasExtmes; + private global::Sirikata.PB._PBJ_Internal.ExternalMessage extmes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance; + public bool HasExtmes { + get { return hasExtmes; } + } + public global::Sirikata.PB._PBJ_Internal.ExternalMessage Extmes { + get { return extmes_; } + } + + public const int ExtmessersFieldNumber = 35; + private pbc::PopsicleList extmessers_ = new pbc::PopsicleList(); + public scg::IList ExtmessersList { + get { return extmessers_; } + } + public int ExtmessersCount { + get { return extmessers_.Count; } + } + public global::Sirikata.PB._PBJ_Internal.ExternalMessage GetExtmessers(int index) { + return extmessers_[index]; + } + + public const int ExtmesserFieldNumber = 36; + private bool hasExtmesser; + private global::Sirikata.PB._PBJ_Internal.ExternalMessage extmesser_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance; + public bool HasExtmesser { + get { return hasExtmesser; } + } + public global::Sirikata.PB._PBJ_Internal.ExternalMessage Extmesser { + get { return extmesser_; } + } + + public override bool IsInitialized { + get { + if (!hasXxfr) return false; + if (!hasExtmesser) return false; + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + if (n_.Count > 0) { + output.WriteRawVarint32(10); + output.WriteRawVarint32((uint) nMemoizedSerializedSize); + foreach (float element in n_) { + output.WriteFloatNoTag(element); + } + } + if (v2F_.Count > 0) { + output.WriteRawVarint32(18); + output.WriteRawVarint32((uint) v2FMemoizedSerializedSize); + foreach (float element in v2F_) { + output.WriteFloatNoTag(element); + } + } + if (v2D_.Count > 0) { + output.WriteRawVarint32(26); + output.WriteRawVarint32((uint) v2DMemoizedSerializedSize); + foreach (double element in v2D_) { + output.WriteDoubleNoTag(element); + } + } + if (v3F_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) v3FMemoizedSerializedSize); + foreach (float element in v3F_) { + output.WriteFloatNoTag(element); + } + } + if (v3D_.Count > 0) { + output.WriteRawVarint32(42); + output.WriteRawVarint32((uint) v3DMemoizedSerializedSize); + foreach (double element in v3D_) { + output.WriteDoubleNoTag(element); + } + } + if (v4F_.Count > 0) { + output.WriteRawVarint32(50); + output.WriteRawVarint32((uint) v4FMemoizedSerializedSize); + foreach (float element in v4F_) { + output.WriteFloatNoTag(element); + } + } + if (v4D_.Count > 0) { + output.WriteRawVarint32(58); + output.WriteRawVarint32((uint) v4DMemoizedSerializedSize); + foreach (double element in v4D_) { + output.WriteDoubleNoTag(element); + } + } + if (q_.Count > 0) { + output.WriteRawVarint32(66); + output.WriteRawVarint32((uint) qMemoizedSerializedSize); + foreach (float element in q_) { + output.WriteFloatNoTag(element); + } + } + if (HasU) { + output.WriteBytes(9, U); + } + if (HasA) { + output.WriteFloat(10, A); + } + if (HasT) { + output.WriteFixed64(11, T); + } + if (HasD) { + output.WriteSFixed64(12, D); + } + if (HasF32) { + output.WriteUInt32(13, F32); + } + if (HasF64) { + output.WriteUInt64(14, F64); + } + if (bsf_.Count > 0) { + output.WriteRawVarint32(122); + output.WriteRawVarint32((uint) bsfMemoizedSerializedSize); + foreach (float element in bsf_) { + output.WriteFloatNoTag(element); + } + } + if (bsd_.Count > 0) { + output.WriteRawVarint32(130); + output.WriteRawVarint32((uint) bsdMemoizedSerializedSize); + foreach (double element in bsd_) { + output.WriteDoubleNoTag(element); + } + } + if (bbf_.Count > 0) { + output.WriteRawVarint32(138); + output.WriteRawVarint32((uint) bbfMemoizedSerializedSize); + foreach (float element in bbf_) { + output.WriteFloatNoTag(element); + } + } + if (bbd_.Count > 0) { + output.WriteRawVarint32(146); + output.WriteRawVarint32((uint) bbdMemoizedSerializedSize); + foreach (double element in bbd_) { + output.WriteDoubleNoTag(element); + } + } + if (HasE32) { + output.WriteEnum(19, (int) E32); + } + if (HasXxd) { + output.WriteDouble(20, Xxd); + } + if (HasXxf) { + output.WriteFloat(21, Xxf); + } + if (HasXxu32) { + output.WriteUInt32(22, Xxu32); + } + if (HasXxs) { + output.WriteString(23, Xxs); + } + if (HasXxb) { + output.WriteBytes(24, Xxb); + } + if (xxss_.Count > 0) { + foreach (string element in xxss_) { + output.WriteString(25, element); + } + } + if (xxbb_.Count > 0) { + foreach (pb::ByteString element in xxbb_) { + output.WriteBytes(26, element); + } + } + if (xxff_.Count > 0) { + output.WriteRawVarint32(218); + output.WriteRawVarint32((uint) xxffMemoizedSerializedSize); + foreach (float element in xxff_) { + output.WriteFloatNoTag(element); + } + } + if (HasXxfr) { + output.WriteFloat(28, Xxfr); + } + if (xxnn_.Count > 0) { + output.WriteRawVarint32(234); + output.WriteRawVarint32((uint) xxnnMemoizedSerializedSize); + foreach (float element in xxnn_) { + output.WriteFloatNoTag(element); + } + } + if (HasSubmes) { + output.WriteMessage(30, Submes); + } + foreach (global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage element in SubmessersList) { + output.WriteMessage(31, element); + } + if (HasSha) { + output.WriteBytes(32, Sha); + } + if (shas_.Count > 0) { + foreach (pb::ByteString element in shas_) { + output.WriteBytes(33, element); + } + } + if (HasExtmes) { + output.WriteMessage(34, Extmes); + } + foreach (global::Sirikata.PB._PBJ_Internal.ExternalMessage element in ExtmessersList) { + output.WriteMessage(35, element); + } + if (HasExtmesser) { + output.WriteMessage(36, Extmesser); + } + extensionWriter.WriteUntil(200, output); + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasXxd) { + size += pb::CodedOutputStream.ComputeDoubleSize(20, Xxd); + } + if (HasXxf) { + size += pb::CodedOutputStream.ComputeFloatSize(21, Xxf); + } + if (HasXxu32) { + size += pb::CodedOutputStream.ComputeUInt32Size(22, Xxu32); + } + if (HasXxs) { + size += pb::CodedOutputStream.ComputeStringSize(23, Xxs); + } + if (HasXxb) { + size += pb::CodedOutputStream.ComputeBytesSize(24, Xxb); + } + { + int dataSize = 0; + foreach (string element in XxssList) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 2 * xxss_.Count; + } + { + int dataSize = 0; + foreach (pb::ByteString element in XxbbList) { + dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); + } + size += dataSize; + size += 2 * xxbb_.Count; + } + { + int dataSize = 0; + dataSize = 4 * xxff_.Count; + size += dataSize; + if (xxff_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + xxffMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * xxnn_.Count; + size += dataSize; + if (xxnn_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + xxnnMemoizedSerializedSize = dataSize; + } + if (HasXxfr) { + size += pb::CodedOutputStream.ComputeFloatSize(28, Xxfr); + } + { + int dataSize = 0; + dataSize = 4 * n_.Count; + size += dataSize; + if (n_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + nMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * v2F_.Count; + size += dataSize; + if (v2F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + v2FMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 8 * v2D_.Count; + size += dataSize; + if (v2D_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + v2DMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * v3F_.Count; + size += dataSize; + if (v3F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + v3FMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 8 * v3D_.Count; + size += dataSize; + if (v3D_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + v3DMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * v4F_.Count; + size += dataSize; + if (v4F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + v4FMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 8 * v4D_.Count; + size += dataSize; + if (v4D_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + v4DMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * q_.Count; + size += dataSize; + if (q_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + qMemoizedSerializedSize = dataSize; + } + if (HasU) { + size += pb::CodedOutputStream.ComputeBytesSize(9, U); + } + if (HasA) { + size += pb::CodedOutputStream.ComputeFloatSize(10, A); + } + if (HasT) { + size += pb::CodedOutputStream.ComputeFixed64Size(11, T); + } + if (HasD) { + size += pb::CodedOutputStream.ComputeSFixed64Size(12, D); + } + if (HasF32) { + size += pb::CodedOutputStream.ComputeUInt32Size(13, F32); + } + if (HasF64) { + size += pb::CodedOutputStream.ComputeUInt64Size(14, F64); + } + { + int dataSize = 0; + dataSize = 4 * bsf_.Count; + size += dataSize; + if (bsf_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + bsfMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 8 * bsd_.Count; + size += dataSize; + if (bsd_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + bsdMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * bbf_.Count; + size += dataSize; + if (bbf_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + bbfMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 8 * bbd_.Count; + size += dataSize; + if (bbd_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + bbdMemoizedSerializedSize = dataSize; + } + if (HasE32) { + size += pb::CodedOutputStream.ComputeEnumSize(19, (int) E32); + } + if (HasSubmes) { + size += pb::CodedOutputStream.ComputeMessageSize(30, Submes); + } + foreach (global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage element in SubmessersList) { + size += pb::CodedOutputStream.ComputeMessageSize(31, element); + } + if (HasSha) { + size += pb::CodedOutputStream.ComputeBytesSize(32, Sha); + } + { + int dataSize = 0; + foreach (pb::ByteString element in ShasList) { + dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); + } + size += dataSize; + size += 2 * shas_.Count; + } + if (HasExtmes) { + size += pb::CodedOutputStream.ComputeMessageSize(34, Extmes); + } + foreach (global::Sirikata.PB._PBJ_Internal.ExternalMessage element in ExtmessersList) { + size += pb::CodedOutputStream.ComputeMessageSize(35, element); + } + if (HasExtmesser) { + size += pb::CodedOutputStream.ComputeMessageSize(36, Extmesser); + } + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMessage ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static TestMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static TestMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessage 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(TestMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMessage result = new TestMessage(); + + protected override TestMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.PB._PBJ_Internal.TestMessage.Descriptor; } + } + + public override TestMessage DefaultInstanceForType { + get { return global::Sirikata.PB._PBJ_Internal.TestMessage.DefaultInstance; } + } + + public override TestMessage BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.xxss_.MakeReadOnly(); + result.xxbb_.MakeReadOnly(); + result.xxff_.MakeReadOnly(); + result.xxnn_.MakeReadOnly(); + result.n_.MakeReadOnly(); + result.v2F_.MakeReadOnly(); + result.v2D_.MakeReadOnly(); + result.v3F_.MakeReadOnly(); + result.v3D_.MakeReadOnly(); + result.v4F_.MakeReadOnly(); + result.v4D_.MakeReadOnly(); + result.q_.MakeReadOnly(); + result.bsf_.MakeReadOnly(); + result.bsd_.MakeReadOnly(); + result.bbf_.MakeReadOnly(); + result.bbd_.MakeReadOnly(); + result.submessers_.MakeReadOnly(); + result.shas_.MakeReadOnly(); + result.extmessers_.MakeReadOnly(); + TestMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMessage) { + return MergeFrom((TestMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMessage other) { + if (other == global::Sirikata.PB._PBJ_Internal.TestMessage.DefaultInstance) return this; + if (other.HasXxd) { + Xxd = other.Xxd; + } + if (other.HasXxf) { + Xxf = other.Xxf; + } + if (other.HasXxu32) { + Xxu32 = other.Xxu32; + } + if (other.HasXxs) { + Xxs = other.Xxs; + } + if (other.HasXxb) { + Xxb = other.Xxb; + } + if (other.xxss_.Count != 0) { + base.AddRange(other.xxss_, result.xxss_); + } + if (other.xxbb_.Count != 0) { + base.AddRange(other.xxbb_, result.xxbb_); + } + if (other.xxff_.Count != 0) { + base.AddRange(other.xxff_, result.xxff_); + } + if (other.xxnn_.Count != 0) { + base.AddRange(other.xxnn_, result.xxnn_); + } + if (other.HasXxfr) { + Xxfr = other.Xxfr; + } + if (other.n_.Count != 0) { + base.AddRange(other.n_, result.n_); + } + if (other.v2F_.Count != 0) { + base.AddRange(other.v2F_, result.v2F_); + } + if (other.v2D_.Count != 0) { + base.AddRange(other.v2D_, result.v2D_); + } + if (other.v3F_.Count != 0) { + base.AddRange(other.v3F_, result.v3F_); + } + if (other.v3D_.Count != 0) { + base.AddRange(other.v3D_, result.v3D_); + } + if (other.v4F_.Count != 0) { + base.AddRange(other.v4F_, result.v4F_); + } + if (other.v4D_.Count != 0) { + base.AddRange(other.v4D_, result.v4D_); + } + if (other.q_.Count != 0) { + base.AddRange(other.q_, result.q_); + } + if (other.HasU) { + U = other.U; + } + if (other.HasA) { + A = other.A; + } + if (other.HasT) { + T = other.T; + } + if (other.HasD) { + D = other.D; + } + if (other.HasF32) { + F32 = other.F32; + } + if (other.HasF64) { + F64 = other.F64; + } + if (other.bsf_.Count != 0) { + base.AddRange(other.bsf_, result.bsf_); + } + if (other.bsd_.Count != 0) { + base.AddRange(other.bsd_, result.bsd_); + } + if (other.bbf_.Count != 0) { + base.AddRange(other.bbf_, result.bbf_); + } + if (other.bbd_.Count != 0) { + base.AddRange(other.bbd_, result.bbd_); + } + if (other.HasE32) { + E32 = other.E32; + } + if (other.HasSubmes) { + MergeSubmes(other.Submes); + } + if (other.submessers_.Count != 0) { + base.AddRange(other.submessers_, result.submessers_); + } + if (other.HasSha) { + Sha = other.Sha; + } + if (other.shas_.Count != 0) { + base.AddRange(other.shas_, result.shas_); + } + if (other.HasExtmes) { + MergeExtmes(other.Extmes); + } + if (other.extmessers_.Count != 0) { + base.AddRange(other.extmessers_, result.extmessers_); + } + if (other.HasExtmesser) { + MergeExtmesser(other.Extmesser); + } + this.MergeExtensionFields(other); + 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: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddN(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 18: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddV2F(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 26: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddV2D(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddV3F(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 42: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddV3D(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 50: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddV4F(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 58: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddV4D(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 66: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddQ(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 74: { + U = input.ReadBytes(); + break; + } + case 85: { + A = input.ReadFloat(); + break; + } + case 89: { + T = input.ReadFixed64(); + break; + } + case 97: { + D = input.ReadSFixed64(); + break; + } + case 104: { + F32 = input.ReadUInt32(); + break; + } + case 112: { + F64 = input.ReadUInt64(); + break; + } + case 122: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddBsf(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 130: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddBsd(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 138: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddBbf(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 146: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddBbd(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 152: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32), rawValue)) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(19, (ulong) rawValue); + } else { + E32 = (global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32) rawValue; + } + break; + } + case 161: { + Xxd = input.ReadDouble(); + break; + } + case 173: { + Xxf = input.ReadFloat(); + break; + } + case 176: { + Xxu32 = input.ReadUInt32(); + break; + } + case 186: { + Xxs = input.ReadString(); + break; + } + case 194: { + Xxb = input.ReadBytes(); + break; + } + case 202: { + AddXxss(input.ReadString()); + break; + } + case 210: { + AddXxbb(input.ReadBytes()); + break; + } + case 218: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddXxff(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 229: { + Xxfr = input.ReadFloat(); + break; + } + case 234: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddXxnn(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 242: { + global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.CreateBuilder(); + if (HasSubmes) { + subBuilder.MergeFrom(Submes); + } + input.ReadMessage(subBuilder, extensionRegistry); + Submes = subBuilder.BuildPartial(); + break; + } + case 250: { + global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddSubmessers(subBuilder.BuildPartial()); + break; + } + case 258: { + Sha = input.ReadBytes(); + break; + } + case 266: { + AddShas(input.ReadBytes()); + break; + } + case 274: { + global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder(); + if (HasExtmes) { + subBuilder.MergeFrom(Extmes); + } + input.ReadMessage(subBuilder, extensionRegistry); + Extmes = subBuilder.BuildPartial(); + break; + } + case 282: { + global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddExtmessers(subBuilder.BuildPartial()); + break; + } + case 290: { + global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder(); + if (HasExtmesser) { + subBuilder.MergeFrom(Extmesser); + } + input.ReadMessage(subBuilder, extensionRegistry); + Extmesser = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasXxd { + get { return result.HasXxd; } + } + public double Xxd { + get { return result.Xxd; } + set { SetXxd(value); } + } + public Builder SetXxd(double value) { + result.hasXxd = true; + result.xxd_ = value; + return this; + } + public Builder ClearXxd() { + result.hasXxd = false; + result.xxd_ = 10.3D; + return this; + } + + public bool HasXxf { + get { return result.HasXxf; } + } + public float Xxf { + get { return result.Xxf; } + set { SetXxf(value); } + } + public Builder SetXxf(float value) { + result.hasXxf = true; + result.xxf_ = value; + return this; + } + public Builder ClearXxf() { + result.hasXxf = false; + result.xxf_ = 0F; + return this; + } + + public bool HasXxu32 { + get { return result.HasXxu32; } + } + [global::System.CLSCompliant(false)] + public uint Xxu32 { + get { return result.Xxu32; } + set { SetXxu32(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetXxu32(uint value) { + result.hasXxu32 = true; + result.xxu32_ = value; + return this; + } + public Builder ClearXxu32() { + result.hasXxu32 = false; + result.xxu32_ = 0; + return this; + } + + public bool HasXxs { + get { return result.HasXxs; } + } + public string Xxs { + get { return result.Xxs; } + set { SetXxs(value); } + } + public Builder SetXxs(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasXxs = true; + result.xxs_ = value; + return this; + } + public Builder ClearXxs() { + result.hasXxs = false; + result.xxs_ = ""; + return this; + } + + public bool HasXxb { + get { return result.HasXxb; } + } + public pb::ByteString Xxb { + get { return result.Xxb; } + set { SetXxb(value); } + } + public Builder SetXxb(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasXxb = true; + result.xxb_ = value; + return this; + } + public Builder ClearXxb() { + result.hasXxb = false; + result.xxb_ = pb::ByteString.Empty; + return this; + } + + public pbc::IPopsicleList XxssList { + get { return result.xxss_; } + } + public int XxssCount { + get { return result.XxssCount; } + } + public string GetXxss(int index) { + return result.GetXxss(index); + } + public Builder SetXxss(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.xxss_[index] = value; + return this; + } + public Builder AddXxss(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.xxss_.Add(value); + return this; + } + public Builder AddRangeXxss(scg::IEnumerable values) { + base.AddRange(values, result.xxss_); + return this; + } + public Builder ClearXxss() { + result.xxss_.Clear(); + return this; + } + + public pbc::IPopsicleList XxbbList { + get { return result.xxbb_; } + } + public int XxbbCount { + get { return result.XxbbCount; } + } + public pb::ByteString GetXxbb(int index) { + return result.GetXxbb(index); + } + public Builder SetXxbb(int index, pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.xxbb_[index] = value; + return this; + } + public Builder AddXxbb(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.xxbb_.Add(value); + return this; + } + public Builder AddRangeXxbb(scg::IEnumerable values) { + base.AddRange(values, result.xxbb_); + return this; + } + public Builder ClearXxbb() { + result.xxbb_.Clear(); + return this; + } + + public pbc::IPopsicleList XxffList { + get { return result.xxff_; } + } + public int XxffCount { + get { return result.XxffCount; } + } + public float GetXxff(int index) { + return result.GetXxff(index); + } + public Builder SetXxff(int index, float value) { + result.xxff_[index] = value; + return this; + } + public Builder AddXxff(float value) { + result.xxff_.Add(value); + return this; + } + public Builder AddRangeXxff(scg::IEnumerable values) { + base.AddRange(values, result.xxff_); + return this; + } + public Builder ClearXxff() { + result.xxff_.Clear(); + return this; + } + + public pbc::IPopsicleList XxnnList { + get { return result.xxnn_; } + } + public int XxnnCount { + get { return result.XxnnCount; } + } + public float GetXxnn(int index) { + return result.GetXxnn(index); + } + public Builder SetXxnn(int index, float value) { + result.xxnn_[index] = value; + return this; + } + public Builder AddXxnn(float value) { + result.xxnn_.Add(value); + return this; + } + public Builder AddRangeXxnn(scg::IEnumerable values) { + base.AddRange(values, result.xxnn_); + return this; + } + public Builder ClearXxnn() { + result.xxnn_.Clear(); + return this; + } + + public bool HasXxfr { + get { return result.HasXxfr; } + } + public float Xxfr { + get { return result.Xxfr; } + set { SetXxfr(value); } + } + public Builder SetXxfr(float value) { + result.hasXxfr = true; + result.xxfr_ = value; + return this; + } + public Builder ClearXxfr() { + result.hasXxfr = false; + result.xxfr_ = 0F; + return this; + } + + public pbc::IPopsicleList NList { + get { return result.n_; } + } + public int NCount { + get { return result.NCount; } + } + public float GetN(int index) { + return result.GetN(index); + } + public Builder SetN(int index, float value) { + result.n_[index] = value; + return this; + } + public Builder AddN(float value) { + result.n_.Add(value); + return this; + } + public Builder AddRangeN(scg::IEnumerable values) { + base.AddRange(values, result.n_); + return this; + } + public Builder ClearN() { + result.n_.Clear(); + return this; + } + + public pbc::IPopsicleList V2FList { + get { return result.v2F_; } + } + public int V2FCount { + get { return result.V2FCount; } + } + public float GetV2F(int index) { + return result.GetV2F(index); + } + public Builder SetV2F(int index, float value) { + result.v2F_[index] = value; + return this; + } + public Builder AddV2F(float value) { + result.v2F_.Add(value); + return this; + } + public Builder AddRangeV2F(scg::IEnumerable values) { + base.AddRange(values, result.v2F_); + return this; + } + public Builder ClearV2F() { + result.v2F_.Clear(); + return this; + } + + public pbc::IPopsicleList V2DList { + get { return result.v2D_; } + } + public int V2DCount { + get { return result.V2DCount; } + } + public double GetV2D(int index) { + return result.GetV2D(index); + } + public Builder SetV2D(int index, double value) { + result.v2D_[index] = value; + return this; + } + public Builder AddV2D(double value) { + result.v2D_.Add(value); + return this; + } + public Builder AddRangeV2D(scg::IEnumerable values) { + base.AddRange(values, result.v2D_); + return this; + } + public Builder ClearV2D() { + result.v2D_.Clear(); + return this; + } + + public pbc::IPopsicleList V3FList { + get { return result.v3F_; } + } + public int V3FCount { + get { return result.V3FCount; } + } + public float GetV3F(int index) { + return result.GetV3F(index); + } + public Builder SetV3F(int index, float value) { + result.v3F_[index] = value; + return this; + } + public Builder AddV3F(float value) { + result.v3F_.Add(value); + return this; + } + public Builder AddRangeV3F(scg::IEnumerable values) { + base.AddRange(values, result.v3F_); + return this; + } + public Builder ClearV3F() { + result.v3F_.Clear(); + return this; + } + + public pbc::IPopsicleList V3DList { + get { return result.v3D_; } + } + public int V3DCount { + get { return result.V3DCount; } + } + public double GetV3D(int index) { + return result.GetV3D(index); + } + public Builder SetV3D(int index, double value) { + result.v3D_[index] = value; + return this; + } + public Builder AddV3D(double value) { + result.v3D_.Add(value); + return this; + } + public Builder AddRangeV3D(scg::IEnumerable values) { + base.AddRange(values, result.v3D_); + return this; + } + public Builder ClearV3D() { + result.v3D_.Clear(); + return this; + } + + public pbc::IPopsicleList V4FList { + get { return result.v4F_; } + } + public int V4FCount { + get { return result.V4FCount; } + } + public float GetV4F(int index) { + return result.GetV4F(index); + } + public Builder SetV4F(int index, float value) { + result.v4F_[index] = value; + return this; + } + public Builder AddV4F(float value) { + result.v4F_.Add(value); + return this; + } + public Builder AddRangeV4F(scg::IEnumerable values) { + base.AddRange(values, result.v4F_); + return this; + } + public Builder ClearV4F() { + result.v4F_.Clear(); + return this; + } + + public pbc::IPopsicleList V4DList { + get { return result.v4D_; } + } + public int V4DCount { + get { return result.V4DCount; } + } + public double GetV4D(int index) { + return result.GetV4D(index); + } + public Builder SetV4D(int index, double value) { + result.v4D_[index] = value; + return this; + } + public Builder AddV4D(double value) { + result.v4D_.Add(value); + return this; + } + public Builder AddRangeV4D(scg::IEnumerable values) { + base.AddRange(values, result.v4D_); + return this; + } + public Builder ClearV4D() { + result.v4D_.Clear(); + return this; + } + + public pbc::IPopsicleList QList { + get { return result.q_; } + } + public int QCount { + get { return result.QCount; } + } + public float GetQ(int index) { + return result.GetQ(index); + } + public Builder SetQ(int index, float value) { + result.q_[index] = value; + return this; + } + public Builder AddQ(float value) { + result.q_.Add(value); + return this; + } + public Builder AddRangeQ(scg::IEnumerable values) { + base.AddRange(values, result.q_); + return this; + } + public Builder ClearQ() { + result.q_.Clear(); + return this; + } + + public bool HasU { + get { return result.HasU; } + } + public pb::ByteString U { + get { return result.U; } + set { SetU(value); } + } + public Builder SetU(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasU = true; + result.u_ = value; + return this; + } + public Builder ClearU() { + result.hasU = false; + result.u_ = pb::ByteString.Empty; + return this; + } + + public bool HasA { + get { return result.HasA; } + } + public float A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(float value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0F; + return this; + } + + public bool HasT { + get { return result.HasT; } + } + [global::System.CLSCompliant(false)] + public ulong T { + get { return result.T; } + set { SetT(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetT(ulong value) { + result.hasT = true; + result.t_ = value; + return this; + } + public Builder ClearT() { + result.hasT = false; + result.t_ = 0; + return this; + } + + public bool HasD { + get { return result.HasD; } + } + public long D { + get { return result.D; } + set { SetD(value); } + } + public Builder SetD(long value) { + result.hasD = true; + result.d_ = value; + return this; + } + public Builder ClearD() { + result.hasD = false; + result.d_ = 0; + return this; + } + + public bool HasF32 { + get { return result.HasF32; } + } + [global::System.CLSCompliant(false)] + public uint F32 { + get { return result.F32; } + set { SetF32(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetF32(uint value) { + result.hasF32 = true; + result.f32_ = value; + return this; + } + public Builder ClearF32() { + result.hasF32 = false; + result.f32_ = 0; + return this; + } + + public bool HasF64 { + get { return result.HasF64; } + } + [global::System.CLSCompliant(false)] + public ulong F64 { + get { return result.F64; } + set { SetF64(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetF64(ulong value) { + result.hasF64 = true; + result.f64_ = value; + return this; + } + public Builder ClearF64() { + result.hasF64 = false; + result.f64_ = 0UL; + return this; + } + + public pbc::IPopsicleList BsfList { + get { return result.bsf_; } + } + public int BsfCount { + get { return result.BsfCount; } + } + public float GetBsf(int index) { + return result.GetBsf(index); + } + public Builder SetBsf(int index, float value) { + result.bsf_[index] = value; + return this; + } + public Builder AddBsf(float value) { + result.bsf_.Add(value); + return this; + } + public Builder AddRangeBsf(scg::IEnumerable values) { + base.AddRange(values, result.bsf_); + return this; + } + public Builder ClearBsf() { + result.bsf_.Clear(); + return this; + } + + public pbc::IPopsicleList BsdList { + get { return result.bsd_; } + } + public int BsdCount { + get { return result.BsdCount; } + } + public double GetBsd(int index) { + return result.GetBsd(index); + } + public Builder SetBsd(int index, double value) { + result.bsd_[index] = value; + return this; + } + public Builder AddBsd(double value) { + result.bsd_.Add(value); + return this; + } + public Builder AddRangeBsd(scg::IEnumerable values) { + base.AddRange(values, result.bsd_); + return this; + } + public Builder ClearBsd() { + result.bsd_.Clear(); + return this; + } + + public pbc::IPopsicleList BbfList { + get { return result.bbf_; } + } + public int BbfCount { + get { return result.BbfCount; } + } + public float GetBbf(int index) { + return result.GetBbf(index); + } + public Builder SetBbf(int index, float value) { + result.bbf_[index] = value; + return this; + } + public Builder AddBbf(float value) { + result.bbf_.Add(value); + return this; + } + public Builder AddRangeBbf(scg::IEnumerable values) { + base.AddRange(values, result.bbf_); + return this; + } + public Builder ClearBbf() { + result.bbf_.Clear(); + return this; + } + + public pbc::IPopsicleList BbdList { + get { return result.bbd_; } + } + public int BbdCount { + get { return result.BbdCount; } + } + public double GetBbd(int index) { + return result.GetBbd(index); + } + public Builder SetBbd(int index, double value) { + result.bbd_[index] = value; + return this; + } + public Builder AddBbd(double value) { + result.bbd_.Add(value); + return this; + } + public Builder AddRangeBbd(scg::IEnumerable values) { + base.AddRange(values, result.bbd_); + return this; + } + public Builder ClearBbd() { + result.bbd_.Clear(); + return this; + } + + public bool HasE32 { + get { return result.HasE32; } + } + public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32 E32 { + get { return result.E32; } + set { SetE32(value); } + } + public Builder SetE32(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32 value) { + result.hasE32 = true; + result.e32_ = value; + return this; + } + public Builder ClearE32() { + result.hasE32 = false; + result.e32_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32.UNIVERSAL1; + return this; + } + + public bool HasSubmes { + get { return result.HasSubmes; } + } + public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage Submes { + get { return result.Submes; } + set { SetSubmes(value); } + } + public Builder SetSubmes(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasSubmes = true; + result.submes_ = value; + return this; + } + public Builder SetSubmes(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasSubmes = true; + result.submes_ = builderForValue.Build(); + return this; + } + public Builder MergeSubmes(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasSubmes && + result.submes_ != global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance) { + result.submes_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.CreateBuilder(result.submes_).MergeFrom(value).BuildPartial(); + } else { + result.submes_ = value; + } + result.hasSubmes = true; + return this; + } + public Builder ClearSubmes() { + result.hasSubmes = false; + result.submes_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance; + return this; + } + + public pbc::IPopsicleList SubmessersList { + get { return result.submessers_; } + } + public int SubmessersCount { + get { return result.SubmessersCount; } + } + public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage GetSubmessers(int index) { + return result.GetSubmessers(index); + } + public Builder SetSubmessers(int index, global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.submessers_[index] = value; + return this; + } + public Builder SetSubmessers(int index, global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.submessers_[index] = builderForValue.Build(); + return this; + } + public Builder AddSubmessers(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.submessers_.Add(value); + return this; + } + public Builder AddSubmessers(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.submessers_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeSubmessers(scg::IEnumerable values) { + base.AddRange(values, result.submessers_); + return this; + } + public Builder ClearSubmessers() { + result.submessers_.Clear(); + return this; + } + + public bool HasSha { + get { return result.HasSha; } + } + public pb::ByteString Sha { + get { return result.Sha; } + set { SetSha(value); } + } + public Builder SetSha(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasSha = true; + result.sha_ = value; + return this; + } + public Builder ClearSha() { + result.hasSha = false; + result.sha_ = pb::ByteString.Empty; + return this; + } + + public pbc::IPopsicleList ShasList { + get { return result.shas_; } + } + public int ShasCount { + get { return result.ShasCount; } + } + public pb::ByteString GetShas(int index) { + return result.GetShas(index); + } + public Builder SetShas(int index, pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.shas_[index] = value; + return this; + } + public Builder AddShas(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.shas_.Add(value); + return this; + } + public Builder AddRangeShas(scg::IEnumerable values) { + base.AddRange(values, result.shas_); + return this; + } + public Builder ClearShas() { + result.shas_.Clear(); + return this; + } + + public bool HasExtmes { + get { return result.HasExtmes; } + } + public global::Sirikata.PB._PBJ_Internal.ExternalMessage Extmes { + get { return result.Extmes; } + set { SetExtmes(value); } + } + public Builder SetExtmes(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasExtmes = true; + result.extmes_ = value; + return this; + } + public Builder SetExtmes(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasExtmes = true; + result.extmes_ = builderForValue.Build(); + return this; + } + public Builder MergeExtmes(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasExtmes && + result.extmes_ != global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance) { + result.extmes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder(result.extmes_).MergeFrom(value).BuildPartial(); + } else { + result.extmes_ = value; + } + result.hasExtmes = true; + return this; + } + public Builder ClearExtmes() { + result.hasExtmes = false; + result.extmes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance; + return this; + } + + public pbc::IPopsicleList ExtmessersList { + get { return result.extmessers_; } + } + public int ExtmessersCount { + get { return result.ExtmessersCount; } + } + public global::Sirikata.PB._PBJ_Internal.ExternalMessage GetExtmessers(int index) { + return result.GetExtmessers(index); + } + public Builder SetExtmessers(int index, global::Sirikata.PB._PBJ_Internal.ExternalMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.extmessers_[index] = value; + return this; + } + public Builder SetExtmessers(int index, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.extmessers_[index] = builderForValue.Build(); + return this; + } + public Builder AddExtmessers(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.extmessers_.Add(value); + return this; + } + public Builder AddExtmessers(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.extmessers_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeExtmessers(scg::IEnumerable values) { + base.AddRange(values, result.extmessers_); + return this; + } + public Builder ClearExtmessers() { + result.extmessers_.Clear(); + return this; + } + + public bool HasExtmesser { + get { return result.HasExtmesser; } + } + public global::Sirikata.PB._PBJ_Internal.ExternalMessage Extmesser { + get { return result.Extmesser; } + set { SetExtmesser(value); } + } + public Builder SetExtmesser(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasExtmesser = true; + result.extmesser_ = value; + return this; + } + public Builder SetExtmesser(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasExtmesser = true; + result.extmesser_ = builderForValue.Build(); + return this; + } + public Builder MergeExtmesser(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasExtmesser && + result.extmesser_ != global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance) { + result.extmesser_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder(result.extmesser_).MergeFrom(value).BuildPartial(); + } else { + result.extmesser_ = value; + } + result.hasExtmesser = true; + return this; + } + public Builder ClearExtmesser() { + result.hasExtmesser = false; + result.extmesser_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance; + return this; + } + } + static TestMessage() { + object.ReferenceEquals(global::Sirikata.PB._PBJ_Internal.Test.Descriptor, null); + } + } + + #endregion + +} diff --git a/OpenSim/Client/Sirikata/Protocol/Test.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Test.pbj.cs new file mode 100644 index 0000000..c753c36 --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Test.pbj.cs @@ -0,0 +1,1734 @@ +using pbd = global::Google.ProtocolBuffers.Descriptors; +using pb = global::Google.ProtocolBuffers; +namespace Sirikata.PB { + public class ExternalMessage : PBJ.IMessage { + protected _PBJ_Internal.ExternalMessage super; + public _PBJ_Internal.ExternalMessage _PBJSuper{ get { return super;} } + public ExternalMessage() { + super=new _PBJ_Internal.ExternalMessage(); + } + public ExternalMessage(_PBJ_Internal.ExternalMessage reference) { + super=reference; + } + public static ExternalMessage defaultInstance= new ExternalMessage (_PBJ_Internal.ExternalMessage.DefaultInstance); + public static ExternalMessage DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.ExternalMessage.Descriptor; } } + public static class Types { + public class SubMessage : PBJ.IMessage { + protected _PBJ_Internal.ExternalMessage.Types.SubMessage super; + public _PBJ_Internal.ExternalMessage.Types.SubMessage _PBJSuper{ get { return super;} } + public SubMessage() { + super=new _PBJ_Internal.ExternalMessage.Types.SubMessage(); + } + public SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage reference) { + super=reference; + } + public static SubMessage defaultInstance= new SubMessage (_PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance); + public static SubMessage DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.ExternalMessage.Types.SubMessage.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int SubuuidFieldTag=1; + public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} } + public PBJ.UUID Subuuid{ get { + if (HasSubuuid) { + return PBJ._PBJ.CastUuid(super.Subuuid); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int SubvectorFieldTag=2; + public bool HasSubvector{ get {return super.SubvectorCount>=3;} } + public PBJ.Vector3d Subvector{ get { + int index=0; + if (HasSubvector) { + return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + } + public const int SubdurationFieldTag=3; + public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} } + public PBJ.Duration Subduration{ get { + if (HasSubduration) { + return PBJ._PBJ.CastDuration(super.Subduration); + } else { + return PBJ._PBJ.CastDuration(); + } + } + } + public const int SubnormalFieldTag=4; + public bool HasSubnormal{ get {return super.SubnormalCount>=2;} } + public PBJ.Vector3f Subnormal{ get { + int index=0; + if (HasSubnormal) { + return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1)); + } else { + return PBJ._PBJ.CastNormal(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(SubMessage prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static SubMessage ParseFrom(pb::ByteString data) { + return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data)); + } + public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er)); + } + public static SubMessage ParseFrom(byte[] data) { + return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data)); + } + public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er)); + } + public static SubMessage ParseFrom(global::System.IO.Stream data) { + return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data)); + } + public static SubMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er)); + } + public static SubMessage ParseFrom(pb::CodedInputStream data) { + return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data)); + } + public static SubMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.ExternalMessage.Types.SubMessage.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.ExternalMessage.Types.SubMessage.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.ExternalMessage.Types.SubMessage.Builder();} + public Builder(_PBJ_Internal.ExternalMessage.Types.SubMessage.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(SubMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public SubMessage BuildPartial() {return new SubMessage(super.BuildPartial());} + public SubMessage Build() {if (_HasAllPBJFields) return new SubMessage(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return SubMessage.Descriptor; } } + public Builder ClearSubuuid() { super.ClearSubuuid();return this;} + public const int SubuuidFieldTag=1; + public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} } + public PBJ.UUID Subuuid{ get { + if (HasSubuuid) { + return PBJ._PBJ.CastUuid(super.Subuuid); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.Subuuid=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearSubvector() { super.ClearSubvector();return this;} + public const int SubvectorFieldTag=2; + public bool HasSubvector{ get {return super.SubvectorCount>=3;} } + public PBJ.Vector3d Subvector{ get { + int index=0; + if (HasSubvector) { + return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + set { + super.ClearSubvector(); + double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); + super.AddSubvector(_PBJtempArray[0]); + super.AddSubvector(_PBJtempArray[1]); + super.AddSubvector(_PBJtempArray[2]); + } + } + public Builder ClearSubduration() { super.ClearSubduration();return this;} + public const int SubdurationFieldTag=3; + public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} } + public PBJ.Duration Subduration{ get { + if (HasSubduration) { + return PBJ._PBJ.CastDuration(super.Subduration); + } else { + return PBJ._PBJ.CastDuration(); + } + } + set { + super.Subduration=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearSubnormal() { super.ClearSubnormal();return this;} + public const int SubnormalFieldTag=4; + public bool HasSubnormal{ get {return super.SubnormalCount>=2;} } + public PBJ.Vector3f Subnormal{ get { + int index=0; + if (HasSubnormal) { + return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1)); + } else { + return PBJ._PBJ.CastNormal(); + } + } + set { + super.ClearSubnormal(); + float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); + super.AddSubnormal(_PBJtempArray[0]); + super.AddSubnormal(_PBJtempArray[1]); + } + } + } + } + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int IsTrueFieldTag=40; + public bool HasIsTrue{ get {return super.HasIsTrue&&PBJ._PBJ.ValidateBool(super.IsTrue);} } + public bool IsTrue{ get { + if (HasIsTrue) { + return PBJ._PBJ.CastBool(super.IsTrue); + } else { + return true; + } + } + } + public const int V2FFieldTag=2; + public bool HasV2F{ get {return super.V2FCount>=2;} } + public PBJ.Vector2f V2F{ get { + int index=0; + if (HasV2F) { + return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1)); + } else { + return PBJ._PBJ.CastVector2f(); + } + } + } + public const int SubMesFieldTag=30; + public bool HasSubMes{ get {return super.HasSubMes;} } + public Types.SubMessage SubMes{ get { + if (HasSubMes) { + return new Types.SubMessage(super.SubMes); + } else { + return new Types.SubMessage(); + } + } + } + public const int SubmessersFieldTag=31; + public int SubmessersCount { get { return super.SubmessersCount;} } + public bool HasSubmessers(int index) {return true;} + public Types.SubMessage Submessers(int index) { + return new Types.SubMessage(super.GetSubmessers(index)); + } + public const int ShaFieldTag=32; + public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} } + public PBJ.SHA256 Sha{ get { + if (HasSha) { + return PBJ._PBJ.CastSha256(super.Sha); + } else { + return PBJ._PBJ.CastSha256(); + } + } + } + public const int ShasFieldTag=33; + public int ShasCount { get { return super.ShasCount;} } + public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));} + public PBJ.SHA256 Shas(int index) { + return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index)); + } + public const int V3FFieldTag=4; + public bool HasV3F{ get {return super.V3FCount>=3;} } + public PBJ.Vector3f V3F{ get { + int index=0; + if (HasV3F) { + return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + } + public const int V3FfFieldTag=5; + public int V3FfCount { get { return super.V3FfCount/3;} } + public bool HasV3Ff(int index) { return true; } + public PBJ.Vector3f GetV3Ff(int index) { + if (HasV3Ff(index)) { + return PBJ._PBJ.CastVector3f(super.GetV3Ff(index*3+0),super.GetV3Ff(index*3+1),super.GetV3Ff(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(ExternalMessage prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static ExternalMessage ParseFrom(pb::ByteString data) { + return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data)); + } + public static ExternalMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er)); + } + public static ExternalMessage ParseFrom(byte[] data) { + return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data)); + } + public static ExternalMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er)); + } + public static ExternalMessage ParseFrom(global::System.IO.Stream data) { + return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data)); + } + public static ExternalMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er)); + } + public static ExternalMessage ParseFrom(pb::CodedInputStream data) { + return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data)); + } + public static ExternalMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + &&HasV3F + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + &&HasV3F + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.ExternalMessage.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.ExternalMessage.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.ExternalMessage.Builder();} + public Builder(_PBJ_Internal.ExternalMessage.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(ExternalMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public ExternalMessage BuildPartial() {return new ExternalMessage(super.BuildPartial());} + public ExternalMessage Build() {if (_HasAllPBJFields) return new ExternalMessage(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return ExternalMessage.Descriptor; } } + public Builder ClearIsTrue() { super.ClearIsTrue();return this;} + public const int IsTrueFieldTag=40; + public bool HasIsTrue{ get {return super.HasIsTrue&&PBJ._PBJ.ValidateBool(super.IsTrue);} } + public bool IsTrue{ get { + if (HasIsTrue) { + return PBJ._PBJ.CastBool(super.IsTrue); + } else { + return true; + } + } + set { + super.IsTrue=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearV2F() { super.ClearV2F();return this;} + public const int V2FFieldTag=2; + public bool HasV2F{ get {return super.V2FCount>=2;} } + public PBJ.Vector2f V2F{ get { + int index=0; + if (HasV2F) { + return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1)); + } else { + return PBJ._PBJ.CastVector2f(); + } + } + set { + super.ClearV2F(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector2f(value); + super.AddV2F(_PBJtempArray[0]); + super.AddV2F(_PBJtempArray[1]); + } + } + public Builder ClearSubMes() { super.ClearSubMes();return this;} + public const int SubMesFieldTag=30; + public bool HasSubMes{ get {return super.HasSubMes;} } + public Types.SubMessage SubMes{ get { + if (HasSubMes) { + return new Types.SubMessage(super.SubMes); + } else { + return new Types.SubMessage(); + } + } + set { + super.SubMes=value._PBJSuper; + } + } + public Builder ClearSubmessers() { super.ClearSubmessers();return this;} + public Builder SetSubmessers(int index,Types.SubMessage value) { + super.SetSubmessers(index,value._PBJSuper); + return this; + } + public const int SubmessersFieldTag=31; + public int SubmessersCount { get { return super.SubmessersCount;} } + public bool HasSubmessers(int index) {return true;} + public Types.SubMessage Submessers(int index) { + return new Types.SubMessage(super.GetSubmessers(index)); + } + public Builder AddSubmessers(Types.SubMessage value ) { + super.AddSubmessers(value._PBJSuper); + return this; + } + public Builder ClearSha() { super.ClearSha();return this;} + public const int ShaFieldTag=32; + public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} } + public PBJ.SHA256 Sha{ get { + if (HasSha) { + return PBJ._PBJ.CastSha256(super.Sha); + } else { + return PBJ._PBJ.CastSha256(); + } + } + set { + super.Sha=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearShas() { super.ClearShas();return this;} + public Builder SetShas(int index, PBJ.SHA256 value) { + super.SetShas(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int ShasFieldTag=33; + public int ShasCount { get { return super.ShasCount;} } + public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));} + public PBJ.SHA256 Shas(int index) { + return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index)); + } + public Builder AddShas(PBJ.SHA256 value) { + super.AddShas(PBJ._PBJ.Construct(value)); + return this; + } + public Builder ClearV3F() { super.ClearV3F();return this;} + public const int V3FFieldTag=4; + public bool HasV3F{ get {return super.V3FCount>=3;} } + public PBJ.Vector3f V3F{ get { + int index=0; + if (HasV3F) { + return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + set { + super.ClearV3F(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.AddV3F(_PBJtempArray[0]); + super.AddV3F(_PBJtempArray[1]); + super.AddV3F(_PBJtempArray[2]); + } + } + public Builder ClearV3Ff() { super.ClearV3Ff();return this;} + public const int V3FfFieldTag=5; + public int V3FfCount { get { return super.V3FfCount/3;} } + public bool HasV3Ff(int index) { return true; } + public PBJ.Vector3f GetV3Ff(int index) { + if (HasV3Ff(index)) { + return PBJ._PBJ.CastVector3f(super.GetV3Ff(index*3+0),super.GetV3Ff(index*3+1),super.GetV3Ff(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + public Builder AddV3Ff(PBJ.Vector3f value) { + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.AddV3Ff(_PBJtempArray[0]); + super.AddV3Ff(_PBJtempArray[1]); + super.AddV3Ff(_PBJtempArray[2]); + return this; + } + public Builder SetV3Ff(int index,PBJ.Vector3f value) { + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.SetV3Ff(index*3+0,_PBJtempArray[0]); + super.SetV3Ff(index*3+1,_PBJtempArray[1]); + super.SetV3Ff(index*3+2,_PBJtempArray[2]); + return this; + } + } + } +} +namespace Sirikata.PB { + public class TestMessage : PBJ.IMessage { + protected _PBJ_Internal.TestMessage super; + public _PBJ_Internal.TestMessage _PBJSuper{ get { return super;} } + public TestMessage() { + super=new _PBJ_Internal.TestMessage(); + } + public TestMessage(_PBJ_Internal.TestMessage reference) { + super=reference; + } + public static TestMessage defaultInstance= new TestMessage (_PBJ_Internal.TestMessage.DefaultInstance); + public static TestMessage DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.TestMessage.Descriptor; } } + public static class Types { + public enum Flagsf32 { + UNIVERSA=_PBJ_Internal.TestMessage.Types.Flagsf32.UNIVERSA, + WE=_PBJ_Internal.TestMessage.Types.Flagsf32.WE, + IMAGE=_PBJ_Internal.TestMessage.Types.Flagsf32.IMAGE, + LOCA=_PBJ_Internal.TestMessage.Types.Flagsf32.LOCA + }; + public enum Flagsf64 { + UNIVERSAL=_PBJ_Internal.TestMessage.Types.Flagsf64.UNIVERSAL, + WEB=_PBJ_Internal.TestMessage.Types.Flagsf64.WEB, + IMAGES=_PBJ_Internal.TestMessage.Types.Flagsf64.IMAGES, + LOCAL=_PBJ_Internal.TestMessage.Types.Flagsf64.LOCAL + }; + public enum Enum32 { + UNIVERSAL1=_PBJ_Internal.TestMessage.Types.Enum32.UNIVERSAL1, + WEB1=_PBJ_Internal.TestMessage.Types.Enum32.WEB1, + IMAGES1=_PBJ_Internal.TestMessage.Types.Enum32.IMAGES1, + LOCAL1=_PBJ_Internal.TestMessage.Types.Enum32.LOCAL1 + }; + public class SubMessage : PBJ.IMessage { + protected _PBJ_Internal.TestMessage.Types.SubMessage super; + public _PBJ_Internal.TestMessage.Types.SubMessage _PBJSuper{ get { return super;} } + public SubMessage() { + super=new _PBJ_Internal.TestMessage.Types.SubMessage(); + } + public SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage reference) { + super=reference; + } + public static SubMessage defaultInstance= new SubMessage (_PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance); + public static SubMessage DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.TestMessage.Types.SubMessage.Descriptor; } } + public static class Types { + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int SubuuidFieldTag=1; + public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} } + public PBJ.UUID Subuuid{ get { + if (HasSubuuid) { + return PBJ._PBJ.CastUuid(super.Subuuid); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int SubvectorFieldTag=2; + public bool HasSubvector{ get {return super.SubvectorCount>=3;} } + public PBJ.Vector3d Subvector{ get { + int index=0; + if (HasSubvector) { + return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + } + public const int SubdurationFieldTag=3; + public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} } + public PBJ.Duration Subduration{ get { + if (HasSubduration) { + return PBJ._PBJ.CastDuration(super.Subduration); + } else { + return PBJ._PBJ.CastDuration(); + } + } + } + public const int SubnormalFieldTag=4; + public bool HasSubnormal{ get {return super.SubnormalCount>=2;} } + public PBJ.Vector3f Subnormal{ get { + int index=0; + if (HasSubnormal) { + return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1)); + } else { + return PBJ._PBJ.CastNormal(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(SubMessage prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static SubMessage ParseFrom(pb::ByteString data) { + return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data)); + } + public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er)); + } + public static SubMessage ParseFrom(byte[] data) { + return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data)); + } + public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er)); + } + public static SubMessage ParseFrom(global::System.IO.Stream data) { + return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data)); + } + public static SubMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er)); + } + public static SubMessage ParseFrom(pb::CodedInputStream data) { + return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data)); + } + public static SubMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.TestMessage.Types.SubMessage.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.TestMessage.Types.SubMessage.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.TestMessage.Types.SubMessage.Builder();} + public Builder(_PBJ_Internal.TestMessage.Types.SubMessage.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(SubMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public SubMessage BuildPartial() {return new SubMessage(super.BuildPartial());} + public SubMessage Build() {if (_HasAllPBJFields) return new SubMessage(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return SubMessage.Descriptor; } } + public Builder ClearSubuuid() { super.ClearSubuuid();return this;} + public const int SubuuidFieldTag=1; + public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} } + public PBJ.UUID Subuuid{ get { + if (HasSubuuid) { + return PBJ._PBJ.CastUuid(super.Subuuid); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.Subuuid=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearSubvector() { super.ClearSubvector();return this;} + public const int SubvectorFieldTag=2; + public bool HasSubvector{ get {return super.SubvectorCount>=3;} } + public PBJ.Vector3d Subvector{ get { + int index=0; + if (HasSubvector) { + return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + set { + super.ClearSubvector(); + double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); + super.AddSubvector(_PBJtempArray[0]); + super.AddSubvector(_PBJtempArray[1]); + super.AddSubvector(_PBJtempArray[2]); + } + } + public Builder ClearSubduration() { super.ClearSubduration();return this;} + public const int SubdurationFieldTag=3; + public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} } + public PBJ.Duration Subduration{ get { + if (HasSubduration) { + return PBJ._PBJ.CastDuration(super.Subduration); + } else { + return PBJ._PBJ.CastDuration(); + } + } + set { + super.Subduration=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearSubnormal() { super.ClearSubnormal();return this;} + public const int SubnormalFieldTag=4; + public bool HasSubnormal{ get {return super.SubnormalCount>=2;} } + public PBJ.Vector3f Subnormal{ get { + int index=0; + if (HasSubnormal) { + return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1)); + } else { + return PBJ._PBJ.CastNormal(); + } + } + set { + super.ClearSubnormal(); + float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); + super.AddSubnormal(_PBJtempArray[0]); + super.AddSubnormal(_PBJtempArray[1]); + } + } + } + } + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false; + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false||(field_tag>=100&&field_tag<=199); + } + public const int XxdFieldTag=20; + public bool HasXxd{ get {return super.HasXxd&&PBJ._PBJ.ValidateDouble(super.Xxd);} } + public double Xxd{ get { + if (HasXxd) { + return PBJ._PBJ.CastDouble(super.Xxd); + } else { + return 10.3; + } + } + } + public const int XxfFieldTag=21; + public bool HasXxf{ get {return super.HasXxf&&PBJ._PBJ.ValidateFloat(super.Xxf);} } + public float Xxf{ get { + if (HasXxf) { + return PBJ._PBJ.CastFloat(super.Xxf); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int Xxu32FieldTag=22; + public bool HasXxu32{ get {return super.HasXxu32&&PBJ._PBJ.ValidateUint32(super.Xxu32);} } + public uint Xxu32{ get { + if (HasXxu32) { + return PBJ._PBJ.CastUint32(super.Xxu32); + } else { + return PBJ._PBJ.CastUint32(); + } + } + } + public const int XxsFieldTag=23; + public bool HasXxs{ get {return super.HasXxs&&PBJ._PBJ.ValidateString(super.Xxs);} } + public string Xxs{ get { + if (HasXxs) { + return PBJ._PBJ.CastString(super.Xxs); + } else { + return PBJ._PBJ.CastString(); + } + } + } + public const int XxbFieldTag=24; + public bool HasXxb{ get {return super.HasXxb&&PBJ._PBJ.ValidateBytes(super.Xxb);} } + public pb::ByteString Xxb{ get { + if (HasXxb) { + return PBJ._PBJ.CastBytes(super.Xxb); + } else { + return PBJ._PBJ.CastBytes(); + } + } + } + public const int XxssFieldTag=25; + public int XxssCount { get { return super.XxssCount;} } + public bool HasXxss(int index) {return PBJ._PBJ.ValidateString(super.GetXxss(index));} + public string Xxss(int index) { + return (string)PBJ._PBJ.CastString(super.GetXxss(index)); + } + public const int XxbbFieldTag=26; + public int XxbbCount { get { return super.XxbbCount;} } + public bool HasXxbb(int index) {return PBJ._PBJ.ValidateBytes(super.GetXxbb(index));} + public pb::ByteString Xxbb(int index) { + return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetXxbb(index)); + } + public const int XxffFieldTag=27; + public int XxffCount { get { return super.XxffCount;} } + public bool HasXxff(int index) {return PBJ._PBJ.ValidateFloat(super.GetXxff(index));} + public float Xxff(int index) { + return (float)PBJ._PBJ.CastFloat(super.GetXxff(index)); + } + public const int XxnnFieldTag=29; + public int XxnnCount { get { return super.XxnnCount/2;} } + public bool HasXxnn(int index) { return true; } + public PBJ.Vector3f GetXxnn(int index) { + if (HasXxnn(index)) { + return PBJ._PBJ.CastNormal(super.GetXxnn(index*2+0),super.GetXxnn(index*2+1)); + } else { + return PBJ._PBJ.CastNormal(); + } + } + public const int XxfrFieldTag=28; + public bool HasXxfr{ get {return super.HasXxfr&&PBJ._PBJ.ValidateFloat(super.Xxfr);} } + public float Xxfr{ get { + if (HasXxfr) { + return PBJ._PBJ.CastFloat(super.Xxfr); + } else { + return PBJ._PBJ.CastFloat(); + } + } + } + public const int NFieldTag=1; + public bool HasN{ get {return super.NCount>=2;} } + public PBJ.Vector3f N{ get { + int index=0; + if (HasN) { + return PBJ._PBJ.CastNormal(super.GetN(index*2+0),super.GetN(index*2+1)); + } else { + return PBJ._PBJ.CastNormal(); + } + } + } + public const int V2FFieldTag=2; + public bool HasV2F{ get {return super.V2FCount>=2;} } + public PBJ.Vector2f V2F{ get { + int index=0; + if (HasV2F) { + return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1)); + } else { + return PBJ._PBJ.CastVector2f(); + } + } + } + public const int V2DFieldTag=3; + public bool HasV2D{ get {return super.V2DCount>=2;} } + public PBJ.Vector2d V2D{ get { + int index=0; + if (HasV2D) { + return PBJ._PBJ.CastVector2d(super.GetV2D(index*2+0),super.GetV2D(index*2+1)); + } else { + return PBJ._PBJ.CastVector2d(); + } + } + } + public const int V3FFieldTag=4; + public bool HasV3F{ get {return super.V3FCount>=3;} } + public PBJ.Vector3f V3F{ get { + int index=0; + if (HasV3F) { + return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + } + public const int V3DFieldTag=5; + public bool HasV3D{ get {return super.V3DCount>=3;} } + public PBJ.Vector3d V3D{ get { + int index=0; + if (HasV3D) { + return PBJ._PBJ.CastVector3d(super.GetV3D(index*3+0),super.GetV3D(index*3+1),super.GetV3D(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + } + public const int V4FFieldTag=6; + public bool HasV4F{ get {return super.V4FCount>=4;} } + public PBJ.Vector4f V4F{ get { + int index=0; + if (HasV4F) { + return PBJ._PBJ.CastVector4f(super.GetV4F(index*4+0),super.GetV4F(index*4+1),super.GetV4F(index*4+2),super.GetV4F(index*4+3)); + } else { + return PBJ._PBJ.CastVector4f(); + } + } + } + public const int V4DFieldTag=7; + public bool HasV4D{ get {return super.V4DCount>=4;} } + public PBJ.Vector4d V4D{ get { + int index=0; + if (HasV4D) { + return PBJ._PBJ.CastVector4d(super.GetV4D(index*4+0),super.GetV4D(index*4+1),super.GetV4D(index*4+2),super.GetV4D(index*4+3)); + } else { + return PBJ._PBJ.CastVector4d(); + } + } + } + public const int QFieldTag=8; + public bool HasQ{ get {return super.QCount>=3;} } + public PBJ.Quaternion Q{ get { + int index=0; + if (HasQ) { + return PBJ._PBJ.CastQuaternion(super.GetQ(index*3+0),super.GetQ(index*3+1),super.GetQ(index*3+2)); + } else { + return PBJ._PBJ.CastQuaternion(); + } + } + } + public const int UFieldTag=9; + public bool HasU{ get {return super.HasU&&PBJ._PBJ.ValidateUuid(super.U);} } + public PBJ.UUID U{ get { + if (HasU) { + return PBJ._PBJ.CastUuid(super.U); + } else { + return PBJ._PBJ.CastUuid(); + } + } + } + public const int AFieldTag=10; + public bool HasA{ get {return super.HasA&&PBJ._PBJ.ValidateAngle(super.A);} } + public float A{ get { + if (HasA) { + return PBJ._PBJ.CastAngle(super.A); + } else { + return PBJ._PBJ.CastAngle(); + } + } + } + public const int TFieldTag=11; + public bool HasT{ get {return super.HasT&&PBJ._PBJ.ValidateTime(super.T);} } + public PBJ.Time T{ get { + if (HasT) { + return PBJ._PBJ.CastTime(super.T); + } else { + return PBJ._PBJ.CastTime(); + } + } + } + public const int DFieldTag=12; + public bool HasD{ get {return super.HasD&&PBJ._PBJ.ValidateDuration(super.D);} } + public PBJ.Duration D{ get { + if (HasD) { + return PBJ._PBJ.CastDuration(super.D); + } else { + return PBJ._PBJ.CastDuration(); + } + } + } + public const int F32FieldTag=13; + public bool HasF32 { get { + if (!super.HasF32) return false; + return PBJ._PBJ.ValidateFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA); + } } + public uint F32{ get { + if (HasF32) { + return (uint)PBJ._PBJ.CastFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA); + } else { + return (uint)PBJ._PBJ.CastFlags((ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA); + } + } + } + public const int F64FieldTag=14; + public bool HasF64 { get { + if (!super.HasF64) return false; + return PBJ._PBJ.ValidateFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL); + } } + public ulong F64{ get { + if (HasF64) { + return (ulong)PBJ._PBJ.CastFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL); + } else { + return (ulong)PBJ._PBJ.CastFlags((ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL); + } + } + } + public const int BsfFieldTag=15; + public bool HasBsf{ get {return super.BsfCount>=4;} } + public PBJ.BoundingSphere3f Bsf{ get { + int index=0; + if (HasBsf) { + return PBJ._PBJ.CastBoundingsphere3f(super.GetBsf(index*4+0),super.GetBsf(index*4+1),super.GetBsf(index*4+2),super.GetBsf(index*4+3)); + } else { + return PBJ._PBJ.CastBoundingsphere3f(); + } + } + } + public const int BsdFieldTag=16; + public bool HasBsd{ get {return super.BsdCount>=4;} } + public PBJ.BoundingSphere3d Bsd{ get { + int index=0; + if (HasBsd) { + return PBJ._PBJ.CastBoundingsphere3d(super.GetBsd(index*4+0),super.GetBsd(index*4+1),super.GetBsd(index*4+2),super.GetBsd(index*4+3)); + } else { + return PBJ._PBJ.CastBoundingsphere3d(); + } + } + } + public const int BbfFieldTag=17; + public bool HasBbf{ get {return super.BbfCount>=6;} } + public PBJ.BoundingBox3f3f Bbf{ get { + int index=0; + if (HasBbf) { + return PBJ._PBJ.CastBoundingbox3f3f(super.GetBbf(index*6+0),super.GetBbf(index*6+1),super.GetBbf(index*6+2),super.GetBbf(index*6+3),super.GetBbf(index*6+4),super.GetBbf(index*6+5)); + } else { + return PBJ._PBJ.CastBoundingbox3f3f(); + } + } + } + public const int BbdFieldTag=18; + public bool HasBbd{ get {return super.BbdCount>=6;} } + public PBJ.BoundingBox3d3f Bbd{ get { + int index=0; + if (HasBbd) { + return PBJ._PBJ.CastBoundingbox3d3f(super.GetBbd(index*6+0),super.GetBbd(index*6+1),super.GetBbd(index*6+2),super.GetBbd(index*6+3),super.GetBbd(index*6+4),super.GetBbd(index*6+5)); + } else { + return PBJ._PBJ.CastBoundingbox3d3f(); + } + } + } + public const int E32FieldTag=19; + public bool HasE32{ get {return super.HasE32;} } + public Types.Enum32 E32{ get { + if (HasE32) { + return (Types.Enum32)super.E32; + } else { + return new Types.Enum32(); + } + } + } + public const int SubmesFieldTag=30; + public bool HasSubmes{ get {return super.HasSubmes;} } + public Types.SubMessage Submes{ get { + if (HasSubmes) { + return new Types.SubMessage(super.Submes); + } else { + return new Types.SubMessage(); + } + } + } + public const int SubmessersFieldTag=31; + public int SubmessersCount { get { return super.SubmessersCount;} } + public bool HasSubmessers(int index) {return true;} + public Types.SubMessage Submessers(int index) { + return new Types.SubMessage(super.GetSubmessers(index)); + } + public const int ShaFieldTag=32; + public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} } + public PBJ.SHA256 Sha{ get { + if (HasSha) { + return PBJ._PBJ.CastSha256(super.Sha); + } else { + return PBJ._PBJ.CastSha256(); + } + } + } + public const int ShasFieldTag=33; + public int ShasCount { get { return super.ShasCount;} } + public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));} + public PBJ.SHA256 Shas(int index) { + return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index)); + } + public const int ExtmesFieldTag=34; + public bool HasExtmes{ get {return super.HasExtmes;} } + public ExternalMessage Extmes{ get { + if (HasExtmes) { + return new ExternalMessage(super.Extmes); + } else { + return new ExternalMessage(); + } + } + } + public const int ExtmessersFieldTag=35; + public int ExtmessersCount { get { return super.ExtmessersCount;} } + public bool HasExtmessers(int index) {return true;} + public ExternalMessage Extmessers(int index) { + return new ExternalMessage(super.GetExtmessers(index)); + } + public const int ExtmesserFieldTag=36; + public bool HasExtmesser{ get {return super.HasExtmesser;} } + public ExternalMessage Extmesser{ get { + if (HasExtmesser) { + return new ExternalMessage(super.Extmesser); + } else { + return new ExternalMessage(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(TestMessage prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static TestMessage ParseFrom(pb::ByteString data) { + return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data)); + } + public static TestMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er)); + } + public static TestMessage ParseFrom(byte[] data) { + return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data)); + } + public static TestMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er)); + } + public static TestMessage ParseFrom(global::System.IO.Stream data) { + return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data)); + } + public static TestMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er)); + } + public static TestMessage ParseFrom(pb::CodedInputStream data) { + return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data)); + } + public static TestMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + &&HasV3F + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + &&HasV3F + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.TestMessage.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.TestMessage.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.TestMessage.Builder();} + public Builder(_PBJ_Internal.TestMessage.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(TestMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public TestMessage BuildPartial() {return new TestMessage(super.BuildPartial());} + public TestMessage Build() {if (_HasAllPBJFields) return new TestMessage(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return TestMessage.Descriptor; } } + public Builder ClearXxd() { super.ClearXxd();return this;} + public const int XxdFieldTag=20; + public bool HasXxd{ get {return super.HasXxd&&PBJ._PBJ.ValidateDouble(super.Xxd);} } + public double Xxd{ get { + if (HasXxd) { + return PBJ._PBJ.CastDouble(super.Xxd); + } else { + return 10.3; + } + } + set { + super.Xxd=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearXxf() { super.ClearXxf();return this;} + public const int XxfFieldTag=21; + public bool HasXxf{ get {return super.HasXxf&&PBJ._PBJ.ValidateFloat(super.Xxf);} } + public float Xxf{ get { + if (HasXxf) { + return PBJ._PBJ.CastFloat(super.Xxf); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.Xxf=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearXxu32() { super.ClearXxu32();return this;} + public const int Xxu32FieldTag=22; + public bool HasXxu32{ get {return super.HasXxu32&&PBJ._PBJ.ValidateUint32(super.Xxu32);} } + public uint Xxu32{ get { + if (HasXxu32) { + return PBJ._PBJ.CastUint32(super.Xxu32); + } else { + return PBJ._PBJ.CastUint32(); + } + } + set { + super.Xxu32=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearXxs() { super.ClearXxs();return this;} + public const int XxsFieldTag=23; + public bool HasXxs{ get {return super.HasXxs&&PBJ._PBJ.ValidateString(super.Xxs);} } + public string Xxs{ get { + if (HasXxs) { + return PBJ._PBJ.CastString(super.Xxs); + } else { + return PBJ._PBJ.CastString(); + } + } + set { + super.Xxs=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearXxb() { super.ClearXxb();return this;} + public const int XxbFieldTag=24; + public bool HasXxb{ get {return super.HasXxb&&PBJ._PBJ.ValidateBytes(super.Xxb);} } + public pb::ByteString Xxb{ get { + if (HasXxb) { + return PBJ._PBJ.CastBytes(super.Xxb); + } else { + return PBJ._PBJ.CastBytes(); + } + } + set { + super.Xxb=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearXxss() { super.ClearXxss();return this;} + public Builder SetXxss(int index, string value) { + super.SetXxss(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int XxssFieldTag=25; + public int XxssCount { get { return super.XxssCount;} } + public bool HasXxss(int index) {return PBJ._PBJ.ValidateString(super.GetXxss(index));} + public string Xxss(int index) { + return (string)PBJ._PBJ.CastString(super.GetXxss(index)); + } + public Builder AddXxss(string value) { + super.AddXxss(PBJ._PBJ.Construct(value)); + return this; + } + public Builder ClearXxbb() { super.ClearXxbb();return this;} + public Builder SetXxbb(int index, pb::ByteString value) { + super.SetXxbb(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int XxbbFieldTag=26; + public int XxbbCount { get { return super.XxbbCount;} } + public bool HasXxbb(int index) {return PBJ._PBJ.ValidateBytes(super.GetXxbb(index));} + public pb::ByteString Xxbb(int index) { + return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetXxbb(index)); + } + public Builder AddXxbb(pb::ByteString value) { + super.AddXxbb(PBJ._PBJ.Construct(value)); + return this; + } + public Builder ClearXxff() { super.ClearXxff();return this;} + public Builder SetXxff(int index, float value) { + super.SetXxff(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int XxffFieldTag=27; + public int XxffCount { get { return super.XxffCount;} } + public bool HasXxff(int index) {return PBJ._PBJ.ValidateFloat(super.GetXxff(index));} + public float Xxff(int index) { + return (float)PBJ._PBJ.CastFloat(super.GetXxff(index)); + } + public Builder AddXxff(float value) { + super.AddXxff(PBJ._PBJ.Construct(value)); + return this; + } + public Builder ClearXxnn() { super.ClearXxnn();return this;} + public const int XxnnFieldTag=29; + public int XxnnCount { get { return super.XxnnCount/2;} } + public bool HasXxnn(int index) { return true; } + public PBJ.Vector3f GetXxnn(int index) { + if (HasXxnn(index)) { + return PBJ._PBJ.CastNormal(super.GetXxnn(index*2+0),super.GetXxnn(index*2+1)); + } else { + return PBJ._PBJ.CastNormal(); + } + } + public Builder AddXxnn(PBJ.Vector3f value) { + float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); + super.AddXxnn(_PBJtempArray[0]); + super.AddXxnn(_PBJtempArray[1]); + return this; + } + public Builder SetXxnn(int index,PBJ.Vector3f value) { + float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); + super.SetXxnn(index*2+0,_PBJtempArray[0]); + super.SetXxnn(index*2+1,_PBJtempArray[1]); + return this; + } + public Builder ClearXxfr() { super.ClearXxfr();return this;} + public const int XxfrFieldTag=28; + public bool HasXxfr{ get {return super.HasXxfr&&PBJ._PBJ.ValidateFloat(super.Xxfr);} } + public float Xxfr{ get { + if (HasXxfr) { + return PBJ._PBJ.CastFloat(super.Xxfr); + } else { + return PBJ._PBJ.CastFloat(); + } + } + set { + super.Xxfr=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearN() { super.ClearN();return this;} + public const int NFieldTag=1; + public bool HasN{ get {return super.NCount>=2;} } + public PBJ.Vector3f N{ get { + int index=0; + if (HasN) { + return PBJ._PBJ.CastNormal(super.GetN(index*2+0),super.GetN(index*2+1)); + } else { + return PBJ._PBJ.CastNormal(); + } + } + set { + super.ClearN(); + float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); + super.AddN(_PBJtempArray[0]); + super.AddN(_PBJtempArray[1]); + } + } + public Builder ClearV2F() { super.ClearV2F();return this;} + public const int V2FFieldTag=2; + public bool HasV2F{ get {return super.V2FCount>=2;} } + public PBJ.Vector2f V2F{ get { + int index=0; + if (HasV2F) { + return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1)); + } else { + return PBJ._PBJ.CastVector2f(); + } + } + set { + super.ClearV2F(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector2f(value); + super.AddV2F(_PBJtempArray[0]); + super.AddV2F(_PBJtempArray[1]); + } + } + public Builder ClearV2D() { super.ClearV2D();return this;} + public const int V2DFieldTag=3; + public bool HasV2D{ get {return super.V2DCount>=2;} } + public PBJ.Vector2d V2D{ get { + int index=0; + if (HasV2D) { + return PBJ._PBJ.CastVector2d(super.GetV2D(index*2+0),super.GetV2D(index*2+1)); + } else { + return PBJ._PBJ.CastVector2d(); + } + } + set { + super.ClearV2D(); + double[] _PBJtempArray=PBJ._PBJ.ConstructVector2d(value); + super.AddV2D(_PBJtempArray[0]); + super.AddV2D(_PBJtempArray[1]); + } + } + public Builder ClearV3F() { super.ClearV3F();return this;} + public const int V3FFieldTag=4; + public bool HasV3F{ get {return super.V3FCount>=3;} } + public PBJ.Vector3f V3F{ get { + int index=0; + if (HasV3F) { + return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2)); + } else { + return PBJ._PBJ.CastVector3f(); + } + } + set { + super.ClearV3F(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); + super.AddV3F(_PBJtempArray[0]); + super.AddV3F(_PBJtempArray[1]); + super.AddV3F(_PBJtempArray[2]); + } + } + public Builder ClearV3D() { super.ClearV3D();return this;} + public const int V3DFieldTag=5; + public bool HasV3D{ get {return super.V3DCount>=3;} } + public PBJ.Vector3d V3D{ get { + int index=0; + if (HasV3D) { + return PBJ._PBJ.CastVector3d(super.GetV3D(index*3+0),super.GetV3D(index*3+1),super.GetV3D(index*3+2)); + } else { + return PBJ._PBJ.CastVector3d(); + } + } + set { + super.ClearV3D(); + double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); + super.AddV3D(_PBJtempArray[0]); + super.AddV3D(_PBJtempArray[1]); + super.AddV3D(_PBJtempArray[2]); + } + } + public Builder ClearV4F() { super.ClearV4F();return this;} + public const int V4FFieldTag=6; + public bool HasV4F{ get {return super.V4FCount>=4;} } + public PBJ.Vector4f V4F{ get { + int index=0; + if (HasV4F) { + return PBJ._PBJ.CastVector4f(super.GetV4F(index*4+0),super.GetV4F(index*4+1),super.GetV4F(index*4+2),super.GetV4F(index*4+3)); + } else { + return PBJ._PBJ.CastVector4f(); + } + } + set { + super.ClearV4F(); + float[] _PBJtempArray=PBJ._PBJ.ConstructVector4f(value); + super.AddV4F(_PBJtempArray[0]); + super.AddV4F(_PBJtempArray[1]); + super.AddV4F(_PBJtempArray[2]); + super.AddV4F(_PBJtempArray[3]); + } + } + public Builder ClearV4D() { super.ClearV4D();return this;} + public const int V4DFieldTag=7; + public bool HasV4D{ get {return super.V4DCount>=4;} } + public PBJ.Vector4d V4D{ get { + int index=0; + if (HasV4D) { + return PBJ._PBJ.CastVector4d(super.GetV4D(index*4+0),super.GetV4D(index*4+1),super.GetV4D(index*4+2),super.GetV4D(index*4+3)); + } else { + return PBJ._PBJ.CastVector4d(); + } + } + set { + super.ClearV4D(); + double[] _PBJtempArray=PBJ._PBJ.ConstructVector4d(value); + super.AddV4D(_PBJtempArray[0]); + super.AddV4D(_PBJtempArray[1]); + super.AddV4D(_PBJtempArray[2]); + super.AddV4D(_PBJtempArray[3]); + } + } + public Builder ClearQ() { super.ClearQ();return this;} + public const int QFieldTag=8; + public bool HasQ{ get {return super.QCount>=3;} } + public PBJ.Quaternion Q{ get { + int index=0; + if (HasQ) { + return PBJ._PBJ.CastQuaternion(super.GetQ(index*3+0),super.GetQ(index*3+1),super.GetQ(index*3+2)); + } else { + return PBJ._PBJ.CastQuaternion(); + } + } + set { + super.ClearQ(); + float[] _PBJtempArray=PBJ._PBJ.ConstructQuaternion(value); + super.AddQ(_PBJtempArray[0]); + super.AddQ(_PBJtempArray[1]); + super.AddQ(_PBJtempArray[2]); + } + } + public Builder ClearU() { super.ClearU();return this;} + public const int UFieldTag=9; + public bool HasU{ get {return super.HasU&&PBJ._PBJ.ValidateUuid(super.U);} } + public PBJ.UUID U{ get { + if (HasU) { + return PBJ._PBJ.CastUuid(super.U); + } else { + return PBJ._PBJ.CastUuid(); + } + } + set { + super.U=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearA() { super.ClearA();return this;} + public const int AFieldTag=10; + public bool HasA{ get {return super.HasA&&PBJ._PBJ.ValidateAngle(super.A);} } + public float A{ get { + if (HasA) { + return PBJ._PBJ.CastAngle(super.A); + } else { + return PBJ._PBJ.CastAngle(); + } + } + set { + super.A=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearT() { super.ClearT();return this;} + public const int TFieldTag=11; + public bool HasT{ get {return super.HasT&&PBJ._PBJ.ValidateTime(super.T);} } + public PBJ.Time T{ get { + if (HasT) { + return PBJ._PBJ.CastTime(super.T); + } else { + return PBJ._PBJ.CastTime(); + } + } + set { + super.T=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearD() { super.ClearD();return this;} + public const int DFieldTag=12; + public bool HasD{ get {return super.HasD&&PBJ._PBJ.ValidateDuration(super.D);} } + public PBJ.Duration D{ get { + if (HasD) { + return PBJ._PBJ.CastDuration(super.D); + } else { + return PBJ._PBJ.CastDuration(); + } + } + set { + super.D=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearF32() { super.ClearF32();return this;} + public const int F32FieldTag=13; + public bool HasF32 { get { + if (!super.HasF32) return false; + return PBJ._PBJ.ValidateFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA); + } } + public uint F32{ get { + if (HasF32) { + return (uint)PBJ._PBJ.CastFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA); + } else { + return (uint)PBJ._PBJ.CastFlags((ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA); + } + } + set { + super.F32=((value)); + } + } + public Builder ClearF64() { super.ClearF64();return this;} + public const int F64FieldTag=14; + public bool HasF64 { get { + if (!super.HasF64) return false; + return PBJ._PBJ.ValidateFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL); + } } + public ulong F64{ get { + if (HasF64) { + return (ulong)PBJ._PBJ.CastFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL); + } else { + return (ulong)PBJ._PBJ.CastFlags((ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL); + } + } + set { + super.F64=((value)); + } + } + public Builder ClearBsf() { super.ClearBsf();return this;} + public const int BsfFieldTag=15; + public bool HasBsf{ get {return super.BsfCount>=4;} } + public PBJ.BoundingSphere3f Bsf{ get { + int index=0; + if (HasBsf) { + return PBJ._PBJ.CastBoundingsphere3f(super.GetBsf(index*4+0),super.GetBsf(index*4+1),super.GetBsf(index*4+2),super.GetBsf(index*4+3)); + } else { + return PBJ._PBJ.CastBoundingsphere3f(); + } + } + set { + super.ClearBsf(); + float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value); + super.AddBsf(_PBJtempArray[0]); + super.AddBsf(_PBJtempArray[1]); + super.AddBsf(_PBJtempArray[2]); + super.AddBsf(_PBJtempArray[3]); + } + } + public Builder ClearBsd() { super.ClearBsd();return this;} + public const int BsdFieldTag=16; + public bool HasBsd{ get {return super.BsdCount>=4;} } + public PBJ.BoundingSphere3d Bsd{ get { + int index=0; + if (HasBsd) { + return PBJ._PBJ.CastBoundingsphere3d(super.GetBsd(index*4+0),super.GetBsd(index*4+1),super.GetBsd(index*4+2),super.GetBsd(index*4+3)); + } else { + return PBJ._PBJ.CastBoundingsphere3d(); + } + } + set { + super.ClearBsd(); + double[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3d(value); + super.AddBsd(_PBJtempArray[0]); + super.AddBsd(_PBJtempArray[1]); + super.AddBsd(_PBJtempArray[2]); + super.AddBsd(_PBJtempArray[3]); + } + } + public Builder ClearBbf() { super.ClearBbf();return this;} + public const int BbfFieldTag=17; + public bool HasBbf{ get {return super.BbfCount>=6;} } + public PBJ.BoundingBox3f3f Bbf{ get { + int index=0; + if (HasBbf) { + return PBJ._PBJ.CastBoundingbox3f3f(super.GetBbf(index*6+0),super.GetBbf(index*6+1),super.GetBbf(index*6+2),super.GetBbf(index*6+3),super.GetBbf(index*6+4),super.GetBbf(index*6+5)); + } else { + return PBJ._PBJ.CastBoundingbox3f3f(); + } + } + set { + super.ClearBbf(); + float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingbox3f3f(value); + super.AddBbf(_PBJtempArray[0]); + super.AddBbf(_PBJtempArray[1]); + super.AddBbf(_PBJtempArray[2]); + super.AddBbf(_PBJtempArray[3]); + super.AddBbf(_PBJtempArray[4]); + super.AddBbf(_PBJtempArray[5]); + } + } + public Builder ClearBbd() { super.ClearBbd();return this;} + public const int BbdFieldTag=18; + public bool HasBbd{ get {return super.BbdCount>=6;} } + public PBJ.BoundingBox3d3f Bbd{ get { + int index=0; + if (HasBbd) { + return PBJ._PBJ.CastBoundingbox3d3f(super.GetBbd(index*6+0),super.GetBbd(index*6+1),super.GetBbd(index*6+2),super.GetBbd(index*6+3),super.GetBbd(index*6+4),super.GetBbd(index*6+5)); + } else { + return PBJ._PBJ.CastBoundingbox3d3f(); + } + } + set { + super.ClearBbd(); + double[] _PBJtempArray=PBJ._PBJ.ConstructBoundingbox3d3f(value); + super.AddBbd(_PBJtempArray[0]); + super.AddBbd(_PBJtempArray[1]); + super.AddBbd(_PBJtempArray[2]); + super.AddBbd(_PBJtempArray[3]); + super.AddBbd(_PBJtempArray[4]); + super.AddBbd(_PBJtempArray[5]); + } + } + public Builder ClearE32() { super.ClearE32();return this;} + public const int E32FieldTag=19; + public bool HasE32{ get {return super.HasE32;} } + public Types.Enum32 E32{ get { + if (HasE32) { + return (Types.Enum32)super.E32; + } else { + return new Types.Enum32(); + } + } + set { + super.E32=((_PBJ_Internal.TestMessage.Types.Enum32)value); + } + } + public Builder ClearSubmes() { super.ClearSubmes();return this;} + public const int SubmesFieldTag=30; + public bool HasSubmes{ get {return super.HasSubmes;} } + public Types.SubMessage Submes{ get { + if (HasSubmes) { + return new Types.SubMessage(super.Submes); + } else { + return new Types.SubMessage(); + } + } + set { + super.Submes=value._PBJSuper; + } + } + public Builder ClearSubmessers() { super.ClearSubmessers();return this;} + public Builder SetSubmessers(int index,Types.SubMessage value) { + super.SetSubmessers(index,value._PBJSuper); + return this; + } + public const int SubmessersFieldTag=31; + public int SubmessersCount { get { return super.SubmessersCount;} } + public bool HasSubmessers(int index) {return true;} + public Types.SubMessage Submessers(int index) { + return new Types.SubMessage(super.GetSubmessers(index)); + } + public Builder AddSubmessers(Types.SubMessage value ) { + super.AddSubmessers(value._PBJSuper); + return this; + } + public Builder ClearSha() { super.ClearSha();return this;} + public const int ShaFieldTag=32; + public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} } + public PBJ.SHA256 Sha{ get { + if (HasSha) { + return PBJ._PBJ.CastSha256(super.Sha); + } else { + return PBJ._PBJ.CastSha256(); + } + } + set { + super.Sha=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearShas() { super.ClearShas();return this;} + public Builder SetShas(int index, PBJ.SHA256 value) { + super.SetShas(index,PBJ._PBJ.Construct(value)); + return this; + } + public const int ShasFieldTag=33; + public int ShasCount { get { return super.ShasCount;} } + public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));} + public PBJ.SHA256 Shas(int index) { + return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index)); + } + public Builder AddShas(PBJ.SHA256 value) { + super.AddShas(PBJ._PBJ.Construct(value)); + return this; + } + public Builder ClearExtmes() { super.ClearExtmes();return this;} + public const int ExtmesFieldTag=34; + public bool HasExtmes{ get {return super.HasExtmes;} } + public ExternalMessage Extmes{ get { + if (HasExtmes) { + return new ExternalMessage(super.Extmes); + } else { + return new ExternalMessage(); + } + } + set { + super.Extmes=value._PBJSuper; + } + } + public Builder ClearExtmessers() { super.ClearExtmessers();return this;} + public Builder SetExtmessers(int index,ExternalMessage value) { + super.SetExtmessers(index,value._PBJSuper); + return this; + } + public const int ExtmessersFieldTag=35; + public int ExtmessersCount { get { return super.ExtmessersCount;} } + public bool HasExtmessers(int index) {return true;} + public ExternalMessage Extmessers(int index) { + return new ExternalMessage(super.GetExtmessers(index)); + } + public Builder AddExtmessers(ExternalMessage value ) { + super.AddExtmessers(value._PBJSuper); + return this; + } + public Builder ClearExtmesser() { super.ClearExtmesser();return this;} + public const int ExtmesserFieldTag=36; + public bool HasExtmesser{ get {return super.HasExtmesser;} } + public ExternalMessage Extmesser{ get { + if (HasExtmesser) { + return new ExternalMessage(super.Extmesser); + } else { + return new ExternalMessage(); + } + } + set { + super.Extmesser=value._PBJSuper; + } + } + } + } +} +namespace Sirikata.PB { +} diff --git a/OpenSim/Client/Sirikata/Protocol/Time.cs b/OpenSim/Client/Sirikata/Protocol/Time.cs new file mode 100644 index 0000000..4ad49cc --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Time.cs @@ -0,0 +1,454 @@ +// 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.Network.Protocol._PBJ_Internal { + + public static partial class Time { + + #region Extension registration + public static void RegisterAllExtensions(pb::ExtensionRegistry registry) { + } + #endregion + #region Static variables + internal static pbd::MessageDescriptor internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__FieldAccessorTable; + #endregion + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbd::FileDescriptor descriptor; + + static Time() { + byte[] descriptorData = global::System.Convert.FromBase64String( + "CgpUaW1lLnByb3RvEidTaXJpa2F0YS5OZXR3b3JrLlByb3RvY29sLl9QQkpf" + + "SW50ZXJuYWwirQEKCFRpbWVTeW5jEhMKC2NsaWVudF90aW1lGAkgASgGEhMK" + + "C3NlcnZlcl90aW1lGAogASgGEhIKCnN5bmNfcm91bmQYCyABKAQSFgoOcmV0" + + "dXJuX29wdGlvbnMYDiABKA0SEwoKcm91bmRfdHJpcBiBFCABKAYiNgoNUmV0" + + "dXJuT3B0aW9ucxISCg5SRVBMWV9SRUxJQUJMRRABEhEKDVJFUExZX09SREVS" + + "RUQQAg=="); + pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { + descriptor = root; + internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__Descriptor = Descriptor.MessageTypes[0]; + internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__Descriptor, + new string[] { "ClientTime", "ServerTime", "SyncRound", "ReturnOptions", "RoundTrip", }); + return null; + }; + pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, + new pbd::FileDescriptor[] { + }, assigner); + } + #endregion + + } + #region Messages + public sealed partial class TimeSync : pb::GeneratedMessage { + private static readonly TimeSync defaultInstance = new Builder().BuildPartial(); + public static TimeSync DefaultInstance { + get { return defaultInstance; } + } + + public override TimeSync DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TimeSync ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Network.Protocol._PBJ_Internal.Time.internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Network.Protocol._PBJ_Internal.Time.internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum ReturnOptions { + REPLY_RELIABLE = 1, + REPLY_ORDERED = 2, + } + + } + #endregion + + public const int ClientTimeFieldNumber = 9; + private bool hasClientTime; + private ulong clientTime_ = 0; + public bool HasClientTime { + get { return hasClientTime; } + } + [global::System.CLSCompliant(false)] + public ulong ClientTime { + get { return clientTime_; } + } + + public const int ServerTimeFieldNumber = 10; + private bool hasServerTime; + private ulong serverTime_ = 0; + public bool HasServerTime { + get { return hasServerTime; } + } + [global::System.CLSCompliant(false)] + public ulong ServerTime { + get { return serverTime_; } + } + + public const int SyncRoundFieldNumber = 11; + private bool hasSyncRound; + private ulong syncRound_ = 0UL; + public bool HasSyncRound { + get { return hasSyncRound; } + } + [global::System.CLSCompliant(false)] + public ulong SyncRound { + get { return syncRound_; } + } + + public const int ReturnOptionsFieldNumber = 14; + private bool hasReturnOptions; + private uint returnOptions_ = 0; + public bool HasReturnOptions { + get { return hasReturnOptions; } + } + [global::System.CLSCompliant(false)] + public uint ReturnOptions { + get { return returnOptions_; } + } + + public const int RoundTripFieldNumber = 2561; + private bool hasRoundTrip; + private ulong roundTrip_ = 0; + public bool HasRoundTrip { + get { return hasRoundTrip; } + } + [global::System.CLSCompliant(false)] + public ulong RoundTrip { + get { return roundTrip_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasClientTime) { + output.WriteFixed64(9, ClientTime); + } + if (HasServerTime) { + output.WriteFixed64(10, ServerTime); + } + if (HasSyncRound) { + output.WriteUInt64(11, SyncRound); + } + if (HasReturnOptions) { + output.WriteUInt32(14, ReturnOptions); + } + if (HasRoundTrip) { + output.WriteFixed64(2561, RoundTrip); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasClientTime) { + size += pb::CodedOutputStream.ComputeFixed64Size(9, ClientTime); + } + if (HasServerTime) { + size += pb::CodedOutputStream.ComputeFixed64Size(10, ServerTime); + } + if (HasSyncRound) { + size += pb::CodedOutputStream.ComputeUInt64Size(11, SyncRound); + } + if (HasReturnOptions) { + size += pb::CodedOutputStream.ComputeUInt32Size(14, ReturnOptions); + } + if (HasRoundTrip) { + size += pb::CodedOutputStream.ComputeFixed64Size(2561, RoundTrip); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TimeSync ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TimeSync ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TimeSync ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TimeSync ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TimeSync ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TimeSync ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TimeSync ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static TimeSync ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static TimeSync ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TimeSync 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(TimeSync prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TimeSync result = new TimeSync(); + + protected override TimeSync MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TimeSync(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.Descriptor; } + } + + public override TimeSync DefaultInstanceForType { + get { return global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.DefaultInstance; } + } + + public override TimeSync BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + TimeSync returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TimeSync) { + return MergeFrom((TimeSync) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TimeSync other) { + if (other == global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.DefaultInstance) return this; + if (other.HasClientTime) { + ClientTime = other.ClientTime; + } + if (other.HasServerTime) { + ServerTime = other.ServerTime; + } + if (other.HasSyncRound) { + SyncRound = other.SyncRound; + } + if (other.HasReturnOptions) { + ReturnOptions = other.ReturnOptions; + } + if (other.HasRoundTrip) { + RoundTrip = other.RoundTrip; + } + 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 73: { + ClientTime = input.ReadFixed64(); + break; + } + case 81: { + ServerTime = input.ReadFixed64(); + break; + } + case 88: { + SyncRound = input.ReadUInt64(); + break; + } + case 112: { + ReturnOptions = input.ReadUInt32(); + break; + } + case 20489: { + RoundTrip = input.ReadFixed64(); + break; + } + } + } + } + + + public bool HasClientTime { + get { return result.HasClientTime; } + } + [global::System.CLSCompliant(false)] + public ulong ClientTime { + get { return result.ClientTime; } + set { SetClientTime(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetClientTime(ulong value) { + result.hasClientTime = true; + result.clientTime_ = value; + return this; + } + public Builder ClearClientTime() { + result.hasClientTime = false; + result.clientTime_ = 0; + return this; + } + + public bool HasServerTime { + get { return result.HasServerTime; } + } + [global::System.CLSCompliant(false)] + public ulong ServerTime { + get { return result.ServerTime; } + set { SetServerTime(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetServerTime(ulong value) { + result.hasServerTime = true; + result.serverTime_ = value; + return this; + } + public Builder ClearServerTime() { + result.hasServerTime = false; + result.serverTime_ = 0; + return this; + } + + public bool HasSyncRound { + get { return result.HasSyncRound; } + } + [global::System.CLSCompliant(false)] + public ulong SyncRound { + get { return result.SyncRound; } + set { SetSyncRound(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetSyncRound(ulong value) { + result.hasSyncRound = true; + result.syncRound_ = value; + return this; + } + public Builder ClearSyncRound() { + result.hasSyncRound = false; + result.syncRound_ = 0UL; + return this; + } + + public bool HasReturnOptions { + get { return result.HasReturnOptions; } + } + [global::System.CLSCompliant(false)] + public uint ReturnOptions { + get { return result.ReturnOptions; } + set { SetReturnOptions(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetReturnOptions(uint value) { + result.hasReturnOptions = true; + result.returnOptions_ = value; + return this; + } + public Builder ClearReturnOptions() { + result.hasReturnOptions = false; + result.returnOptions_ = 0; + return this; + } + + public bool HasRoundTrip { + get { return result.HasRoundTrip; } + } + [global::System.CLSCompliant(false)] + public ulong RoundTrip { + get { return result.RoundTrip; } + set { SetRoundTrip(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetRoundTrip(ulong value) { + result.hasRoundTrip = true; + result.roundTrip_ = value; + return this; + } + public Builder ClearRoundTrip() { + result.hasRoundTrip = false; + result.roundTrip_ = 0; + return this; + } + } + static TimeSync() { + object.ReferenceEquals(global::Sirikata.Network.Protocol._PBJ_Internal.Time.Descriptor, null); + } + } + + #endregion + +} diff --git a/OpenSim/Client/Sirikata/Protocol/Time.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Time.pbj.cs new file mode 100644 index 0000000..c3e9e73 --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Time.pbj.cs @@ -0,0 +1,218 @@ +using pbd = global::Google.ProtocolBuffers.Descriptors; +using pb = global::Google.ProtocolBuffers; +namespace Sirikata.Network.Protocol { + public class TimeSync : PBJ.IMessage { + protected _PBJ_Internal.TimeSync super; + public _PBJ_Internal.TimeSync _PBJSuper{ get { return super;} } + public TimeSync() { + super=new _PBJ_Internal.TimeSync(); + } + public TimeSync(_PBJ_Internal.TimeSync reference) { + super=reference; + } + public static TimeSync defaultInstance= new TimeSync (_PBJ_Internal.TimeSync.DefaultInstance); + public static TimeSync DefaultInstance{ + get {return defaultInstance;} + } + public static pbd.MessageDescriptor Descriptor { + get { return _PBJ_Internal.TimeSync.Descriptor; } } + public static class Types { + public enum ReturnOptions { + REPLY_RELIABLE=_PBJ_Internal.TimeSync.Types.ReturnOptions.REPLY_RELIABLE, + REPLY_ORDERED=_PBJ_Internal.TimeSync.Types.ReturnOptions.REPLY_ORDERED + }; + } + public static bool WithinReservedFieldTagRange(int field_tag) { + return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); + } + public static bool WithinExtensionFieldTagRange(int field_tag) { + return false; + } + public const int ClientTimeFieldTag=9; + public bool HasClientTime{ get {return super.HasClientTime&&PBJ._PBJ.ValidateTime(super.ClientTime);} } + public PBJ.Time ClientTime{ get { + if (HasClientTime) { + return PBJ._PBJ.CastTime(super.ClientTime); + } else { + return PBJ._PBJ.CastTime(); + } + } + } + public const int ServerTimeFieldTag=10; + public bool HasServerTime{ get {return super.HasServerTime&&PBJ._PBJ.ValidateTime(super.ServerTime);} } + public PBJ.Time ServerTime{ get { + if (HasServerTime) { + return PBJ._PBJ.CastTime(super.ServerTime); + } else { + return PBJ._PBJ.CastTime(); + } + } + } + public const int SyncRoundFieldTag=11; + public bool HasSyncRound{ get {return super.HasSyncRound&&PBJ._PBJ.ValidateUint64(super.SyncRound);} } + public ulong SyncRound{ get { + if (HasSyncRound) { + return PBJ._PBJ.CastUint64(super.SyncRound); + } else { + return PBJ._PBJ.CastUint64(); + } + } + } + public const int ReturnOptionsFieldTag=14; + public bool HasReturnOptions { get { + if (!super.HasReturnOptions) return false; + return PBJ._PBJ.ValidateFlags(super.ReturnOptions,(ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED); + } } + public uint ReturnOptions{ get { + if (HasReturnOptions) { + return (uint)PBJ._PBJ.CastFlags(super.ReturnOptions,(ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED); + } else { + return (uint)PBJ._PBJ.CastFlags((ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED); + } + } + } + public const int RoundTripFieldTag=2561; + public bool HasRoundTrip{ get {return super.HasRoundTrip&&PBJ._PBJ.ValidateTime(super.RoundTrip);} } + public PBJ.Time RoundTrip{ get { + if (HasRoundTrip) { + return PBJ._PBJ.CastTime(super.RoundTrip); + } else { + return PBJ._PBJ.CastTime(); + } + } + } + public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } + public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder() { return new Builder(); } + public static Builder CreateBuilder(TimeSync prototype) { + return (Builder)new Builder().MergeFrom(prototype); + } + public static TimeSync ParseFrom(pb::ByteString data) { + return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data)); + } + public static TimeSync ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { + return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data,er)); + } + public static TimeSync ParseFrom(byte[] data) { + return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data)); + } + public static TimeSync ParseFrom(byte[] data, pb::ExtensionRegistry er) { + return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data,er)); + } + public static TimeSync ParseFrom(global::System.IO.Stream data) { + return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data)); + } + public static TimeSync ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { + return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data,er)); + } + public static TimeSync ParseFrom(pb::CodedInputStream data) { + return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data)); + } + public static TimeSync ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { + return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data,er)); + } + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + public class Builder : global::PBJ.IMessage.IBuilder{ + protected override bool _HasAllPBJFields{ get { + return true + ; + } } + public bool IsInitialized { get { + return super.IsInitialized&&_HasAllPBJFields; + } } + protected _PBJ_Internal.TimeSync.Builder super; + public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } + public _PBJ_Internal.TimeSync.Builder _PBJSuper{ get { return super;} } + public Builder() {super = new _PBJ_Internal.TimeSync.Builder();} + public Builder(_PBJ_Internal.TimeSync.Builder other) { + super=other; + } + public Builder Clone() {return new Builder(super.Clone());} + public Builder MergeFrom(TimeSync prototype) { super.MergeFrom(prototype._PBJSuper);return this;} + public Builder Clear() {super.Clear();return this;} + public TimeSync BuildPartial() {return new TimeSync(super.BuildPartial());} + public TimeSync Build() {if (_HasAllPBJFields) return new TimeSync(super.Build());return null;} + public pbd::MessageDescriptor DescriptorForType { + get { return TimeSync.Descriptor; } } + public Builder ClearClientTime() { super.ClearClientTime();return this;} + public const int ClientTimeFieldTag=9; + public bool HasClientTime{ get {return super.HasClientTime&&PBJ._PBJ.ValidateTime(super.ClientTime);} } + public PBJ.Time ClientTime{ get { + if (HasClientTime) { + return PBJ._PBJ.CastTime(super.ClientTime); + } else { + return PBJ._PBJ.CastTime(); + } + } + set { + super.ClientTime=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearServerTime() { super.ClearServerTime();return this;} + public const int ServerTimeFieldTag=10; + public bool HasServerTime{ get {return super.HasServerTime&&PBJ._PBJ.ValidateTime(super.ServerTime);} } + public PBJ.Time ServerTime{ get { + if (HasServerTime) { + return PBJ._PBJ.CastTime(super.ServerTime); + } else { + return PBJ._PBJ.CastTime(); + } + } + set { + super.ServerTime=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearSyncRound() { super.ClearSyncRound();return this;} + public const int SyncRoundFieldTag=11; + public bool HasSyncRound{ get {return super.HasSyncRound&&PBJ._PBJ.ValidateUint64(super.SyncRound);} } + public ulong SyncRound{ get { + if (HasSyncRound) { + return PBJ._PBJ.CastUint64(super.SyncRound); + } else { + return PBJ._PBJ.CastUint64(); + } + } + set { + super.SyncRound=(PBJ._PBJ.Construct(value)); + } + } + public Builder ClearReturnOptions() { super.ClearReturnOptions();return this;} + public const int ReturnOptionsFieldTag=14; + public bool HasReturnOptions { get { + if (!super.HasReturnOptions) return false; + return PBJ._PBJ.ValidateFlags(super.ReturnOptions,(ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED); + } } + public uint ReturnOptions{ get { + if (HasReturnOptions) { + return (uint)PBJ._PBJ.CastFlags(super.ReturnOptions,(ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED); + } else { + return (uint)PBJ._PBJ.CastFlags((ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED); + } + } + set { + super.ReturnOptions=((value)); + } + } + public Builder ClearRoundTrip() { super.ClearRoundTrip();return this;} + public const int RoundTripFieldTag=2561; + public bool HasRoundTrip{ get {return super.HasRoundTrip&&PBJ._PBJ.ValidateTime(super.RoundTrip);} } + public PBJ.Time RoundTrip{ get { + if (HasRoundTrip) { + return PBJ._PBJ.CastTime(super.RoundTrip); + } else { + return PBJ._PBJ.CastTime(); + } + } + set { + super.RoundTrip=(PBJ._PBJ.Construct(value)); + } + } + } + } +} -- cgit v1.1