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/Test.cs | 3773 ++++++++++++++++++++++++++++++ 1 file changed, 3773 insertions(+) create mode 100644 OpenSim/Client/Sirikata/Protocol/Test.cs (limited to 'OpenSim/Client/Sirikata/Protocol/Test.cs') 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 + +} -- cgit v1.1