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/Sirikata.cs | 8074 ++++++++++++++++++++++++++ 1 file changed, 8074 insertions(+) create mode 100644 OpenSim/Client/Sirikata/Protocol/Sirikata.cs (limited to 'OpenSim/Client/Sirikata/Protocol/Sirikata.cs') diff --git a/OpenSim/Client/Sirikata/Protocol/Sirikata.cs b/OpenSim/Client/Sirikata/Protocol/Sirikata.cs new file mode 100644 index 0000000..9283086 --- /dev/null +++ b/OpenSim/Client/Sirikata/Protocol/Sirikata.cs @@ -0,0 +1,8074 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +using pb = global::Google.ProtocolBuffers; +using pbc = global::Google.ProtocolBuffers.Collections; +using pbd = global::Google.ProtocolBuffers.Descriptors; +using scg = global::System.Collections.Generic; +namespace Sirikata.Protocol._PBJ_Internal { + + public static partial class Sirikata { + + #region Extension registration + public static void RegisterAllExtensions(pb::ExtensionRegistry registry) { + } + #endregion + #region Static variables + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__FieldAccessorTable; + #endregion + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbd::FileDescriptor descriptor; + + static Sirikata() { + byte[] descriptorData = global::System.Convert.FromBase64String( + "Cg5TaXJpa2F0YS5wcm90bxIfU2lyaWthdGEuUHJvdG9jb2wuX1BCSl9JbnRl" + + "cm5hbCI/CgtNZXNzYWdlQm9keRIVCg1tZXNzYWdlX25hbWVzGAkgAygJEhkK" + + "EW1lc3NhZ2VfYXJndW1lbnRzGAogAygMIroDCg9SZWFkT25seU1lc3NhZ2US" + + "FQoNc291cmNlX29iamVjdBgBIAEoDBITCgtzb3VyY2VfcG9ydBgDIAEoDRIV" + + "Cgxzb3VyY2Vfc3BhY2UYgAwgASgMEhoKEmRlc3RpbmF0aW9uX29iamVjdBgC" + + "IAEoDBIYChBkZXN0aW5hdGlvbl9wb3J0GAQgASgNEhoKEWRlc3RpbmF0aW9u" + + "X3NwYWNlGIEMIAEoDBIKCgJpZBgHIAEoAxIQCghyZXBseV9pZBgIIAEoAxJV" + + "Cg1yZXR1cm5fc3RhdHVzGIAOIAEoDjI9LlNpcmlrYXRhLlByb3RvY29sLl9Q" + + "QkpfSW50ZXJuYWwuUmVhZE9ubHlNZXNzYWdlLlJldHVyblN0YXR1cxIVCg1t" + + "ZXNzYWdlX25hbWVzGAkgAygJEhkKEW1lc3NhZ2VfYXJndW1lbnRzGAogAygM" + + "ImsKDFJldHVyblN0YXR1cxILCgdTVUNDRVNTEAASEwoPTkVUV09SS19GQUlM" + + "VVJFEAESEwoPVElNRU9VVF9GQUlMVVJFEAMSEgoOUFJPVE9DT0xfRVJST1IQ" + + "BBIQCgxQT1JUX0ZBSUxVUkUQBSLOAQoNU3BhY2VTZXJ2aWNlcxIZChFyZWdp" + + "c3RyYXRpb25fcG9ydBghIAEoDRIQCghsb2NfcG9ydBgiIAEoDRIRCglnZW9t" + + "X3BvcnQYIyABKA0SEQoJb3NlZ19wb3J0GCQgASgNEhEKCWNzZWdfcG9ydBgl" + + "IAEoDRITCgtyb3V0ZXJfcG9ydBgmIAEoDRIdChVwcmVfY29ubmVjdGlvbl9i" + + "dWZmZXIYQCABKAQSIwobbWF4X3ByZV9jb25uZWN0aW9uX21lc3NhZ2VzGEEg" + + "ASgEIsQBCgZPYmpMb2MSEQoJdGltZXN0YW1wGAIgASgGEhQKCHBvc2l0aW9u" + + "GAMgAygBQgIQARIXCgtvcmllbnRhdGlvbhgEIAMoAkICEAESFAoIdmVsb2Np" + + "dHkYBSADKAJCAhABEhsKD3JvdGF0aW9uYWxfYXhpcxgHIAMoAkICEAESFQoN" + + "YW5ndWxhcl9zcGVlZBgIIAEoAhIUCgx1cGRhdGVfZmxhZ3MYBiABKA0iGAoL" + + "VXBkYXRlRmxhZ3MSCQoFRk9SQ0UQASKFAQoKTG9jUmVxdWVzdBIYChByZXF1" + + "ZXN0ZWRfZmllbGRzGAIgASgNIl0KBkZpZWxkcxIMCghQT1NJVElPThABEg8K" + + "C09SSUVOVEFUSU9OEAISDAoIVkVMT0NJVFkQBBITCg9ST1RBVElPTkFMX0FY" + + "SVMQCBIRCg1BTkdVTEFSX1NQRUVEEBAiigEKBk5ld09iahIcChRvYmplY3Rf" + + "dXVpZF9ldmlkZW5jZRgCIAEoDBJFChRyZXF1ZXN0ZWRfb2JqZWN0X2xvYxgD" + + "IAEoCzInLlNpcmlrYXRhLlByb3RvY29sLl9QQkpfSW50ZXJuYWwuT2JqTG9j" + + "EhsKD2JvdW5kaW5nX3NwaGVyZRgEIAMoAkICEAEiegoGUmV0T2JqEhgKEG9i" + + "amVjdF9yZWZlcmVuY2UYAiABKAwSOQoIbG9jYXRpb24YAyABKAsyJy5TaXJp" + + "a2F0YS5Qcm90b2NvbC5fUEJKX0ludGVybmFsLk9iakxvYxIbCg9ib3VuZGlu" + + "Z19zcGhlcmUYBCADKAJCAhABIiIKBkRlbE9iahIYChBvYmplY3RfcmVmZXJl" + + "bmNlGAIgASgMIpoBCgxOZXdQcm94UXVlcnkSEAoIcXVlcnlfaWQYAiABKA0S" + + "EQoJc3RhdGVsZXNzGAMgASgIEhsKD3JlbGF0aXZlX2NlbnRlchgEIAMoAkIC" + + "EAESGwoPYWJzb2x1dGVfY2VudGVyGAUgAygBQgIQARISCgptYXhfcmFkaXVz" + + "GAYgASgCEhcKD21pbl9zb2xpZF9hbmdsZRgHIAEoAiLhAQoIUHJveENhbGwS" + + "EAoIcXVlcnlfaWQYAiACKA0SGAoQcHJveGltYXRlX29iamVjdBgDIAIoDBJR" + + "Cg9wcm94aW1pdHlfZXZlbnQYBCACKA4yOC5TaXJpa2F0YS5Qcm90b2NvbC5f" + + "UEJKX0ludGVybmFsLlByb3hDYWxsLlByb3hpbWl0eUV2ZW50IlYKDlByb3hp" + + "bWl0eUV2ZW50EhQKEEVYSVRFRF9QUk9YSU1JVFkQABIVChFFTlRFUkVEX1BS" + + "T1hJTUlUWRABEhcKE1NUQVRFTEVTU19QUk9YSU1JVFkQAiIgCgxEZWxQcm94" + + "UXVlcnkSEAoIcXVlcnlfaWQYAiABKA0iJQoQVmVjdG9yM2ZQcm9wZXJ0eRIR" + + "CgV2YWx1ZRgKIAMoAkICEAEiHwoOU3RyaW5nUHJvcGVydHkSDQoFdmFsdWUY" + + "CiABKAkiMQoRU3RyaW5nTWFwUHJvcGVydHkSDAoEa2V5cxgCIAMoCRIOCgZ2" + + "YWx1ZXMYAyADKAkiyQIKElBoeXNpY2FsUGFyYW1ldGVycxJGCgRtb2RlGAIg" + + "ASgOMjguU2lyaWthdGEuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5QaHlzaWNh" + + "bFBhcmFtZXRlcnMuTW9kZRIPCgdkZW5zaXR5GAMgASgCEhAKCGZyaWN0aW9u" + + "GAQgASgCEg4KBmJvdW5jZRgFIAEoAhIQCgRodWxsGAYgAygCQgIQARITCgtj" + + "b2xsaWRlX21zZxgQIAEoDRIUCgxjb2xsaWRlX21hc2sYESABKA0SDwoHZ3Jh" + + "dml0eRgSIAEoAiJqCgRNb2RlEg8KC05PTlBIWVNJQ0FMEAASCgoGU1RBVElD" + + "EAESDgoKRFlOQU1JQ0JPWBACEhEKDURZTkFNSUNTUEhFUkUQAxITCg9EWU5B" + + "TUlDQ1lMSU5ERVIQBBINCglDSEFSQUNURVIQBSLaAwoRTGlnaHRJbmZvUHJv" + + "cGVydHkSGQoNZGlmZnVzZV9jb2xvchgDIAMoAkICEAESGgoOc3BlY3VsYXJf" + + "Y29sb3IYBCADKAJCAhABEg0KBXBvd2VyGAUgASgCEhkKDWFtYmllbnRfY29s" + + "b3IYBiADKAJCAhABEhgKDHNoYWRvd19jb2xvchgHIAMoAkICEAESEwoLbGln" + + "aHRfcmFuZ2UYCCABKAESGAoQY29uc3RhbnRfZmFsbG9mZhgJIAEoAhIWCg5s" + + "aW5lYXJfZmFsbG9mZhgKIAEoAhIZChFxdWFkcmF0aWNfZmFsbG9mZhgLIAEo" + + "AhIaChJjb25lX2lubmVyX3JhZGlhbnMYDCABKAISGgoSY29uZV9vdXRlcl9y" + + "YWRpYW5zGA0gASgCEhQKDGNvbmVfZmFsbG9mZhgOIAEoAhJLCgR0eXBlGA8g" + + "ASgOMj0uU2lyaWthdGEuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5MaWdodElu" + + "Zm9Qcm9wZXJ0eS5MaWdodFR5cGVzEhQKDGNhc3RzX3NoYWRvdxgQIAEoCCI3" + + "CgpMaWdodFR5cGVzEgkKBVBPSU5UEAASDQoJU1BPVExJR0hUEAESDwoLRElS" + + "RUNUSU9OQUwQAiIfCg5QYXJlbnRQcm9wZXJ0eRINCgV2YWx1ZRgKIAEoDCIh" + + "ChBVVUlETGlzdFByb3BlcnR5Eg0KBXZhbHVlGAogAygMIqQBCg5Db25uZWN0" + + "VG9TcGFjZRIQCghzcGFjZV9pZBgBIAEoDBIcChRvYmplY3RfdXVpZF9ldmlk" + + "ZW5jZRgCIAEoDBJFChRyZXF1ZXN0ZWRfb2JqZWN0X2xvYxgDIAEoCzInLlNp" + + "cmlrYXRhLlByb3RvY29sLl9QQkpfSW50ZXJuYWwuT2JqTG9jEhsKD2JvdW5k" + + "aW5nX3NwaGVyZRgEIAMoAkICEAEivgIKDENyZWF0ZU9iamVjdBITCgtvYmpl" + + "Y3RfdXVpZBgBIAEoDBJJChBzcGFjZV9wcm9wZXJ0aWVzGAIgAygLMi8uU2ly" + + "aWthdGEuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5Db25uZWN0VG9TcGFjZRIM" + + "CgRtZXNoGAMgASgJEhEKBXNjYWxlGAQgAygCQgIQARIOCgZ3ZWJ1cmwYBSAB" + + "KAkSRgoKbGlnaHRfaW5mbxgGIAEoCzIyLlNpcmlrYXRhLlByb3RvY29sLl9Q" + + "QkpfSW50ZXJuYWwuTGlnaHRJbmZvUHJvcGVydHkSDgoGY2FtZXJhGAcgASgI" + + "EkUKCHBoeXNpY2FsGAggASgLMjMuU2lyaWthdGEuUHJvdG9jb2wuX1BCSl9J" + + "bnRlcm5hbC5QaHlzaWNhbFBhcmFtZXRlcnM="); + pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { + descriptor = root; + internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__Descriptor = Descriptor.MessageTypes[0]; + internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__Descriptor, + new string[] { "MessageNames", "MessageArguments", }); + internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__Descriptor = Descriptor.MessageTypes[1]; + internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__Descriptor, + new string[] { "SourceObject", "SourcePort", "SourceSpace", "DestinationObject", "DestinationPort", "DestinationSpace", "Id", "ReplyId", "ReturnStatus", "MessageNames", "MessageArguments", }); + internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__Descriptor = Descriptor.MessageTypes[2]; + internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__Descriptor, + new string[] { "RegistrationPort", "LocPort", "GeomPort", "OsegPort", "CsegPort", "RouterPort", "PreConnectionBuffer", "MaxPreConnectionMessages", }); + internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__Descriptor = Descriptor.MessageTypes[3]; + internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__Descriptor, + new string[] { "Timestamp", "Position", "Orientation", "Velocity", "RotationalAxis", "AngularSpeed", "UpdateFlags", }); + internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__Descriptor = Descriptor.MessageTypes[4]; + internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__Descriptor, + new string[] { "RequestedFields", }); + internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__Descriptor = Descriptor.MessageTypes[5]; + internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__Descriptor, + new string[] { "ObjectUuidEvidence", "RequestedObjectLoc", "BoundingSphere", }); + internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__Descriptor = Descriptor.MessageTypes[6]; + internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__Descriptor, + new string[] { "ObjectReference", "Location", "BoundingSphere", }); + internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__Descriptor = Descriptor.MessageTypes[7]; + internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__Descriptor, + new string[] { "ObjectReference", }); + internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__Descriptor = Descriptor.MessageTypes[8]; + internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__Descriptor, + new string[] { "QueryId", "Stateless", "RelativeCenter", "AbsoluteCenter", "MaxRadius", "MinSolidAngle", }); + internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__Descriptor = Descriptor.MessageTypes[9]; + internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__Descriptor, + new string[] { "QueryId", "ProximateObject", "ProximityEvent", }); + internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__Descriptor = Descriptor.MessageTypes[10]; + internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__Descriptor, + new string[] { "QueryId", }); + internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__Descriptor = Descriptor.MessageTypes[11]; + internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__Descriptor, + new string[] { "Value", }); + internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__Descriptor = Descriptor.MessageTypes[12]; + internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__Descriptor, + new string[] { "Value", }); + internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__Descriptor = Descriptor.MessageTypes[13]; + internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__Descriptor, + new string[] { "Keys", "Values", }); + internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__Descriptor = Descriptor.MessageTypes[14]; + internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__Descriptor, + new string[] { "Mode", "Density", "Friction", "Bounce", "Hull", "CollideMsg", "CollideMask", "Gravity", }); + internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__Descriptor = Descriptor.MessageTypes[15]; + internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__Descriptor, + new string[] { "DiffuseColor", "SpecularColor", "Power", "AmbientColor", "ShadowColor", "LightRange", "ConstantFalloff", "LinearFalloff", "QuadraticFalloff", "ConeInnerRadians", "ConeOuterRadians", "ConeFalloff", "Type", "CastsShadow", }); + internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__Descriptor = Descriptor.MessageTypes[16]; + internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__Descriptor, + new string[] { "Value", }); + internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__Descriptor = Descriptor.MessageTypes[17]; + internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__Descriptor, + new string[] { "Value", }); + internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__Descriptor = Descriptor.MessageTypes[18]; + internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__Descriptor, + new string[] { "SpaceId", "ObjectUuidEvidence", "RequestedObjectLoc", "BoundingSphere", }); + internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__Descriptor = Descriptor.MessageTypes[19]; + internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__Descriptor, + new string[] { "ObjectUuid", "SpaceProperties", "Mesh", "Scale", "Weburl", "LightInfo", "Camera", "Physical", }); + return null; + }; + pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, + new pbd::FileDescriptor[] { + }, assigner); + } + #endregion + + } + #region Messages + public sealed partial class MessageBody : pb::GeneratedMessage { + private static readonly MessageBody defaultInstance = new Builder().BuildPartial(); + public static MessageBody DefaultInstance { + get { return defaultInstance; } + } + + public override MessageBody DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override MessageBody ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__FieldAccessorTable; } + } + + public const int MessageNamesFieldNumber = 9; + private pbc::PopsicleList messageNames_ = new pbc::PopsicleList(); + public scg::IList MessageNamesList { + get { return pbc::Lists.AsReadOnly(messageNames_); } + } + public int MessageNamesCount { + get { return messageNames_.Count; } + } + public string GetMessageNames(int index) { + return messageNames_[index]; + } + + public const int MessageArgumentsFieldNumber = 10; + private pbc::PopsicleList messageArguments_ = new pbc::PopsicleList(); + public scg::IList MessageArgumentsList { + get { return pbc::Lists.AsReadOnly(messageArguments_); } + } + public int MessageArgumentsCount { + get { return messageArguments_.Count; } + } + public pb::ByteString GetMessageArguments(int index) { + return messageArguments_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (messageNames_.Count > 0) { + foreach (string element in messageNames_) { + output.WriteString(9, element); + } + } + if (messageArguments_.Count > 0) { + foreach (pb::ByteString element in messageArguments_) { + output.WriteBytes(10, element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + foreach (string element in MessageNamesList) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 1 * messageNames_.Count; + } + { + int dataSize = 0; + foreach (pb::ByteString element in MessageArgumentsList) { + dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); + } + size += dataSize; + size += 1 * messageArguments_.Count; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static MessageBody ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static MessageBody ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static MessageBody ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static MessageBody ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static MessageBody ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static MessageBody ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static MessageBody ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static MessageBody ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static MessageBody ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static MessageBody ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(MessageBody prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + MessageBody result = new MessageBody(); + + protected override MessageBody MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new MessageBody(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.MessageBody.Descriptor; } + } + + public override MessageBody DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.MessageBody.DefaultInstance; } + } + + public override MessageBody BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.messageNames_.MakeReadOnly(); + result.messageArguments_.MakeReadOnly(); + MessageBody returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is MessageBody) { + return MergeFrom((MessageBody) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(MessageBody other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.MessageBody.DefaultInstance) return this; + if (other.messageNames_.Count != 0) { + base.AddRange(other.messageNames_, result.messageNames_); + } + if (other.messageArguments_.Count != 0) { + base.AddRange(other.messageArguments_, result.messageArguments_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 74: { + AddMessageNames(input.ReadString()); + break; + } + case 82: { + AddMessageArguments(input.ReadBytes()); + break; + } + } + } + } + + + public pbc::IPopsicleList MessageNamesList { + get { return result.messageNames_; } + } + public int MessageNamesCount { + get { return result.MessageNamesCount; } + } + public string GetMessageNames(int index) { + return result.GetMessageNames(index); + } + public Builder SetMessageNames(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageNames_[index] = value; + return this; + } + public Builder AddMessageNames(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageNames_.Add(value); + return this; + } + public Builder AddRangeMessageNames(scg::IEnumerable values) { + base.AddRange(values, result.messageNames_); + return this; + } + public Builder ClearMessageNames() { + result.messageNames_.Clear(); + return this; + } + + public pbc::IPopsicleList MessageArgumentsList { + get { return result.messageArguments_; } + } + public int MessageArgumentsCount { + get { return result.MessageArgumentsCount; } + } + public pb::ByteString GetMessageArguments(int index) { + return result.GetMessageArguments(index); + } + public Builder SetMessageArguments(int index, pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageArguments_[index] = value; + return this; + } + public Builder AddMessageArguments(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageArguments_.Add(value); + return this; + } + public Builder AddRangeMessageArguments(scg::IEnumerable values) { + base.AddRange(values, result.messageArguments_); + return this; + } + public Builder ClearMessageArguments() { + result.messageArguments_.Clear(); + return this; + } + } + static MessageBody() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class ReadOnlyMessage : pb::GeneratedMessage { + private static readonly ReadOnlyMessage defaultInstance = new Builder().BuildPartial(); + public static ReadOnlyMessage DefaultInstance { + get { return defaultInstance; } + } + + public override ReadOnlyMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ReadOnlyMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum ReturnStatus { + SUCCESS = 0, + NETWORK_FAILURE = 1, + TIMEOUT_FAILURE = 3, + PROTOCOL_ERROR = 4, + PORT_FAILURE = 5, + } + + } + #endregion + + public const int SourceObjectFieldNumber = 1; + private bool hasSourceObject; + private pb::ByteString sourceObject_ = pb::ByteString.Empty; + public bool HasSourceObject { + get { return hasSourceObject; } + } + public pb::ByteString SourceObject { + get { return sourceObject_; } + } + + public const int SourcePortFieldNumber = 3; + private bool hasSourcePort; + private uint sourcePort_ = 0; + public bool HasSourcePort { + get { return hasSourcePort; } + } + [global::System.CLSCompliant(false)] + public uint SourcePort { + get { return sourcePort_; } + } + + public const int SourceSpaceFieldNumber = 1536; + private bool hasSourceSpace; + private pb::ByteString sourceSpace_ = pb::ByteString.Empty; + public bool HasSourceSpace { + get { return hasSourceSpace; } + } + public pb::ByteString SourceSpace { + get { return sourceSpace_; } + } + + public const int DestinationObjectFieldNumber = 2; + private bool hasDestinationObject; + private pb::ByteString destinationObject_ = pb::ByteString.Empty; + public bool HasDestinationObject { + get { return hasDestinationObject; } + } + public pb::ByteString DestinationObject { + get { return destinationObject_; } + } + + public const int DestinationPortFieldNumber = 4; + private bool hasDestinationPort; + private uint destinationPort_ = 0; + public bool HasDestinationPort { + get { return hasDestinationPort; } + } + [global::System.CLSCompliant(false)] + public uint DestinationPort { + get { return destinationPort_; } + } + + public const int DestinationSpaceFieldNumber = 1537; + private bool hasDestinationSpace; + private pb::ByteString destinationSpace_ = pb::ByteString.Empty; + public bool HasDestinationSpace { + get { return hasDestinationSpace; } + } + public pb::ByteString DestinationSpace { + get { return destinationSpace_; } + } + + public const int IdFieldNumber = 7; + private bool hasId; + private long id_ = 0L; + public bool HasId { + get { return hasId; } + } + public long Id { + get { return id_; } + } + + public const int ReplyIdFieldNumber = 8; + private bool hasReplyId; + private long replyId_ = 0L; + public bool HasReplyId { + get { return hasReplyId; } + } + public long ReplyId { + get { return replyId_; } + } + + public const int ReturnStatusFieldNumber = 1792; + private bool hasReturnStatus; + private global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus returnStatus_ = global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.SUCCESS; + public bool HasReturnStatus { + get { return hasReturnStatus; } + } + public global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus ReturnStatus { + get { return returnStatus_; } + } + + public const int MessageNamesFieldNumber = 9; + private pbc::PopsicleList messageNames_ = new pbc::PopsicleList(); + public scg::IList MessageNamesList { + get { return pbc::Lists.AsReadOnly(messageNames_); } + } + public int MessageNamesCount { + get { return messageNames_.Count; } + } + public string GetMessageNames(int index) { + return messageNames_[index]; + } + + public const int MessageArgumentsFieldNumber = 10; + private pbc::PopsicleList messageArguments_ = new pbc::PopsicleList(); + public scg::IList MessageArgumentsList { + get { return pbc::Lists.AsReadOnly(messageArguments_); } + } + public int MessageArgumentsCount { + get { return messageArguments_.Count; } + } + public pb::ByteString GetMessageArguments(int index) { + return messageArguments_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasSourceObject) { + output.WriteBytes(1, SourceObject); + } + if (HasDestinationObject) { + output.WriteBytes(2, DestinationObject); + } + if (HasSourcePort) { + output.WriteUInt32(3, SourcePort); + } + if (HasDestinationPort) { + output.WriteUInt32(4, DestinationPort); + } + if (HasId) { + output.WriteInt64(7, Id); + } + if (HasReplyId) { + output.WriteInt64(8, ReplyId); + } + if (messageNames_.Count > 0) { + foreach (string element in messageNames_) { + output.WriteString(9, element); + } + } + if (messageArguments_.Count > 0) { + foreach (pb::ByteString element in messageArguments_) { + output.WriteBytes(10, element); + } + } + if (HasSourceSpace) { + output.WriteBytes(1536, SourceSpace); + } + if (HasDestinationSpace) { + output.WriteBytes(1537, DestinationSpace); + } + if (HasReturnStatus) { + output.WriteEnum(1792, (int) ReturnStatus); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasSourceObject) { + size += pb::CodedOutputStream.ComputeBytesSize(1, SourceObject); + } + if (HasSourcePort) { + size += pb::CodedOutputStream.ComputeUInt32Size(3, SourcePort); + } + if (HasSourceSpace) { + size += pb::CodedOutputStream.ComputeBytesSize(1536, SourceSpace); + } + if (HasDestinationObject) { + size += pb::CodedOutputStream.ComputeBytesSize(2, DestinationObject); + } + if (HasDestinationPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(4, DestinationPort); + } + if (HasDestinationSpace) { + size += pb::CodedOutputStream.ComputeBytesSize(1537, DestinationSpace); + } + if (HasId) { + size += pb::CodedOutputStream.ComputeInt64Size(7, Id); + } + if (HasReplyId) { + size += pb::CodedOutputStream.ComputeInt64Size(8, ReplyId); + } + if (HasReturnStatus) { + size += pb::CodedOutputStream.ComputeEnumSize(1792, (int) ReturnStatus); + } + { + int dataSize = 0; + foreach (string element in MessageNamesList) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 1 * messageNames_.Count; + } + { + int dataSize = 0; + foreach (pb::ByteString element in MessageArgumentsList) { + dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); + } + size += dataSize; + size += 1 * messageArguments_.Count; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ReadOnlyMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ReadOnlyMessage ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ReadOnlyMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ReadOnlyMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ReadOnlyMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ReadOnlyMessage result = new ReadOnlyMessage(); + + protected override ReadOnlyMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ReadOnlyMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Descriptor; } + } + + public override ReadOnlyMessage DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.DefaultInstance; } + } + + public override ReadOnlyMessage BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.messageNames_.MakeReadOnly(); + result.messageArguments_.MakeReadOnly(); + ReadOnlyMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ReadOnlyMessage) { + return MergeFrom((ReadOnlyMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ReadOnlyMessage other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.DefaultInstance) return this; + if (other.HasSourceObject) { + SourceObject = other.SourceObject; + } + if (other.HasSourcePort) { + SourcePort = other.SourcePort; + } + if (other.HasSourceSpace) { + SourceSpace = other.SourceSpace; + } + if (other.HasDestinationObject) { + DestinationObject = other.DestinationObject; + } + if (other.HasDestinationPort) { + DestinationPort = other.DestinationPort; + } + if (other.HasDestinationSpace) { + DestinationSpace = other.DestinationSpace; + } + if (other.HasId) { + Id = other.Id; + } + if (other.HasReplyId) { + ReplyId = other.ReplyId; + } + if (other.HasReturnStatus) { + ReturnStatus = other.ReturnStatus; + } + if (other.messageNames_.Count != 0) { + base.AddRange(other.messageNames_, result.messageNames_); + } + if (other.messageArguments_.Count != 0) { + base.AddRange(other.messageArguments_, result.messageArguments_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 10: { + SourceObject = input.ReadBytes(); + break; + } + case 18: { + DestinationObject = input.ReadBytes(); + break; + } + case 24: { + SourcePort = input.ReadUInt32(); + break; + } + case 32: { + DestinationPort = input.ReadUInt32(); + break; + } + case 56: { + Id = input.ReadInt64(); + break; + } + case 64: { + ReplyId = input.ReadInt64(); + break; + } + case 74: { + AddMessageNames(input.ReadString()); + break; + } + case 82: { + AddMessageArguments(input.ReadBytes()); + break; + } + case 12290: { + SourceSpace = input.ReadBytes(); + break; + } + case 12298: { + DestinationSpace = input.ReadBytes(); + break; + } + case 14336: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus), rawValue)) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(1792, (ulong) rawValue); + } else { + ReturnStatus = (global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus) rawValue; + } + break; + } + } + } + } + + + public bool HasSourceObject { + get { return result.HasSourceObject; } + } + public pb::ByteString SourceObject { + get { return result.SourceObject; } + set { SetSourceObject(value); } + } + public Builder SetSourceObject(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasSourceObject = true; + result.sourceObject_ = value; + return this; + } + public Builder ClearSourceObject() { + result.hasSourceObject = false; + result.sourceObject_ = pb::ByteString.Empty; + return this; + } + + public bool HasSourcePort { + get { return result.HasSourcePort; } + } + [global::System.CLSCompliant(false)] + public uint SourcePort { + get { return result.SourcePort; } + set { SetSourcePort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetSourcePort(uint value) { + result.hasSourcePort = true; + result.sourcePort_ = value; + return this; + } + public Builder ClearSourcePort() { + result.hasSourcePort = false; + result.sourcePort_ = 0; + return this; + } + + public bool HasSourceSpace { + get { return result.HasSourceSpace; } + } + public pb::ByteString SourceSpace { + get { return result.SourceSpace; } + set { SetSourceSpace(value); } + } + public Builder SetSourceSpace(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasSourceSpace = true; + result.sourceSpace_ = value; + return this; + } + public Builder ClearSourceSpace() { + result.hasSourceSpace = false; + result.sourceSpace_ = pb::ByteString.Empty; + return this; + } + + public bool HasDestinationObject { + get { return result.HasDestinationObject; } + } + public pb::ByteString DestinationObject { + get { return result.DestinationObject; } + set { SetDestinationObject(value); } + } + public Builder SetDestinationObject(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasDestinationObject = true; + result.destinationObject_ = value; + return this; + } + public Builder ClearDestinationObject() { + result.hasDestinationObject = false; + result.destinationObject_ = pb::ByteString.Empty; + return this; + } + + public bool HasDestinationPort { + get { return result.HasDestinationPort; } + } + [global::System.CLSCompliant(false)] + public uint DestinationPort { + get { return result.DestinationPort; } + set { SetDestinationPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetDestinationPort(uint value) { + result.hasDestinationPort = true; + result.destinationPort_ = value; + return this; + } + public Builder ClearDestinationPort() { + result.hasDestinationPort = false; + result.destinationPort_ = 0; + return this; + } + + public bool HasDestinationSpace { + get { return result.HasDestinationSpace; } + } + public pb::ByteString DestinationSpace { + get { return result.DestinationSpace; } + set { SetDestinationSpace(value); } + } + public Builder SetDestinationSpace(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasDestinationSpace = true; + result.destinationSpace_ = value; + return this; + } + public Builder ClearDestinationSpace() { + result.hasDestinationSpace = false; + result.destinationSpace_ = pb::ByteString.Empty; + return this; + } + + public bool HasId { + get { return result.HasId; } + } + public long Id { + get { return result.Id; } + set { SetId(value); } + } + public Builder SetId(long value) { + result.hasId = true; + result.id_ = value; + return this; + } + public Builder ClearId() { + result.hasId = false; + result.id_ = 0L; + return this; + } + + public bool HasReplyId { + get { return result.HasReplyId; } + } + public long ReplyId { + get { return result.ReplyId; } + set { SetReplyId(value); } + } + public Builder SetReplyId(long value) { + result.hasReplyId = true; + result.replyId_ = value; + return this; + } + public Builder ClearReplyId() { + result.hasReplyId = false; + result.replyId_ = 0L; + return this; + } + + public bool HasReturnStatus { + get { return result.HasReturnStatus; } + } + public global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus ReturnStatus { + get { return result.ReturnStatus; } + set { SetReturnStatus(value); } + } + public Builder SetReturnStatus(global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus value) { + result.hasReturnStatus = true; + result.returnStatus_ = value; + return this; + } + public Builder ClearReturnStatus() { + result.hasReturnStatus = false; + result.returnStatus_ = global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.SUCCESS; + return this; + } + + public pbc::IPopsicleList MessageNamesList { + get { return result.messageNames_; } + } + public int MessageNamesCount { + get { return result.MessageNamesCount; } + } + public string GetMessageNames(int index) { + return result.GetMessageNames(index); + } + public Builder SetMessageNames(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageNames_[index] = value; + return this; + } + public Builder AddMessageNames(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageNames_.Add(value); + return this; + } + public Builder AddRangeMessageNames(scg::IEnumerable values) { + base.AddRange(values, result.messageNames_); + return this; + } + public Builder ClearMessageNames() { + result.messageNames_.Clear(); + return this; + } + + public pbc::IPopsicleList MessageArgumentsList { + get { return result.messageArguments_; } + } + public int MessageArgumentsCount { + get { return result.MessageArgumentsCount; } + } + public pb::ByteString GetMessageArguments(int index) { + return result.GetMessageArguments(index); + } + public Builder SetMessageArguments(int index, pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageArguments_[index] = value; + return this; + } + public Builder AddMessageArguments(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.messageArguments_.Add(value); + return this; + } + public Builder AddRangeMessageArguments(scg::IEnumerable values) { + base.AddRange(values, result.messageArguments_); + return this; + } + public Builder ClearMessageArguments() { + result.messageArguments_.Clear(); + return this; + } + } + static ReadOnlyMessage() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class SpaceServices : pb::GeneratedMessage { + private static readonly SpaceServices defaultInstance = new Builder().BuildPartial(); + public static SpaceServices DefaultInstance { + get { return defaultInstance; } + } + + public override SpaceServices DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override SpaceServices ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__FieldAccessorTable; } + } + + public const int RegistrationPortFieldNumber = 33; + private bool hasRegistrationPort; + private uint registrationPort_ = 0; + public bool HasRegistrationPort { + get { return hasRegistrationPort; } + } + [global::System.CLSCompliant(false)] + public uint RegistrationPort { + get { return registrationPort_; } + } + + public const int LocPortFieldNumber = 34; + private bool hasLocPort; + private uint locPort_ = 0; + public bool HasLocPort { + get { return hasLocPort; } + } + [global::System.CLSCompliant(false)] + public uint LocPort { + get { return locPort_; } + } + + public const int GeomPortFieldNumber = 35; + private bool hasGeomPort; + private uint geomPort_ = 0; + public bool HasGeomPort { + get { return hasGeomPort; } + } + [global::System.CLSCompliant(false)] + public uint GeomPort { + get { return geomPort_; } + } + + public const int OsegPortFieldNumber = 36; + private bool hasOsegPort; + private uint osegPort_ = 0; + public bool HasOsegPort { + get { return hasOsegPort; } + } + [global::System.CLSCompliant(false)] + public uint OsegPort { + get { return osegPort_; } + } + + public const int CsegPortFieldNumber = 37; + private bool hasCsegPort; + private uint csegPort_ = 0; + public bool HasCsegPort { + get { return hasCsegPort; } + } + [global::System.CLSCompliant(false)] + public uint CsegPort { + get { return csegPort_; } + } + + public const int RouterPortFieldNumber = 38; + private bool hasRouterPort; + private uint routerPort_ = 0; + public bool HasRouterPort { + get { return hasRouterPort; } + } + [global::System.CLSCompliant(false)] + public uint RouterPort { + get { return routerPort_; } + } + + public const int PreConnectionBufferFieldNumber = 64; + private bool hasPreConnectionBuffer; + private ulong preConnectionBuffer_ = 0UL; + public bool HasPreConnectionBuffer { + get { return hasPreConnectionBuffer; } + } + [global::System.CLSCompliant(false)] + public ulong PreConnectionBuffer { + get { return preConnectionBuffer_; } + } + + public const int MaxPreConnectionMessagesFieldNumber = 65; + private bool hasMaxPreConnectionMessages; + private ulong maxPreConnectionMessages_ = 0UL; + public bool HasMaxPreConnectionMessages { + get { return hasMaxPreConnectionMessages; } + } + [global::System.CLSCompliant(false)] + public ulong MaxPreConnectionMessages { + get { return maxPreConnectionMessages_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasRegistrationPort) { + output.WriteUInt32(33, RegistrationPort); + } + if (HasLocPort) { + output.WriteUInt32(34, LocPort); + } + if (HasGeomPort) { + output.WriteUInt32(35, GeomPort); + } + if (HasOsegPort) { + output.WriteUInt32(36, OsegPort); + } + if (HasCsegPort) { + output.WriteUInt32(37, CsegPort); + } + if (HasRouterPort) { + output.WriteUInt32(38, RouterPort); + } + if (HasPreConnectionBuffer) { + output.WriteUInt64(64, PreConnectionBuffer); + } + if (HasMaxPreConnectionMessages) { + output.WriteUInt64(65, MaxPreConnectionMessages); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasRegistrationPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(33, RegistrationPort); + } + if (HasLocPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(34, LocPort); + } + if (HasGeomPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(35, GeomPort); + } + if (HasOsegPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(36, OsegPort); + } + if (HasCsegPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(37, CsegPort); + } + if (HasRouterPort) { + size += pb::CodedOutputStream.ComputeUInt32Size(38, RouterPort); + } + if (HasPreConnectionBuffer) { + size += pb::CodedOutputStream.ComputeUInt64Size(64, PreConnectionBuffer); + } + if (HasMaxPreConnectionMessages) { + size += pb::CodedOutputStream.ComputeUInt64Size(65, MaxPreConnectionMessages); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static SpaceServices ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SpaceServices ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SpaceServices ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SpaceServices ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SpaceServices ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SpaceServices ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SpaceServices ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static SpaceServices ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static SpaceServices ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SpaceServices ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SpaceServices prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + SpaceServices result = new SpaceServices(); + + protected override SpaceServices MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new SpaceServices(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.SpaceServices.Descriptor; } + } + + public override SpaceServices DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.SpaceServices.DefaultInstance; } + } + + public override SpaceServices BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + SpaceServices returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is SpaceServices) { + return MergeFrom((SpaceServices) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(SpaceServices other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.SpaceServices.DefaultInstance) return this; + if (other.HasRegistrationPort) { + RegistrationPort = other.RegistrationPort; + } + if (other.HasLocPort) { + LocPort = other.LocPort; + } + if (other.HasGeomPort) { + GeomPort = other.GeomPort; + } + if (other.HasOsegPort) { + OsegPort = other.OsegPort; + } + if (other.HasCsegPort) { + CsegPort = other.CsegPort; + } + if (other.HasRouterPort) { + RouterPort = other.RouterPort; + } + if (other.HasPreConnectionBuffer) { + PreConnectionBuffer = other.PreConnectionBuffer; + } + if (other.HasMaxPreConnectionMessages) { + MaxPreConnectionMessages = other.MaxPreConnectionMessages; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 264: { + RegistrationPort = input.ReadUInt32(); + break; + } + case 272: { + LocPort = input.ReadUInt32(); + break; + } + case 280: { + GeomPort = input.ReadUInt32(); + break; + } + case 288: { + OsegPort = input.ReadUInt32(); + break; + } + case 296: { + CsegPort = input.ReadUInt32(); + break; + } + case 304: { + RouterPort = input.ReadUInt32(); + break; + } + case 512: { + PreConnectionBuffer = input.ReadUInt64(); + break; + } + case 520: { + MaxPreConnectionMessages = input.ReadUInt64(); + break; + } + } + } + } + + + public bool HasRegistrationPort { + get { return result.HasRegistrationPort; } + } + [global::System.CLSCompliant(false)] + public uint RegistrationPort { + get { return result.RegistrationPort; } + set { SetRegistrationPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetRegistrationPort(uint value) { + result.hasRegistrationPort = true; + result.registrationPort_ = value; + return this; + } + public Builder ClearRegistrationPort() { + result.hasRegistrationPort = false; + result.registrationPort_ = 0; + return this; + } + + public bool HasLocPort { + get { return result.HasLocPort; } + } + [global::System.CLSCompliant(false)] + public uint LocPort { + get { return result.LocPort; } + set { SetLocPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetLocPort(uint value) { + result.hasLocPort = true; + result.locPort_ = value; + return this; + } + public Builder ClearLocPort() { + result.hasLocPort = false; + result.locPort_ = 0; + return this; + } + + public bool HasGeomPort { + get { return result.HasGeomPort; } + } + [global::System.CLSCompliant(false)] + public uint GeomPort { + get { return result.GeomPort; } + set { SetGeomPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetGeomPort(uint value) { + result.hasGeomPort = true; + result.geomPort_ = value; + return this; + } + public Builder ClearGeomPort() { + result.hasGeomPort = false; + result.geomPort_ = 0; + return this; + } + + public bool HasOsegPort { + get { return result.HasOsegPort; } + } + [global::System.CLSCompliant(false)] + public uint OsegPort { + get { return result.OsegPort; } + set { SetOsegPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetOsegPort(uint value) { + result.hasOsegPort = true; + result.osegPort_ = value; + return this; + } + public Builder ClearOsegPort() { + result.hasOsegPort = false; + result.osegPort_ = 0; + return this; + } + + public bool HasCsegPort { + get { return result.HasCsegPort; } + } + [global::System.CLSCompliant(false)] + public uint CsegPort { + get { return result.CsegPort; } + set { SetCsegPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetCsegPort(uint value) { + result.hasCsegPort = true; + result.csegPort_ = value; + return this; + } + public Builder ClearCsegPort() { + result.hasCsegPort = false; + result.csegPort_ = 0; + return this; + } + + public bool HasRouterPort { + get { return result.HasRouterPort; } + } + [global::System.CLSCompliant(false)] + public uint RouterPort { + get { return result.RouterPort; } + set { SetRouterPort(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetRouterPort(uint value) { + result.hasRouterPort = true; + result.routerPort_ = value; + return this; + } + public Builder ClearRouterPort() { + result.hasRouterPort = false; + result.routerPort_ = 0; + return this; + } + + public bool HasPreConnectionBuffer { + get { return result.HasPreConnectionBuffer; } + } + [global::System.CLSCompliant(false)] + public ulong PreConnectionBuffer { + get { return result.PreConnectionBuffer; } + set { SetPreConnectionBuffer(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetPreConnectionBuffer(ulong value) { + result.hasPreConnectionBuffer = true; + result.preConnectionBuffer_ = value; + return this; + } + public Builder ClearPreConnectionBuffer() { + result.hasPreConnectionBuffer = false; + result.preConnectionBuffer_ = 0UL; + return this; + } + + public bool HasMaxPreConnectionMessages { + get { return result.HasMaxPreConnectionMessages; } + } + [global::System.CLSCompliant(false)] + public ulong MaxPreConnectionMessages { + get { return result.MaxPreConnectionMessages; } + set { SetMaxPreConnectionMessages(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetMaxPreConnectionMessages(ulong value) { + result.hasMaxPreConnectionMessages = true; + result.maxPreConnectionMessages_ = value; + return this; + } + public Builder ClearMaxPreConnectionMessages() { + result.hasMaxPreConnectionMessages = false; + result.maxPreConnectionMessages_ = 0UL; + return this; + } + } + static SpaceServices() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class ObjLoc : pb::GeneratedMessage { + private static readonly ObjLoc defaultInstance = new Builder().BuildPartial(); + public static ObjLoc DefaultInstance { + get { return defaultInstance; } + } + + public override ObjLoc DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ObjLoc ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum UpdateFlags { + FORCE = 1, + } + + } + #endregion + + public const int TimestampFieldNumber = 2; + private bool hasTimestamp; + private ulong timestamp_ = 0; + public bool HasTimestamp { + get { return hasTimestamp; } + } + [global::System.CLSCompliant(false)] + public ulong Timestamp { + get { return timestamp_; } + } + + public const int PositionFieldNumber = 3; + private int positionMemoizedSerializedSize; + private pbc::PopsicleList position_ = new pbc::PopsicleList(); + public scg::IList PositionList { + get { return pbc::Lists.AsReadOnly(position_); } + } + public int PositionCount { + get { return position_.Count; } + } + public double GetPosition(int index) { + return position_[index]; + } + + public const int OrientationFieldNumber = 4; + private int orientationMemoizedSerializedSize; + private pbc::PopsicleList orientation_ = new pbc::PopsicleList(); + public scg::IList OrientationList { + get { return pbc::Lists.AsReadOnly(orientation_); } + } + public int OrientationCount { + get { return orientation_.Count; } + } + public float GetOrientation(int index) { + return orientation_[index]; + } + + public const int VelocityFieldNumber = 5; + private int velocityMemoizedSerializedSize; + private pbc::PopsicleList velocity_ = new pbc::PopsicleList(); + public scg::IList VelocityList { + get { return pbc::Lists.AsReadOnly(velocity_); } + } + public int VelocityCount { + get { return velocity_.Count; } + } + public float GetVelocity(int index) { + return velocity_[index]; + } + + public const int RotationalAxisFieldNumber = 7; + private int rotationalAxisMemoizedSerializedSize; + private pbc::PopsicleList rotationalAxis_ = new pbc::PopsicleList(); + public scg::IList RotationalAxisList { + get { return pbc::Lists.AsReadOnly(rotationalAxis_); } + } + public int RotationalAxisCount { + get { return rotationalAxis_.Count; } + } + public float GetRotationalAxis(int index) { + return rotationalAxis_[index]; + } + + public const int AngularSpeedFieldNumber = 8; + private bool hasAngularSpeed; + private float angularSpeed_ = 0F; + public bool HasAngularSpeed { + get { return hasAngularSpeed; } + } + public float AngularSpeed { + get { return angularSpeed_; } + } + + public const int UpdateFlagsFieldNumber = 6; + private bool hasUpdateFlags; + private uint updateFlags_ = 0; + public bool HasUpdateFlags { + get { return hasUpdateFlags; } + } + [global::System.CLSCompliant(false)] + public uint UpdateFlags { + get { return updateFlags_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasTimestamp) { + output.WriteFixed64(2, Timestamp); + } + if (position_.Count > 0) { + output.WriteRawVarint32(26); + output.WriteRawVarint32((uint) positionMemoizedSerializedSize); + foreach (double element in position_) { + output.WriteDoubleNoTag(element); + } + } + if (orientation_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) orientationMemoizedSerializedSize); + foreach (float element in orientation_) { + output.WriteFloatNoTag(element); + } + } + if (velocity_.Count > 0) { + output.WriteRawVarint32(42); + output.WriteRawVarint32((uint) velocityMemoizedSerializedSize); + foreach (float element in velocity_) { + output.WriteFloatNoTag(element); + } + } + if (HasUpdateFlags) { + output.WriteUInt32(6, UpdateFlags); + } + if (rotationalAxis_.Count > 0) { + output.WriteRawVarint32(58); + output.WriteRawVarint32((uint) rotationalAxisMemoizedSerializedSize); + foreach (float element in rotationalAxis_) { + output.WriteFloatNoTag(element); + } + } + if (HasAngularSpeed) { + output.WriteFloat(8, AngularSpeed); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasTimestamp) { + size += pb::CodedOutputStream.ComputeFixed64Size(2, Timestamp); + } + { + int dataSize = 0; + dataSize = 8 * position_.Count; + size += dataSize; + if (position_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + positionMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * orientation_.Count; + size += dataSize; + if (orientation_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + orientationMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * velocity_.Count; + size += dataSize; + if (velocity_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + velocityMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * rotationalAxis_.Count; + size += dataSize; + if (rotationalAxis_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + rotationalAxisMemoizedSerializedSize = dataSize; + } + if (HasAngularSpeed) { + size += pb::CodedOutputStream.ComputeFloatSize(8, AngularSpeed); + } + if (HasUpdateFlags) { + size += pb::CodedOutputStream.ComputeUInt32Size(6, UpdateFlags); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ObjLoc ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ObjLoc ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ObjLoc ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ObjLoc ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ObjLoc ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ObjLoc ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ObjLoc ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ObjLoc ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ObjLoc ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ObjLoc ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ObjLoc prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ObjLoc result = new ObjLoc(); + + protected override ObjLoc MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ObjLoc(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Descriptor; } + } + + public override ObjLoc DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; } + } + + public override ObjLoc BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.position_.MakeReadOnly(); + result.orientation_.MakeReadOnly(); + result.velocity_.MakeReadOnly(); + result.rotationalAxis_.MakeReadOnly(); + ObjLoc returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ObjLoc) { + return MergeFrom((ObjLoc) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ObjLoc other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance) return this; + if (other.HasTimestamp) { + Timestamp = other.Timestamp; + } + if (other.position_.Count != 0) { + base.AddRange(other.position_, result.position_); + } + if (other.orientation_.Count != 0) { + base.AddRange(other.orientation_, result.orientation_); + } + if (other.velocity_.Count != 0) { + base.AddRange(other.velocity_, result.velocity_); + } + if (other.rotationalAxis_.Count != 0) { + base.AddRange(other.rotationalAxis_, result.rotationalAxis_); + } + if (other.HasAngularSpeed) { + AngularSpeed = other.AngularSpeed; + } + if (other.HasUpdateFlags) { + UpdateFlags = other.UpdateFlags; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 17: { + Timestamp = input.ReadFixed64(); + break; + } + case 26: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddPosition(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddOrientation(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 42: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddVelocity(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 48: { + UpdateFlags = input.ReadUInt32(); + break; + } + case 58: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddRotationalAxis(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 69: { + AngularSpeed = input.ReadFloat(); + break; + } + } + } + } + + + public bool HasTimestamp { + get { return result.HasTimestamp; } + } + [global::System.CLSCompliant(false)] + public ulong Timestamp { + get { return result.Timestamp; } + set { SetTimestamp(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetTimestamp(ulong value) { + result.hasTimestamp = true; + result.timestamp_ = value; + return this; + } + public Builder ClearTimestamp() { + result.hasTimestamp = false; + result.timestamp_ = 0; + return this; + } + + public pbc::IPopsicleList PositionList { + get { return result.position_; } + } + public int PositionCount { + get { return result.PositionCount; } + } + public double GetPosition(int index) { + return result.GetPosition(index); + } + public Builder SetPosition(int index, double value) { + result.position_[index] = value; + return this; + } + public Builder AddPosition(double value) { + result.position_.Add(value); + return this; + } + public Builder AddRangePosition(scg::IEnumerable values) { + base.AddRange(values, result.position_); + return this; + } + public Builder ClearPosition() { + result.position_.Clear(); + return this; + } + + public pbc::IPopsicleList OrientationList { + get { return result.orientation_; } + } + public int OrientationCount { + get { return result.OrientationCount; } + } + public float GetOrientation(int index) { + return result.GetOrientation(index); + } + public Builder SetOrientation(int index, float value) { + result.orientation_[index] = value; + return this; + } + public Builder AddOrientation(float value) { + result.orientation_.Add(value); + return this; + } + public Builder AddRangeOrientation(scg::IEnumerable values) { + base.AddRange(values, result.orientation_); + return this; + } + public Builder ClearOrientation() { + result.orientation_.Clear(); + return this; + } + + public pbc::IPopsicleList VelocityList { + get { return result.velocity_; } + } + public int VelocityCount { + get { return result.VelocityCount; } + } + public float GetVelocity(int index) { + return result.GetVelocity(index); + } + public Builder SetVelocity(int index, float value) { + result.velocity_[index] = value; + return this; + } + public Builder AddVelocity(float value) { + result.velocity_.Add(value); + return this; + } + public Builder AddRangeVelocity(scg::IEnumerable values) { + base.AddRange(values, result.velocity_); + return this; + } + public Builder ClearVelocity() { + result.velocity_.Clear(); + return this; + } + + public pbc::IPopsicleList RotationalAxisList { + get { return result.rotationalAxis_; } + } + public int RotationalAxisCount { + get { return result.RotationalAxisCount; } + } + public float GetRotationalAxis(int index) { + return result.GetRotationalAxis(index); + } + public Builder SetRotationalAxis(int index, float value) { + result.rotationalAxis_[index] = value; + return this; + } + public Builder AddRotationalAxis(float value) { + result.rotationalAxis_.Add(value); + return this; + } + public Builder AddRangeRotationalAxis(scg::IEnumerable values) { + base.AddRange(values, result.rotationalAxis_); + return this; + } + public Builder ClearRotationalAxis() { + result.rotationalAxis_.Clear(); + return this; + } + + public bool HasAngularSpeed { + get { return result.HasAngularSpeed; } + } + public float AngularSpeed { + get { return result.AngularSpeed; } + set { SetAngularSpeed(value); } + } + public Builder SetAngularSpeed(float value) { + result.hasAngularSpeed = true; + result.angularSpeed_ = value; + return this; + } + public Builder ClearAngularSpeed() { + result.hasAngularSpeed = false; + result.angularSpeed_ = 0F; + return this; + } + + public bool HasUpdateFlags { + get { return result.HasUpdateFlags; } + } + [global::System.CLSCompliant(false)] + public uint UpdateFlags { + get { return result.UpdateFlags; } + set { SetUpdateFlags(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetUpdateFlags(uint value) { + result.hasUpdateFlags = true; + result.updateFlags_ = value; + return this; + } + public Builder ClearUpdateFlags() { + result.hasUpdateFlags = false; + result.updateFlags_ = 0; + return this; + } + } + static ObjLoc() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class LocRequest : pb::GeneratedMessage { + private static readonly LocRequest defaultInstance = new Builder().BuildPartial(); + public static LocRequest DefaultInstance { + get { return defaultInstance; } + } + + public override LocRequest DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override LocRequest ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum Fields { + POSITION = 1, + ORIENTATION = 2, + VELOCITY = 4, + ROTATIONAL_AXIS = 8, + ANGULAR_SPEED = 16, + } + + } + #endregion + + public const int RequestedFieldsFieldNumber = 2; + private bool hasRequestedFields; + private uint requestedFields_ = 0; + public bool HasRequestedFields { + get { return hasRequestedFields; } + } + [global::System.CLSCompliant(false)] + public uint RequestedFields { + get { return requestedFields_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasRequestedFields) { + output.WriteUInt32(2, RequestedFields); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasRequestedFields) { + size += pb::CodedOutputStream.ComputeUInt32Size(2, RequestedFields); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static LocRequest ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static LocRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static LocRequest ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static LocRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static LocRequest ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static LocRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static LocRequest ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static LocRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static LocRequest ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static LocRequest ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(LocRequest prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + LocRequest result = new LocRequest(); + + protected override LocRequest MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new LocRequest(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.LocRequest.Descriptor; } + } + + public override LocRequest DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.LocRequest.DefaultInstance; } + } + + public override LocRequest BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + LocRequest returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is LocRequest) { + return MergeFrom((LocRequest) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(LocRequest other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.LocRequest.DefaultInstance) return this; + if (other.HasRequestedFields) { + RequestedFields = other.RequestedFields; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 16: { + RequestedFields = input.ReadUInt32(); + break; + } + } + } + } + + + public bool HasRequestedFields { + get { return result.HasRequestedFields; } + } + [global::System.CLSCompliant(false)] + public uint RequestedFields { + get { return result.RequestedFields; } + set { SetRequestedFields(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetRequestedFields(uint value) { + result.hasRequestedFields = true; + result.requestedFields_ = value; + return this; + } + public Builder ClearRequestedFields() { + result.hasRequestedFields = false; + result.requestedFields_ = 0; + return this; + } + } + static LocRequest() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class NewObj : pb::GeneratedMessage { + private static readonly NewObj defaultInstance = new Builder().BuildPartial(); + public static NewObj DefaultInstance { + get { return defaultInstance; } + } + + public override NewObj DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override NewObj ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__FieldAccessorTable; } + } + + public const int ObjectUuidEvidenceFieldNumber = 2; + private bool hasObjectUuidEvidence; + private pb::ByteString objectUuidEvidence_ = pb::ByteString.Empty; + public bool HasObjectUuidEvidence { + get { return hasObjectUuidEvidence; } + } + public pb::ByteString ObjectUuidEvidence { + get { return objectUuidEvidence_; } + } + + public const int RequestedObjectLocFieldNumber = 3; + private bool hasRequestedObjectLoc; + private global::Sirikata.Protocol._PBJ_Internal.ObjLoc requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; + public bool HasRequestedObjectLoc { + get { return hasRequestedObjectLoc; } + } + public global::Sirikata.Protocol._PBJ_Internal.ObjLoc RequestedObjectLoc { + get { return requestedObjectLoc_; } + } + + public const int BoundingSphereFieldNumber = 4; + private int boundingSphereMemoizedSerializedSize; + private pbc::PopsicleList boundingSphere_ = new pbc::PopsicleList(); + public scg::IList BoundingSphereList { + get { return pbc::Lists.AsReadOnly(boundingSphere_); } + } + public int BoundingSphereCount { + get { return boundingSphere_.Count; } + } + public float GetBoundingSphere(int index) { + return boundingSphere_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasObjectUuidEvidence) { + output.WriteBytes(2, ObjectUuidEvidence); + } + if (HasRequestedObjectLoc) { + output.WriteMessage(3, RequestedObjectLoc); + } + if (boundingSphere_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) boundingSphereMemoizedSerializedSize); + foreach (float element in boundingSphere_) { + output.WriteFloatNoTag(element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasObjectUuidEvidence) { + size += pb::CodedOutputStream.ComputeBytesSize(2, ObjectUuidEvidence); + } + if (HasRequestedObjectLoc) { + size += pb::CodedOutputStream.ComputeMessageSize(3, RequestedObjectLoc); + } + { + int dataSize = 0; + dataSize = 4 * boundingSphere_.Count; + size += dataSize; + if (boundingSphere_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + boundingSphereMemoizedSerializedSize = dataSize; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static NewObj ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NewObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NewObj ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NewObj ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NewObj ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NewObj ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static NewObj ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static NewObj ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static NewObj ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NewObj ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(NewObj prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + NewObj result = new NewObj(); + + protected override NewObj MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new NewObj(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.NewObj.Descriptor; } + } + + public override NewObj DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.NewObj.DefaultInstance; } + } + + public override NewObj BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.boundingSphere_.MakeReadOnly(); + NewObj returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is NewObj) { + return MergeFrom((NewObj) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(NewObj other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.NewObj.DefaultInstance) return this; + if (other.HasObjectUuidEvidence) { + ObjectUuidEvidence = other.ObjectUuidEvidence; + } + if (other.HasRequestedObjectLoc) { + MergeRequestedObjectLoc(other.RequestedObjectLoc); + } + if (other.boundingSphere_.Count != 0) { + base.AddRange(other.boundingSphere_, result.boundingSphere_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 18: { + ObjectUuidEvidence = input.ReadBytes(); + break; + } + case 26: { + global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(); + if (HasRequestedObjectLoc) { + subBuilder.MergeFrom(RequestedObjectLoc); + } + input.ReadMessage(subBuilder, extensionRegistry); + RequestedObjectLoc = subBuilder.BuildPartial(); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddBoundingSphere(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + } + } + } + + + public bool HasObjectUuidEvidence { + get { return result.HasObjectUuidEvidence; } + } + public pb::ByteString ObjectUuidEvidence { + get { return result.ObjectUuidEvidence; } + set { SetObjectUuidEvidence(value); } + } + public Builder SetObjectUuidEvidence(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectUuidEvidence = true; + result.objectUuidEvidence_ = value; + return this; + } + public Builder ClearObjectUuidEvidence() { + result.hasObjectUuidEvidence = false; + result.objectUuidEvidence_ = pb::ByteString.Empty; + return this; + } + + public bool HasRequestedObjectLoc { + get { return result.HasRequestedObjectLoc; } + } + public global::Sirikata.Protocol._PBJ_Internal.ObjLoc RequestedObjectLoc { + get { return result.RequestedObjectLoc; } + set { SetRequestedObjectLoc(value); } + } + public Builder SetRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasRequestedObjectLoc = true; + result.requestedObjectLoc_ = value; + return this; + } + public Builder SetRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasRequestedObjectLoc = true; + result.requestedObjectLoc_ = builderForValue.Build(); + return this; + } + public Builder MergeRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasRequestedObjectLoc && + result.requestedObjectLoc_ != global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance) { + result.requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(result.requestedObjectLoc_).MergeFrom(value).BuildPartial(); + } else { + result.requestedObjectLoc_ = value; + } + result.hasRequestedObjectLoc = true; + return this; + } + public Builder ClearRequestedObjectLoc() { + result.hasRequestedObjectLoc = false; + result.requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; + return this; + } + + public pbc::IPopsicleList BoundingSphereList { + get { return result.boundingSphere_; } + } + public int BoundingSphereCount { + get { return result.BoundingSphereCount; } + } + public float GetBoundingSphere(int index) { + return result.GetBoundingSphere(index); + } + public Builder SetBoundingSphere(int index, float value) { + result.boundingSphere_[index] = value; + return this; + } + public Builder AddBoundingSphere(float value) { + result.boundingSphere_.Add(value); + return this; + } + public Builder AddRangeBoundingSphere(scg::IEnumerable values) { + base.AddRange(values, result.boundingSphere_); + return this; + } + public Builder ClearBoundingSphere() { + result.boundingSphere_.Clear(); + return this; + } + } + static NewObj() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class RetObj : pb::GeneratedMessage { + private static readonly RetObj defaultInstance = new Builder().BuildPartial(); + public static RetObj DefaultInstance { + get { return defaultInstance; } + } + + public override RetObj DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override RetObj ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__FieldAccessorTable; } + } + + public const int ObjectReferenceFieldNumber = 2; + private bool hasObjectReference; + private pb::ByteString objectReference_ = pb::ByteString.Empty; + public bool HasObjectReference { + get { return hasObjectReference; } + } + public pb::ByteString ObjectReference { + get { return objectReference_; } + } + + public const int LocationFieldNumber = 3; + private bool hasLocation; + private global::Sirikata.Protocol._PBJ_Internal.ObjLoc location_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; + public bool HasLocation { + get { return hasLocation; } + } + public global::Sirikata.Protocol._PBJ_Internal.ObjLoc Location { + get { return location_; } + } + + public const int BoundingSphereFieldNumber = 4; + private int boundingSphereMemoizedSerializedSize; + private pbc::PopsicleList boundingSphere_ = new pbc::PopsicleList(); + public scg::IList BoundingSphereList { + get { return pbc::Lists.AsReadOnly(boundingSphere_); } + } + public int BoundingSphereCount { + get { return boundingSphere_.Count; } + } + public float GetBoundingSphere(int index) { + return boundingSphere_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasObjectReference) { + output.WriteBytes(2, ObjectReference); + } + if (HasLocation) { + output.WriteMessage(3, Location); + } + if (boundingSphere_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) boundingSphereMemoizedSerializedSize); + foreach (float element in boundingSphere_) { + output.WriteFloatNoTag(element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasObjectReference) { + size += pb::CodedOutputStream.ComputeBytesSize(2, ObjectReference); + } + if (HasLocation) { + size += pb::CodedOutputStream.ComputeMessageSize(3, Location); + } + { + int dataSize = 0; + dataSize = 4 * boundingSphere_.Count; + size += dataSize; + if (boundingSphere_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + boundingSphereMemoizedSerializedSize = dataSize; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static RetObj ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RetObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RetObj ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RetObj ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RetObj ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RetObj ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static RetObj ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static RetObj ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static RetObj ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RetObj ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(RetObj prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + RetObj result = new RetObj(); + + protected override RetObj MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new RetObj(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.RetObj.Descriptor; } + } + + public override RetObj DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.RetObj.DefaultInstance; } + } + + public override RetObj BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.boundingSphere_.MakeReadOnly(); + RetObj returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is RetObj) { + return MergeFrom((RetObj) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(RetObj other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.RetObj.DefaultInstance) return this; + if (other.HasObjectReference) { + ObjectReference = other.ObjectReference; + } + if (other.HasLocation) { + MergeLocation(other.Location); + } + if (other.boundingSphere_.Count != 0) { + base.AddRange(other.boundingSphere_, result.boundingSphere_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 18: { + ObjectReference = input.ReadBytes(); + break; + } + case 26: { + global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(); + if (HasLocation) { + subBuilder.MergeFrom(Location); + } + input.ReadMessage(subBuilder, extensionRegistry); + Location = subBuilder.BuildPartial(); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddBoundingSphere(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + } + } + } + + + public bool HasObjectReference { + get { return result.HasObjectReference; } + } + public pb::ByteString ObjectReference { + get { return result.ObjectReference; } + set { SetObjectReference(value); } + } + public Builder SetObjectReference(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectReference = true; + result.objectReference_ = value; + return this; + } + public Builder ClearObjectReference() { + result.hasObjectReference = false; + result.objectReference_ = pb::ByteString.Empty; + return this; + } + + public bool HasLocation { + get { return result.HasLocation; } + } + public global::Sirikata.Protocol._PBJ_Internal.ObjLoc Location { + get { return result.Location; } + set { SetLocation(value); } + } + public Builder SetLocation(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasLocation = true; + result.location_ = value; + return this; + } + public Builder SetLocation(global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasLocation = true; + result.location_ = builderForValue.Build(); + return this; + } + public Builder MergeLocation(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasLocation && + result.location_ != global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance) { + result.location_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(result.location_).MergeFrom(value).BuildPartial(); + } else { + result.location_ = value; + } + result.hasLocation = true; + return this; + } + public Builder ClearLocation() { + result.hasLocation = false; + result.location_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; + return this; + } + + public pbc::IPopsicleList BoundingSphereList { + get { return result.boundingSphere_; } + } + public int BoundingSphereCount { + get { return result.BoundingSphereCount; } + } + public float GetBoundingSphere(int index) { + return result.GetBoundingSphere(index); + } + public Builder SetBoundingSphere(int index, float value) { + result.boundingSphere_[index] = value; + return this; + } + public Builder AddBoundingSphere(float value) { + result.boundingSphere_.Add(value); + return this; + } + public Builder AddRangeBoundingSphere(scg::IEnumerable values) { + base.AddRange(values, result.boundingSphere_); + return this; + } + public Builder ClearBoundingSphere() { + result.boundingSphere_.Clear(); + return this; + } + } + static RetObj() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class DelObj : pb::GeneratedMessage { + private static readonly DelObj defaultInstance = new Builder().BuildPartial(); + public static DelObj DefaultInstance { + get { return defaultInstance; } + } + + public override DelObj DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override DelObj ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__FieldAccessorTable; } + } + + public const int ObjectReferenceFieldNumber = 2; + private bool hasObjectReference; + private pb::ByteString objectReference_ = pb::ByteString.Empty; + public bool HasObjectReference { + get { return hasObjectReference; } + } + public pb::ByteString ObjectReference { + get { return objectReference_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasObjectReference) { + output.WriteBytes(2, ObjectReference); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasObjectReference) { + size += pb::CodedOutputStream.ComputeBytesSize(2, ObjectReference); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static DelObj ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DelObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DelObj ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DelObj ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DelObj ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DelObj ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static DelObj ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static DelObj ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static DelObj ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DelObj ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(DelObj prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + DelObj result = new DelObj(); + + protected override DelObj MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new DelObj(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.DelObj.Descriptor; } + } + + public override DelObj DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.DelObj.DefaultInstance; } + } + + public override DelObj BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + DelObj returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is DelObj) { + return MergeFrom((DelObj) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(DelObj other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.DelObj.DefaultInstance) return this; + if (other.HasObjectReference) { + ObjectReference = other.ObjectReference; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 18: { + ObjectReference = input.ReadBytes(); + break; + } + } + } + } + + + public bool HasObjectReference { + get { return result.HasObjectReference; } + } + public pb::ByteString ObjectReference { + get { return result.ObjectReference; } + set { SetObjectReference(value); } + } + public Builder SetObjectReference(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectReference = true; + result.objectReference_ = value; + return this; + } + public Builder ClearObjectReference() { + result.hasObjectReference = false; + result.objectReference_ = pb::ByteString.Empty; + return this; + } + } + static DelObj() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class NewProxQuery : pb::GeneratedMessage { + private static readonly NewProxQuery defaultInstance = new Builder().BuildPartial(); + public static NewProxQuery DefaultInstance { + get { return defaultInstance; } + } + + public override NewProxQuery DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override NewProxQuery ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__FieldAccessorTable; } + } + + public const int QueryIdFieldNumber = 2; + private bool hasQueryId; + private uint queryId_ = 0; + public bool HasQueryId { + get { return hasQueryId; } + } + [global::System.CLSCompliant(false)] + public uint QueryId { + get { return queryId_; } + } + + public const int StatelessFieldNumber = 3; + private bool hasStateless; + private bool stateless_ = false; + public bool HasStateless { + get { return hasStateless; } + } + public bool Stateless { + get { return stateless_; } + } + + public const int RelativeCenterFieldNumber = 4; + private int relativeCenterMemoizedSerializedSize; + private pbc::PopsicleList relativeCenter_ = new pbc::PopsicleList(); + public scg::IList RelativeCenterList { + get { return pbc::Lists.AsReadOnly(relativeCenter_); } + } + public int RelativeCenterCount { + get { return relativeCenter_.Count; } + } + public float GetRelativeCenter(int index) { + return relativeCenter_[index]; + } + + public const int AbsoluteCenterFieldNumber = 5; + private int absoluteCenterMemoizedSerializedSize; + private pbc::PopsicleList absoluteCenter_ = new pbc::PopsicleList(); + public scg::IList AbsoluteCenterList { + get { return pbc::Lists.AsReadOnly(absoluteCenter_); } + } + public int AbsoluteCenterCount { + get { return absoluteCenter_.Count; } + } + public double GetAbsoluteCenter(int index) { + return absoluteCenter_[index]; + } + + public const int MaxRadiusFieldNumber = 6; + private bool hasMaxRadius; + private float maxRadius_ = 0F; + public bool HasMaxRadius { + get { return hasMaxRadius; } + } + public float MaxRadius { + get { return maxRadius_; } + } + + public const int MinSolidAngleFieldNumber = 7; + private bool hasMinSolidAngle; + private float minSolidAngle_ = 0F; + public bool HasMinSolidAngle { + get { return hasMinSolidAngle; } + } + public float MinSolidAngle { + get { return minSolidAngle_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasQueryId) { + output.WriteUInt32(2, QueryId); + } + if (HasStateless) { + output.WriteBool(3, Stateless); + } + if (relativeCenter_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) relativeCenterMemoizedSerializedSize); + foreach (float element in relativeCenter_) { + output.WriteFloatNoTag(element); + } + } + if (absoluteCenter_.Count > 0) { + output.WriteRawVarint32(42); + output.WriteRawVarint32((uint) absoluteCenterMemoizedSerializedSize); + foreach (double element in absoluteCenter_) { + output.WriteDoubleNoTag(element); + } + } + if (HasMaxRadius) { + output.WriteFloat(6, MaxRadius); + } + if (HasMinSolidAngle) { + output.WriteFloat(7, MinSolidAngle); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasQueryId) { + size += pb::CodedOutputStream.ComputeUInt32Size(2, QueryId); + } + if (HasStateless) { + size += pb::CodedOutputStream.ComputeBoolSize(3, Stateless); + } + { + int dataSize = 0; + dataSize = 4 * relativeCenter_.Count; + size += dataSize; + if (relativeCenter_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + relativeCenterMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 8 * absoluteCenter_.Count; + size += dataSize; + if (absoluteCenter_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + absoluteCenterMemoizedSerializedSize = dataSize; + } + if (HasMaxRadius) { + size += pb::CodedOutputStream.ComputeFloatSize(6, MaxRadius); + } + if (HasMinSolidAngle) { + size += pb::CodedOutputStream.ComputeFloatSize(7, MinSolidAngle); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static NewProxQuery ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NewProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NewProxQuery ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NewProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NewProxQuery ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NewProxQuery ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static NewProxQuery ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static NewProxQuery ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static NewProxQuery ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NewProxQuery ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(NewProxQuery prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + NewProxQuery result = new NewProxQuery(); + + protected override NewProxQuery MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new NewProxQuery(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.NewProxQuery.Descriptor; } + } + + public override NewProxQuery DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.NewProxQuery.DefaultInstance; } + } + + public override NewProxQuery BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.relativeCenter_.MakeReadOnly(); + result.absoluteCenter_.MakeReadOnly(); + NewProxQuery returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is NewProxQuery) { + return MergeFrom((NewProxQuery) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(NewProxQuery other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.NewProxQuery.DefaultInstance) return this; + if (other.HasQueryId) { + QueryId = other.QueryId; + } + if (other.HasStateless) { + Stateless = other.Stateless; + } + if (other.relativeCenter_.Count != 0) { + base.AddRange(other.relativeCenter_, result.relativeCenter_); + } + if (other.absoluteCenter_.Count != 0) { + base.AddRange(other.absoluteCenter_, result.absoluteCenter_); + } + if (other.HasMaxRadius) { + MaxRadius = other.MaxRadius; + } + if (other.HasMinSolidAngle) { + MinSolidAngle = other.MinSolidAngle; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 16: { + QueryId = input.ReadUInt32(); + break; + } + case 24: { + Stateless = input.ReadBool(); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddRelativeCenter(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 42: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddAbsoluteCenter(input.ReadDouble()); + } + input.PopLimit(limit); + break; + } + case 53: { + MaxRadius = input.ReadFloat(); + break; + } + case 61: { + MinSolidAngle = input.ReadFloat(); + break; + } + } + } + } + + + public bool HasQueryId { + get { return result.HasQueryId; } + } + [global::System.CLSCompliant(false)] + public uint QueryId { + get { return result.QueryId; } + set { SetQueryId(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetQueryId(uint value) { + result.hasQueryId = true; + result.queryId_ = value; + return this; + } + public Builder ClearQueryId() { + result.hasQueryId = false; + result.queryId_ = 0; + return this; + } + + public bool HasStateless { + get { return result.HasStateless; } + } + public bool Stateless { + get { return result.Stateless; } + set { SetStateless(value); } + } + public Builder SetStateless(bool value) { + result.hasStateless = true; + result.stateless_ = value; + return this; + } + public Builder ClearStateless() { + result.hasStateless = false; + result.stateless_ = false; + return this; + } + + public pbc::IPopsicleList RelativeCenterList { + get { return result.relativeCenter_; } + } + public int RelativeCenterCount { + get { return result.RelativeCenterCount; } + } + public float GetRelativeCenter(int index) { + return result.GetRelativeCenter(index); + } + public Builder SetRelativeCenter(int index, float value) { + result.relativeCenter_[index] = value; + return this; + } + public Builder AddRelativeCenter(float value) { + result.relativeCenter_.Add(value); + return this; + } + public Builder AddRangeRelativeCenter(scg::IEnumerable values) { + base.AddRange(values, result.relativeCenter_); + return this; + } + public Builder ClearRelativeCenter() { + result.relativeCenter_.Clear(); + return this; + } + + public pbc::IPopsicleList AbsoluteCenterList { + get { return result.absoluteCenter_; } + } + public int AbsoluteCenterCount { + get { return result.AbsoluteCenterCount; } + } + public double GetAbsoluteCenter(int index) { + return result.GetAbsoluteCenter(index); + } + public Builder SetAbsoluteCenter(int index, double value) { + result.absoluteCenter_[index] = value; + return this; + } + public Builder AddAbsoluteCenter(double value) { + result.absoluteCenter_.Add(value); + return this; + } + public Builder AddRangeAbsoluteCenter(scg::IEnumerable values) { + base.AddRange(values, result.absoluteCenter_); + return this; + } + public Builder ClearAbsoluteCenter() { + result.absoluteCenter_.Clear(); + return this; + } + + public bool HasMaxRadius { + get { return result.HasMaxRadius; } + } + public float MaxRadius { + get { return result.MaxRadius; } + set { SetMaxRadius(value); } + } + public Builder SetMaxRadius(float value) { + result.hasMaxRadius = true; + result.maxRadius_ = value; + return this; + } + public Builder ClearMaxRadius() { + result.hasMaxRadius = false; + result.maxRadius_ = 0F; + return this; + } + + public bool HasMinSolidAngle { + get { return result.HasMinSolidAngle; } + } + public float MinSolidAngle { + get { return result.MinSolidAngle; } + set { SetMinSolidAngle(value); } + } + public Builder SetMinSolidAngle(float value) { + result.hasMinSolidAngle = true; + result.minSolidAngle_ = value; + return this; + } + public Builder ClearMinSolidAngle() { + result.hasMinSolidAngle = false; + result.minSolidAngle_ = 0F; + return this; + } + } + static NewProxQuery() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class ProxCall : pb::GeneratedMessage { + private static readonly ProxCall defaultInstance = new Builder().BuildPartial(); + public static ProxCall DefaultInstance { + get { return defaultInstance; } + } + + public override ProxCall DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ProxCall ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum ProximityEvent { + EXITED_PROXIMITY = 0, + ENTERED_PROXIMITY = 1, + STATELESS_PROXIMITY = 2, + } + + } + #endregion + + public const int QueryIdFieldNumber = 2; + private bool hasQueryId; + private uint queryId_ = 0; + public bool HasQueryId { + get { return hasQueryId; } + } + [global::System.CLSCompliant(false)] + public uint QueryId { + get { return queryId_; } + } + + public const int ProximateObjectFieldNumber = 3; + private bool hasProximateObject; + private pb::ByteString proximateObject_ = pb::ByteString.Empty; + public bool HasProximateObject { + get { return hasProximateObject; } + } + public pb::ByteString ProximateObject { + get { return proximateObject_; } + } + + public const int ProximityEventFieldNumber = 4; + private bool hasProximityEvent; + private global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent proximityEvent_ = global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent.EXITED_PROXIMITY; + public bool HasProximityEvent { + get { return hasProximityEvent; } + } + public global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent ProximityEvent { + get { return proximityEvent_; } + } + + public override bool IsInitialized { + get { + if (!hasQueryId) return false; + if (!hasProximateObject) return false; + if (!hasProximityEvent) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasQueryId) { + output.WriteUInt32(2, QueryId); + } + if (HasProximateObject) { + output.WriteBytes(3, ProximateObject); + } + if (HasProximityEvent) { + output.WriteEnum(4, (int) ProximityEvent); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasQueryId) { + size += pb::CodedOutputStream.ComputeUInt32Size(2, QueryId); + } + if (HasProximateObject) { + size += pb::CodedOutputStream.ComputeBytesSize(3, ProximateObject); + } + if (HasProximityEvent) { + size += pb::CodedOutputStream.ComputeEnumSize(4, (int) ProximityEvent); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ProxCall ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ProxCall ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ProxCall ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ProxCall ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ProxCall ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ProxCall ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ProxCall ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ProxCall ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ProxCall ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ProxCall ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ProxCall prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ProxCall result = new ProxCall(); + + protected override ProxCall MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ProxCall(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ProxCall.Descriptor; } + } + + public override ProxCall DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ProxCall.DefaultInstance; } + } + + public override ProxCall BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + ProxCall returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ProxCall) { + return MergeFrom((ProxCall) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ProxCall other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.ProxCall.DefaultInstance) return this; + if (other.HasQueryId) { + QueryId = other.QueryId; + } + if (other.HasProximateObject) { + ProximateObject = other.ProximateObject; + } + if (other.HasProximityEvent) { + ProximityEvent = other.ProximityEvent; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 16: { + QueryId = input.ReadUInt32(); + break; + } + case 26: { + ProximateObject = input.ReadBytes(); + break; + } + case 32: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent), rawValue)) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(4, (ulong) rawValue); + } else { + ProximityEvent = (global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent) rawValue; + } + break; + } + } + } + } + + + public bool HasQueryId { + get { return result.HasQueryId; } + } + [global::System.CLSCompliant(false)] + public uint QueryId { + get { return result.QueryId; } + set { SetQueryId(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetQueryId(uint value) { + result.hasQueryId = true; + result.queryId_ = value; + return this; + } + public Builder ClearQueryId() { + result.hasQueryId = false; + result.queryId_ = 0; + return this; + } + + public bool HasProximateObject { + get { return result.HasProximateObject; } + } + public pb::ByteString ProximateObject { + get { return result.ProximateObject; } + set { SetProximateObject(value); } + } + public Builder SetProximateObject(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasProximateObject = true; + result.proximateObject_ = value; + return this; + } + public Builder ClearProximateObject() { + result.hasProximateObject = false; + result.proximateObject_ = pb::ByteString.Empty; + return this; + } + + public bool HasProximityEvent { + get { return result.HasProximityEvent; } + } + public global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent ProximityEvent { + get { return result.ProximityEvent; } + set { SetProximityEvent(value); } + } + public Builder SetProximityEvent(global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent value) { + result.hasProximityEvent = true; + result.proximityEvent_ = value; + return this; + } + public Builder ClearProximityEvent() { + result.hasProximityEvent = false; + result.proximityEvent_ = global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent.EXITED_PROXIMITY; + return this; + } + } + static ProxCall() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class DelProxQuery : pb::GeneratedMessage { + private static readonly DelProxQuery defaultInstance = new Builder().BuildPartial(); + public static DelProxQuery DefaultInstance { + get { return defaultInstance; } + } + + public override DelProxQuery DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override DelProxQuery ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__FieldAccessorTable; } + } + + public const int QueryIdFieldNumber = 2; + private bool hasQueryId; + private uint queryId_ = 0; + public bool HasQueryId { + get { return hasQueryId; } + } + [global::System.CLSCompliant(false)] + public uint QueryId { + get { return queryId_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasQueryId) { + output.WriteUInt32(2, QueryId); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasQueryId) { + size += pb::CodedOutputStream.ComputeUInt32Size(2, QueryId); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static DelProxQuery ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DelProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DelProxQuery ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DelProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DelProxQuery ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DelProxQuery ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static DelProxQuery ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static DelProxQuery ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static DelProxQuery ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DelProxQuery ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(DelProxQuery prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + DelProxQuery result = new DelProxQuery(); + + protected override DelProxQuery MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new DelProxQuery(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.DelProxQuery.Descriptor; } + } + + public override DelProxQuery DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.DelProxQuery.DefaultInstance; } + } + + public override DelProxQuery BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + DelProxQuery returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is DelProxQuery) { + return MergeFrom((DelProxQuery) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(DelProxQuery other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.DelProxQuery.DefaultInstance) return this; + if (other.HasQueryId) { + QueryId = other.QueryId; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 16: { + QueryId = input.ReadUInt32(); + break; + } + } + } + } + + + public bool HasQueryId { + get { return result.HasQueryId; } + } + [global::System.CLSCompliant(false)] + public uint QueryId { + get { return result.QueryId; } + set { SetQueryId(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetQueryId(uint value) { + result.hasQueryId = true; + result.queryId_ = value; + return this; + } + public Builder ClearQueryId() { + result.hasQueryId = false; + result.queryId_ = 0; + return this; + } + } + static DelProxQuery() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class Vector3fProperty : pb::GeneratedMessage { + private static readonly Vector3fProperty defaultInstance = new Builder().BuildPartial(); + public static Vector3fProperty DefaultInstance { + get { return defaultInstance; } + } + + public override Vector3fProperty DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Vector3fProperty ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__FieldAccessorTable; } + } + + public const int ValueFieldNumber = 10; + private int valueMemoizedSerializedSize; + private pbc::PopsicleList value_ = new pbc::PopsicleList(); + public scg::IList ValueList { + get { return pbc::Lists.AsReadOnly(value_); } + } + public int ValueCount { + get { return value_.Count; } + } + public float GetValue(int index) { + return value_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (value_.Count > 0) { + output.WriteRawVarint32(82); + output.WriteRawVarint32((uint) valueMemoizedSerializedSize); + foreach (float element in value_) { + output.WriteFloatNoTag(element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + dataSize = 4 * value_.Count; + size += dataSize; + if (value_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + valueMemoizedSerializedSize = dataSize; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Vector3fProperty ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Vector3fProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Vector3fProperty ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Vector3fProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Vector3fProperty ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Vector3fProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Vector3fProperty ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static Vector3fProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static Vector3fProperty ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Vector3fProperty ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Vector3fProperty prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Vector3fProperty result = new Vector3fProperty(); + + protected override Vector3fProperty MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Vector3fProperty(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty.Descriptor; } + } + + public override Vector3fProperty DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty.DefaultInstance; } + } + + public override Vector3fProperty BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.value_.MakeReadOnly(); + Vector3fProperty returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Vector3fProperty) { + return MergeFrom((Vector3fProperty) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Vector3fProperty other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty.DefaultInstance) return this; + if (other.value_.Count != 0) { + base.AddRange(other.value_, result.value_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 82: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddValue(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + } + } + } + + + public pbc::IPopsicleList ValueList { + get { return result.value_; } + } + public int ValueCount { + get { return result.ValueCount; } + } + public float GetValue(int index) { + return result.GetValue(index); + } + public Builder SetValue(int index, float value) { + result.value_[index] = value; + return this; + } + public Builder AddValue(float value) { + result.value_.Add(value); + return this; + } + public Builder AddRangeValue(scg::IEnumerable values) { + base.AddRange(values, result.value_); + return this; + } + public Builder ClearValue() { + result.value_.Clear(); + return this; + } + } + static Vector3fProperty() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class StringProperty : pb::GeneratedMessage { + private static readonly StringProperty defaultInstance = new Builder().BuildPartial(); + public static StringProperty DefaultInstance { + get { return defaultInstance; } + } + + public override StringProperty DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override StringProperty ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__FieldAccessorTable; } + } + + public const int ValueFieldNumber = 10; + private bool hasValue; + private string value_ = ""; + public bool HasValue { + get { return hasValue; } + } + public string Value { + get { return value_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasValue) { + output.WriteString(10, Value); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasValue) { + size += pb::CodedOutputStream.ComputeStringSize(10, Value); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static StringProperty ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StringProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StringProperty ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StringProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StringProperty ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StringProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static StringProperty ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static StringProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static StringProperty ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StringProperty ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(StringProperty prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + StringProperty result = new StringProperty(); + + protected override StringProperty MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new StringProperty(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.StringProperty.Descriptor; } + } + + public override StringProperty DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.StringProperty.DefaultInstance; } + } + + public override StringProperty BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + StringProperty returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is StringProperty) { + return MergeFrom((StringProperty) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(StringProperty other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.StringProperty.DefaultInstance) return this; + if (other.HasValue) { + Value = other.Value; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 82: { + Value = input.ReadString(); + break; + } + } + } + } + + + public bool HasValue { + get { return result.HasValue; } + } + public string Value { + get { return result.Value; } + set { SetValue(value); } + } + public Builder SetValue(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasValue = true; + result.value_ = value; + return this; + } + public Builder ClearValue() { + result.hasValue = false; + result.value_ = ""; + return this; + } + } + static StringProperty() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class StringMapProperty : pb::GeneratedMessage { + private static readonly StringMapProperty defaultInstance = new Builder().BuildPartial(); + public static StringMapProperty DefaultInstance { + get { return defaultInstance; } + } + + public override StringMapProperty DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override StringMapProperty ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__FieldAccessorTable; } + } + + public const int KeysFieldNumber = 2; + private pbc::PopsicleList keys_ = new pbc::PopsicleList(); + public scg::IList KeysList { + get { return pbc::Lists.AsReadOnly(keys_); } + } + public int KeysCount { + get { return keys_.Count; } + } + public string GetKeys(int index) { + return keys_[index]; + } + + public const int ValuesFieldNumber = 3; + private pbc::PopsicleList values_ = new pbc::PopsicleList(); + public scg::IList ValuesList { + get { return pbc::Lists.AsReadOnly(values_); } + } + public int ValuesCount { + get { return values_.Count; } + } + public string GetValues(int index) { + return values_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (keys_.Count > 0) { + foreach (string element in keys_) { + output.WriteString(2, element); + } + } + if (values_.Count > 0) { + foreach (string element in values_) { + output.WriteString(3, element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + foreach (string element in KeysList) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 1 * keys_.Count; + } + { + int dataSize = 0; + foreach (string element in ValuesList) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 1 * values_.Count; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static StringMapProperty ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StringMapProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StringMapProperty ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static StringMapProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static StringMapProperty ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StringMapProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static StringMapProperty ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static StringMapProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static StringMapProperty ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static StringMapProperty ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(StringMapProperty prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + StringMapProperty result = new StringMapProperty(); + + protected override StringMapProperty MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new StringMapProperty(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.StringMapProperty.Descriptor; } + } + + public override StringMapProperty DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.StringMapProperty.DefaultInstance; } + } + + public override StringMapProperty BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.keys_.MakeReadOnly(); + result.values_.MakeReadOnly(); + StringMapProperty returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is StringMapProperty) { + return MergeFrom((StringMapProperty) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(StringMapProperty other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.StringMapProperty.DefaultInstance) return this; + if (other.keys_.Count != 0) { + base.AddRange(other.keys_, result.keys_); + } + if (other.values_.Count != 0) { + base.AddRange(other.values_, result.values_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 18: { + AddKeys(input.ReadString()); + break; + } + case 26: { + AddValues(input.ReadString()); + break; + } + } + } + } + + + public pbc::IPopsicleList KeysList { + get { return result.keys_; } + } + public int KeysCount { + get { return result.KeysCount; } + } + public string GetKeys(int index) { + return result.GetKeys(index); + } + public Builder SetKeys(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.keys_[index] = value; + return this; + } + public Builder AddKeys(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.keys_.Add(value); + return this; + } + public Builder AddRangeKeys(scg::IEnumerable values) { + base.AddRange(values, result.keys_); + return this; + } + public Builder ClearKeys() { + result.keys_.Clear(); + return this; + } + + public pbc::IPopsicleList ValuesList { + get { return result.values_; } + } + public int ValuesCount { + get { return result.ValuesCount; } + } + public string GetValues(int index) { + return result.GetValues(index); + } + public Builder SetValues(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.values_[index] = value; + return this; + } + public Builder AddValues(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.values_.Add(value); + return this; + } + public Builder AddRangeValues(scg::IEnumerable values) { + base.AddRange(values, result.values_); + return this; + } + public Builder ClearValues() { + result.values_.Clear(); + return this; + } + } + static StringMapProperty() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class PhysicalParameters : pb::GeneratedMessage { + private static readonly PhysicalParameters defaultInstance = new Builder().BuildPartial(); + public static PhysicalParameters DefaultInstance { + get { return defaultInstance; } + } + + public override PhysicalParameters DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override PhysicalParameters ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum Mode { + NONPHYSICAL = 0, + STATIC = 1, + DYNAMICBOX = 2, + DYNAMICSPHERE = 3, + DYNAMICCYLINDER = 4, + CHARACTER = 5, + } + + } + #endregion + + public const int ModeFieldNumber = 2; + private bool hasMode; + private global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode mode_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode.NONPHYSICAL; + public bool HasMode { + get { return hasMode; } + } + public global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode Mode { + get { return mode_; } + } + + public const int DensityFieldNumber = 3; + private bool hasDensity; + private float density_ = 0F; + public bool HasDensity { + get { return hasDensity; } + } + public float Density { + get { return density_; } + } + + public const int FrictionFieldNumber = 4; + private bool hasFriction; + private float friction_ = 0F; + public bool HasFriction { + get { return hasFriction; } + } + public float Friction { + get { return friction_; } + } + + public const int BounceFieldNumber = 5; + private bool hasBounce; + private float bounce_ = 0F; + public bool HasBounce { + get { return hasBounce; } + } + public float Bounce { + get { return bounce_; } + } + + public const int HullFieldNumber = 6; + private int hullMemoizedSerializedSize; + private pbc::PopsicleList hull_ = new pbc::PopsicleList(); + public scg::IList HullList { + get { return pbc::Lists.AsReadOnly(hull_); } + } + public int HullCount { + get { return hull_.Count; } + } + public float GetHull(int index) { + return hull_[index]; + } + + public const int CollideMsgFieldNumber = 16; + private bool hasCollideMsg; + private uint collideMsg_ = 0; + public bool HasCollideMsg { + get { return hasCollideMsg; } + } + [global::System.CLSCompliant(false)] + public uint CollideMsg { + get { return collideMsg_; } + } + + public const int CollideMaskFieldNumber = 17; + private bool hasCollideMask; + private uint collideMask_ = 0; + public bool HasCollideMask { + get { return hasCollideMask; } + } + [global::System.CLSCompliant(false)] + public uint CollideMask { + get { return collideMask_; } + } + + public const int GravityFieldNumber = 18; + private bool hasGravity; + private float gravity_ = 0F; + public bool HasGravity { + get { return hasGravity; } + } + public float Gravity { + get { return gravity_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasMode) { + output.WriteEnum(2, (int) Mode); + } + if (HasDensity) { + output.WriteFloat(3, Density); + } + if (HasFriction) { + output.WriteFloat(4, Friction); + } + if (HasBounce) { + output.WriteFloat(5, Bounce); + } + if (hull_.Count > 0) { + output.WriteRawVarint32(50); + output.WriteRawVarint32((uint) hullMemoizedSerializedSize); + foreach (float element in hull_) { + output.WriteFloatNoTag(element); + } + } + if (HasCollideMsg) { + output.WriteUInt32(16, CollideMsg); + } + if (HasCollideMask) { + output.WriteUInt32(17, CollideMask); + } + if (HasGravity) { + output.WriteFloat(18, Gravity); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasMode) { + size += pb::CodedOutputStream.ComputeEnumSize(2, (int) Mode); + } + if (HasDensity) { + size += pb::CodedOutputStream.ComputeFloatSize(3, Density); + } + if (HasFriction) { + size += pb::CodedOutputStream.ComputeFloatSize(4, Friction); + } + if (HasBounce) { + size += pb::CodedOutputStream.ComputeFloatSize(5, Bounce); + } + { + int dataSize = 0; + dataSize = 4 * hull_.Count; + size += dataSize; + if (hull_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + hullMemoizedSerializedSize = dataSize; + } + if (HasCollideMsg) { + size += pb::CodedOutputStream.ComputeUInt32Size(16, CollideMsg); + } + if (HasCollideMask) { + size += pb::CodedOutputStream.ComputeUInt32Size(17, CollideMask); + } + if (HasGravity) { + size += pb::CodedOutputStream.ComputeFloatSize(18, Gravity); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static PhysicalParameters ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static PhysicalParameters ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static PhysicalParameters ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static PhysicalParameters ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static PhysicalParameters ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static PhysicalParameters ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static PhysicalParameters ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static PhysicalParameters ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static PhysicalParameters ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static PhysicalParameters ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(PhysicalParameters prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + PhysicalParameters result = new PhysicalParameters(); + + protected override PhysicalParameters MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new PhysicalParameters(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Descriptor; } + } + + public override PhysicalParameters DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance; } + } + + public override PhysicalParameters BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.hull_.MakeReadOnly(); + PhysicalParameters returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is PhysicalParameters) { + return MergeFrom((PhysicalParameters) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(PhysicalParameters other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance) return this; + if (other.HasMode) { + Mode = other.Mode; + } + if (other.HasDensity) { + Density = other.Density; + } + if (other.HasFriction) { + Friction = other.Friction; + } + if (other.HasBounce) { + Bounce = other.Bounce; + } + if (other.hull_.Count != 0) { + base.AddRange(other.hull_, result.hull_); + } + if (other.HasCollideMsg) { + CollideMsg = other.CollideMsg; + } + if (other.HasCollideMask) { + CollideMask = other.CollideMask; + } + if (other.HasGravity) { + Gravity = other.Gravity; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 16: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode), rawValue)) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(2, (ulong) rawValue); + } else { + Mode = (global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode) rawValue; + } + break; + } + case 29: { + Density = input.ReadFloat(); + break; + } + case 37: { + Friction = input.ReadFloat(); + break; + } + case 45: { + Bounce = input.ReadFloat(); + break; + } + case 50: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddHull(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 128: { + CollideMsg = input.ReadUInt32(); + break; + } + case 136: { + CollideMask = input.ReadUInt32(); + break; + } + case 149: { + Gravity = input.ReadFloat(); + break; + } + } + } + } + + + public bool HasMode { + get { return result.HasMode; } + } + public global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode Mode { + get { return result.Mode; } + set { SetMode(value); } + } + public Builder SetMode(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode value) { + result.hasMode = true; + result.mode_ = value; + return this; + } + public Builder ClearMode() { + result.hasMode = false; + result.mode_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode.NONPHYSICAL; + return this; + } + + public bool HasDensity { + get { return result.HasDensity; } + } + public float Density { + get { return result.Density; } + set { SetDensity(value); } + } + public Builder SetDensity(float value) { + result.hasDensity = true; + result.density_ = value; + return this; + } + public Builder ClearDensity() { + result.hasDensity = false; + result.density_ = 0F; + return this; + } + + public bool HasFriction { + get { return result.HasFriction; } + } + public float Friction { + get { return result.Friction; } + set { SetFriction(value); } + } + public Builder SetFriction(float value) { + result.hasFriction = true; + result.friction_ = value; + return this; + } + public Builder ClearFriction() { + result.hasFriction = false; + result.friction_ = 0F; + return this; + } + + public bool HasBounce { + get { return result.HasBounce; } + } + public float Bounce { + get { return result.Bounce; } + set { SetBounce(value); } + } + public Builder SetBounce(float value) { + result.hasBounce = true; + result.bounce_ = value; + return this; + } + public Builder ClearBounce() { + result.hasBounce = false; + result.bounce_ = 0F; + return this; + } + + public pbc::IPopsicleList HullList { + get { return result.hull_; } + } + public int HullCount { + get { return result.HullCount; } + } + public float GetHull(int index) { + return result.GetHull(index); + } + public Builder SetHull(int index, float value) { + result.hull_[index] = value; + return this; + } + public Builder AddHull(float value) { + result.hull_.Add(value); + return this; + } + public Builder AddRangeHull(scg::IEnumerable values) { + base.AddRange(values, result.hull_); + return this; + } + public Builder ClearHull() { + result.hull_.Clear(); + return this; + } + + public bool HasCollideMsg { + get { return result.HasCollideMsg; } + } + [global::System.CLSCompliant(false)] + public uint CollideMsg { + get { return result.CollideMsg; } + set { SetCollideMsg(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetCollideMsg(uint value) { + result.hasCollideMsg = true; + result.collideMsg_ = value; + return this; + } + public Builder ClearCollideMsg() { + result.hasCollideMsg = false; + result.collideMsg_ = 0; + return this; + } + + public bool HasCollideMask { + get { return result.HasCollideMask; } + } + [global::System.CLSCompliant(false)] + public uint CollideMask { + get { return result.CollideMask; } + set { SetCollideMask(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetCollideMask(uint value) { + result.hasCollideMask = true; + result.collideMask_ = value; + return this; + } + public Builder ClearCollideMask() { + result.hasCollideMask = false; + result.collideMask_ = 0; + return this; + } + + public bool HasGravity { + get { return result.HasGravity; } + } + public float Gravity { + get { return result.Gravity; } + set { SetGravity(value); } + } + public Builder SetGravity(float value) { + result.hasGravity = true; + result.gravity_ = value; + return this; + } + public Builder ClearGravity() { + result.hasGravity = false; + result.gravity_ = 0F; + return this; + } + } + static PhysicalParameters() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class LightInfoProperty : pb::GeneratedMessage { + private static readonly LightInfoProperty defaultInstance = new Builder().BuildPartial(); + public static LightInfoProperty DefaultInstance { + get { return defaultInstance; } + } + + public override LightInfoProperty DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override LightInfoProperty ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum LightTypes { + POINT = 0, + SPOTLIGHT = 1, + DIRECTIONAL = 2, + } + + } + #endregion + + public const int DiffuseColorFieldNumber = 3; + private int diffuseColorMemoizedSerializedSize; + private pbc::PopsicleList diffuseColor_ = new pbc::PopsicleList(); + public scg::IList DiffuseColorList { + get { return pbc::Lists.AsReadOnly(diffuseColor_); } + } + public int DiffuseColorCount { + get { return diffuseColor_.Count; } + } + public float GetDiffuseColor(int index) { + return diffuseColor_[index]; + } + + public const int SpecularColorFieldNumber = 4; + private int specularColorMemoizedSerializedSize; + private pbc::PopsicleList specularColor_ = new pbc::PopsicleList(); + public scg::IList SpecularColorList { + get { return pbc::Lists.AsReadOnly(specularColor_); } + } + public int SpecularColorCount { + get { return specularColor_.Count; } + } + public float GetSpecularColor(int index) { + return specularColor_[index]; + } + + public const int PowerFieldNumber = 5; + private bool hasPower; + private float power_ = 0F; + public bool HasPower { + get { return hasPower; } + } + public float Power { + get { return power_; } + } + + public const int AmbientColorFieldNumber = 6; + private int ambientColorMemoizedSerializedSize; + private pbc::PopsicleList ambientColor_ = new pbc::PopsicleList(); + public scg::IList AmbientColorList { + get { return pbc::Lists.AsReadOnly(ambientColor_); } + } + public int AmbientColorCount { + get { return ambientColor_.Count; } + } + public float GetAmbientColor(int index) { + return ambientColor_[index]; + } + + public const int ShadowColorFieldNumber = 7; + private int shadowColorMemoizedSerializedSize; + private pbc::PopsicleList shadowColor_ = new pbc::PopsicleList(); + public scg::IList ShadowColorList { + get { return pbc::Lists.AsReadOnly(shadowColor_); } + } + public int ShadowColorCount { + get { return shadowColor_.Count; } + } + public float GetShadowColor(int index) { + return shadowColor_[index]; + } + + public const int LightRangeFieldNumber = 8; + private bool hasLightRange; + private double lightRange_ = 0D; + public bool HasLightRange { + get { return hasLightRange; } + } + public double LightRange { + get { return lightRange_; } + } + + public const int ConstantFalloffFieldNumber = 9; + private bool hasConstantFalloff; + private float constantFalloff_ = 0F; + public bool HasConstantFalloff { + get { return hasConstantFalloff; } + } + public float ConstantFalloff { + get { return constantFalloff_; } + } + + public const int LinearFalloffFieldNumber = 10; + private bool hasLinearFalloff; + private float linearFalloff_ = 0F; + public bool HasLinearFalloff { + get { return hasLinearFalloff; } + } + public float LinearFalloff { + get { return linearFalloff_; } + } + + public const int QuadraticFalloffFieldNumber = 11; + private bool hasQuadraticFalloff; + private float quadraticFalloff_ = 0F; + public bool HasQuadraticFalloff { + get { return hasQuadraticFalloff; } + } + public float QuadraticFalloff { + get { return quadraticFalloff_; } + } + + public const int ConeInnerRadiansFieldNumber = 12; + private bool hasConeInnerRadians; + private float coneInnerRadians_ = 0F; + public bool HasConeInnerRadians { + get { return hasConeInnerRadians; } + } + public float ConeInnerRadians { + get { return coneInnerRadians_; } + } + + public const int ConeOuterRadiansFieldNumber = 13; + private bool hasConeOuterRadians; + private float coneOuterRadians_ = 0F; + public bool HasConeOuterRadians { + get { return hasConeOuterRadians; } + } + public float ConeOuterRadians { + get { return coneOuterRadians_; } + } + + public const int ConeFalloffFieldNumber = 14; + private bool hasConeFalloff; + private float coneFalloff_ = 0F; + public bool HasConeFalloff { + get { return hasConeFalloff; } + } + public float ConeFalloff { + get { return coneFalloff_; } + } + + public const int TypeFieldNumber = 15; + private bool hasType; + private global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes type_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes.POINT; + public bool HasType { + get { return hasType; } + } + public global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes Type { + get { return type_; } + } + + public const int CastsShadowFieldNumber = 16; + private bool hasCastsShadow; + private bool castsShadow_ = false; + public bool HasCastsShadow { + get { return hasCastsShadow; } + } + public bool CastsShadow { + get { return castsShadow_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (diffuseColor_.Count > 0) { + output.WriteRawVarint32(26); + output.WriteRawVarint32((uint) diffuseColorMemoizedSerializedSize); + foreach (float element in diffuseColor_) { + output.WriteFloatNoTag(element); + } + } + if (specularColor_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) specularColorMemoizedSerializedSize); + foreach (float element in specularColor_) { + output.WriteFloatNoTag(element); + } + } + if (HasPower) { + output.WriteFloat(5, Power); + } + if (ambientColor_.Count > 0) { + output.WriteRawVarint32(50); + output.WriteRawVarint32((uint) ambientColorMemoizedSerializedSize); + foreach (float element in ambientColor_) { + output.WriteFloatNoTag(element); + } + } + if (shadowColor_.Count > 0) { + output.WriteRawVarint32(58); + output.WriteRawVarint32((uint) shadowColorMemoizedSerializedSize); + foreach (float element in shadowColor_) { + output.WriteFloatNoTag(element); + } + } + if (HasLightRange) { + output.WriteDouble(8, LightRange); + } + if (HasConstantFalloff) { + output.WriteFloat(9, ConstantFalloff); + } + if (HasLinearFalloff) { + output.WriteFloat(10, LinearFalloff); + } + if (HasQuadraticFalloff) { + output.WriteFloat(11, QuadraticFalloff); + } + if (HasConeInnerRadians) { + output.WriteFloat(12, ConeInnerRadians); + } + if (HasConeOuterRadians) { + output.WriteFloat(13, ConeOuterRadians); + } + if (HasConeFalloff) { + output.WriteFloat(14, ConeFalloff); + } + if (HasType) { + output.WriteEnum(15, (int) Type); + } + if (HasCastsShadow) { + output.WriteBool(16, CastsShadow); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + dataSize = 4 * diffuseColor_.Count; + size += dataSize; + if (diffuseColor_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + diffuseColorMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * specularColor_.Count; + size += dataSize; + if (specularColor_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + specularColorMemoizedSerializedSize = dataSize; + } + if (HasPower) { + size += pb::CodedOutputStream.ComputeFloatSize(5, Power); + } + { + int dataSize = 0; + dataSize = 4 * ambientColor_.Count; + size += dataSize; + if (ambientColor_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + ambientColorMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + dataSize = 4 * shadowColor_.Count; + size += dataSize; + if (shadowColor_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + shadowColorMemoizedSerializedSize = dataSize; + } + if (HasLightRange) { + size += pb::CodedOutputStream.ComputeDoubleSize(8, LightRange); + } + if (HasConstantFalloff) { + size += pb::CodedOutputStream.ComputeFloatSize(9, ConstantFalloff); + } + if (HasLinearFalloff) { + size += pb::CodedOutputStream.ComputeFloatSize(10, LinearFalloff); + } + if (HasQuadraticFalloff) { + size += pb::CodedOutputStream.ComputeFloatSize(11, QuadraticFalloff); + } + if (HasConeInnerRadians) { + size += pb::CodedOutputStream.ComputeFloatSize(12, ConeInnerRadians); + } + if (HasConeOuterRadians) { + size += pb::CodedOutputStream.ComputeFloatSize(13, ConeOuterRadians); + } + if (HasConeFalloff) { + size += pb::CodedOutputStream.ComputeFloatSize(14, ConeFalloff); + } + if (HasType) { + size += pb::CodedOutputStream.ComputeEnumSize(15, (int) Type); + } + if (HasCastsShadow) { + size += pb::CodedOutputStream.ComputeBoolSize(16, CastsShadow); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static LightInfoProperty ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static LightInfoProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static LightInfoProperty ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static LightInfoProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static LightInfoProperty ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static LightInfoProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static LightInfoProperty ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static LightInfoProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static LightInfoProperty ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static LightInfoProperty ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(LightInfoProperty prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + LightInfoProperty result = new LightInfoProperty(); + + protected override LightInfoProperty MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new LightInfoProperty(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Descriptor; } + } + + public override LightInfoProperty DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance; } + } + + public override LightInfoProperty BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.diffuseColor_.MakeReadOnly(); + result.specularColor_.MakeReadOnly(); + result.ambientColor_.MakeReadOnly(); + result.shadowColor_.MakeReadOnly(); + LightInfoProperty returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is LightInfoProperty) { + return MergeFrom((LightInfoProperty) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(LightInfoProperty other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance) return this; + if (other.diffuseColor_.Count != 0) { + base.AddRange(other.diffuseColor_, result.diffuseColor_); + } + if (other.specularColor_.Count != 0) { + base.AddRange(other.specularColor_, result.specularColor_); + } + if (other.HasPower) { + Power = other.Power; + } + if (other.ambientColor_.Count != 0) { + base.AddRange(other.ambientColor_, result.ambientColor_); + } + if (other.shadowColor_.Count != 0) { + base.AddRange(other.shadowColor_, result.shadowColor_); + } + if (other.HasLightRange) { + LightRange = other.LightRange; + } + if (other.HasConstantFalloff) { + ConstantFalloff = other.ConstantFalloff; + } + if (other.HasLinearFalloff) { + LinearFalloff = other.LinearFalloff; + } + if (other.HasQuadraticFalloff) { + QuadraticFalloff = other.QuadraticFalloff; + } + if (other.HasConeInnerRadians) { + ConeInnerRadians = other.ConeInnerRadians; + } + if (other.HasConeOuterRadians) { + ConeOuterRadians = other.ConeOuterRadians; + } + if (other.HasConeFalloff) { + ConeFalloff = other.ConeFalloff; + } + if (other.HasType) { + Type = other.Type; + } + if (other.HasCastsShadow) { + CastsShadow = other.CastsShadow; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 26: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddDiffuseColor(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddSpecularColor(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 45: { + Power = input.ReadFloat(); + break; + } + case 50: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddAmbientColor(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 58: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddShadowColor(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 65: { + LightRange = input.ReadDouble(); + break; + } + case 77: { + ConstantFalloff = input.ReadFloat(); + break; + } + case 85: { + LinearFalloff = input.ReadFloat(); + break; + } + case 93: { + QuadraticFalloff = input.ReadFloat(); + break; + } + case 101: { + ConeInnerRadians = input.ReadFloat(); + break; + } + case 109: { + ConeOuterRadians = input.ReadFloat(); + break; + } + case 117: { + ConeFalloff = input.ReadFloat(); + break; + } + case 120: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes), rawValue)) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(15, (ulong) rawValue); + } else { + Type = (global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes) rawValue; + } + break; + } + case 128: { + CastsShadow = input.ReadBool(); + break; + } + } + } + } + + + public pbc::IPopsicleList DiffuseColorList { + get { return result.diffuseColor_; } + } + public int DiffuseColorCount { + get { return result.DiffuseColorCount; } + } + public float GetDiffuseColor(int index) { + return result.GetDiffuseColor(index); + } + public Builder SetDiffuseColor(int index, float value) { + result.diffuseColor_[index] = value; + return this; + } + public Builder AddDiffuseColor(float value) { + result.diffuseColor_.Add(value); + return this; + } + public Builder AddRangeDiffuseColor(scg::IEnumerable values) { + base.AddRange(values, result.diffuseColor_); + return this; + } + public Builder ClearDiffuseColor() { + result.diffuseColor_.Clear(); + return this; + } + + public pbc::IPopsicleList SpecularColorList { + get { return result.specularColor_; } + } + public int SpecularColorCount { + get { return result.SpecularColorCount; } + } + public float GetSpecularColor(int index) { + return result.GetSpecularColor(index); + } + public Builder SetSpecularColor(int index, float value) { + result.specularColor_[index] = value; + return this; + } + public Builder AddSpecularColor(float value) { + result.specularColor_.Add(value); + return this; + } + public Builder AddRangeSpecularColor(scg::IEnumerable values) { + base.AddRange(values, result.specularColor_); + return this; + } + public Builder ClearSpecularColor() { + result.specularColor_.Clear(); + return this; + } + + public bool HasPower { + get { return result.HasPower; } + } + public float Power { + get { return result.Power; } + set { SetPower(value); } + } + public Builder SetPower(float value) { + result.hasPower = true; + result.power_ = value; + return this; + } + public Builder ClearPower() { + result.hasPower = false; + result.power_ = 0F; + return this; + } + + public pbc::IPopsicleList AmbientColorList { + get { return result.ambientColor_; } + } + public int AmbientColorCount { + get { return result.AmbientColorCount; } + } + public float GetAmbientColor(int index) { + return result.GetAmbientColor(index); + } + public Builder SetAmbientColor(int index, float value) { + result.ambientColor_[index] = value; + return this; + } + public Builder AddAmbientColor(float value) { + result.ambientColor_.Add(value); + return this; + } + public Builder AddRangeAmbientColor(scg::IEnumerable values) { + base.AddRange(values, result.ambientColor_); + return this; + } + public Builder ClearAmbientColor() { + result.ambientColor_.Clear(); + return this; + } + + public pbc::IPopsicleList ShadowColorList { + get { return result.shadowColor_; } + } + public int ShadowColorCount { + get { return result.ShadowColorCount; } + } + public float GetShadowColor(int index) { + return result.GetShadowColor(index); + } + public Builder SetShadowColor(int index, float value) { + result.shadowColor_[index] = value; + return this; + } + public Builder AddShadowColor(float value) { + result.shadowColor_.Add(value); + return this; + } + public Builder AddRangeShadowColor(scg::IEnumerable values) { + base.AddRange(values, result.shadowColor_); + return this; + } + public Builder ClearShadowColor() { + result.shadowColor_.Clear(); + return this; + } + + public bool HasLightRange { + get { return result.HasLightRange; } + } + public double LightRange { + get { return result.LightRange; } + set { SetLightRange(value); } + } + public Builder SetLightRange(double value) { + result.hasLightRange = true; + result.lightRange_ = value; + return this; + } + public Builder ClearLightRange() { + result.hasLightRange = false; + result.lightRange_ = 0D; + return this; + } + + public bool HasConstantFalloff { + get { return result.HasConstantFalloff; } + } + public float ConstantFalloff { + get { return result.ConstantFalloff; } + set { SetConstantFalloff(value); } + } + public Builder SetConstantFalloff(float value) { + result.hasConstantFalloff = true; + result.constantFalloff_ = value; + return this; + } + public Builder ClearConstantFalloff() { + result.hasConstantFalloff = false; + result.constantFalloff_ = 0F; + return this; + } + + public bool HasLinearFalloff { + get { return result.HasLinearFalloff; } + } + public float LinearFalloff { + get { return result.LinearFalloff; } + set { SetLinearFalloff(value); } + } + public Builder SetLinearFalloff(float value) { + result.hasLinearFalloff = true; + result.linearFalloff_ = value; + return this; + } + public Builder ClearLinearFalloff() { + result.hasLinearFalloff = false; + result.linearFalloff_ = 0F; + return this; + } + + public bool HasQuadraticFalloff { + get { return result.HasQuadraticFalloff; } + } + public float QuadraticFalloff { + get { return result.QuadraticFalloff; } + set { SetQuadraticFalloff(value); } + } + public Builder SetQuadraticFalloff(float value) { + result.hasQuadraticFalloff = true; + result.quadraticFalloff_ = value; + return this; + } + public Builder ClearQuadraticFalloff() { + result.hasQuadraticFalloff = false; + result.quadraticFalloff_ = 0F; + return this; + } + + public bool HasConeInnerRadians { + get { return result.HasConeInnerRadians; } + } + public float ConeInnerRadians { + get { return result.ConeInnerRadians; } + set { SetConeInnerRadians(value); } + } + public Builder SetConeInnerRadians(float value) { + result.hasConeInnerRadians = true; + result.coneInnerRadians_ = value; + return this; + } + public Builder ClearConeInnerRadians() { + result.hasConeInnerRadians = false; + result.coneInnerRadians_ = 0F; + return this; + } + + public bool HasConeOuterRadians { + get { return result.HasConeOuterRadians; } + } + public float ConeOuterRadians { + get { return result.ConeOuterRadians; } + set { SetConeOuterRadians(value); } + } + public Builder SetConeOuterRadians(float value) { + result.hasConeOuterRadians = true; + result.coneOuterRadians_ = value; + return this; + } + public Builder ClearConeOuterRadians() { + result.hasConeOuterRadians = false; + result.coneOuterRadians_ = 0F; + return this; + } + + public bool HasConeFalloff { + get { return result.HasConeFalloff; } + } + public float ConeFalloff { + get { return result.ConeFalloff; } + set { SetConeFalloff(value); } + } + public Builder SetConeFalloff(float value) { + result.hasConeFalloff = true; + result.coneFalloff_ = value; + return this; + } + public Builder ClearConeFalloff() { + result.hasConeFalloff = false; + result.coneFalloff_ = 0F; + return this; + } + + public bool HasType { + get { return result.HasType; } + } + public global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes Type { + get { return result.Type; } + set { SetType(value); } + } + public Builder SetType(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes value) { + result.hasType = true; + result.type_ = value; + return this; + } + public Builder ClearType() { + result.hasType = false; + result.type_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes.POINT; + return this; + } + + public bool HasCastsShadow { + get { return result.HasCastsShadow; } + } + public bool CastsShadow { + get { return result.CastsShadow; } + set { SetCastsShadow(value); } + } + public Builder SetCastsShadow(bool value) { + result.hasCastsShadow = true; + result.castsShadow_ = value; + return this; + } + public Builder ClearCastsShadow() { + result.hasCastsShadow = false; + result.castsShadow_ = false; + return this; + } + } + static LightInfoProperty() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class ParentProperty : pb::GeneratedMessage { + private static readonly ParentProperty defaultInstance = new Builder().BuildPartial(); + public static ParentProperty DefaultInstance { + get { return defaultInstance; } + } + + public override ParentProperty DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ParentProperty ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__FieldAccessorTable; } + } + + public const int ValueFieldNumber = 10; + private bool hasValue; + private pb::ByteString value_ = pb::ByteString.Empty; + public bool HasValue { + get { return hasValue; } + } + public pb::ByteString Value { + get { return value_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasValue) { + output.WriteBytes(10, Value); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasValue) { + size += pb::CodedOutputStream.ComputeBytesSize(10, Value); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ParentProperty ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ParentProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ParentProperty ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ParentProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ParentProperty ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ParentProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ParentProperty ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ParentProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ParentProperty ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ParentProperty ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ParentProperty prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ParentProperty result = new ParentProperty(); + + protected override ParentProperty MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ParentProperty(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ParentProperty.Descriptor; } + } + + public override ParentProperty DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ParentProperty.DefaultInstance; } + } + + public override ParentProperty BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + ParentProperty returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ParentProperty) { + return MergeFrom((ParentProperty) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ParentProperty other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.ParentProperty.DefaultInstance) return this; + if (other.HasValue) { + Value = other.Value; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 82: { + Value = input.ReadBytes(); + break; + } + } + } + } + + + public bool HasValue { + get { return result.HasValue; } + } + public pb::ByteString Value { + get { return result.Value; } + set { SetValue(value); } + } + public Builder SetValue(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasValue = true; + result.value_ = value; + return this; + } + public Builder ClearValue() { + result.hasValue = false; + result.value_ = pb::ByteString.Empty; + return this; + } + } + static ParentProperty() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class UUIDListProperty : pb::GeneratedMessage { + private static readonly UUIDListProperty defaultInstance = new Builder().BuildPartial(); + public static UUIDListProperty DefaultInstance { + get { return defaultInstance; } + } + + public override UUIDListProperty DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override UUIDListProperty ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__FieldAccessorTable; } + } + + public const int ValueFieldNumber = 10; + private pbc::PopsicleList value_ = new pbc::PopsicleList(); + public scg::IList ValueList { + get { return pbc::Lists.AsReadOnly(value_); } + } + public int ValueCount { + get { return value_.Count; } + } + public pb::ByteString GetValue(int index) { + return value_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (value_.Count > 0) { + foreach (pb::ByteString element in value_) { + output.WriteBytes(10, element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + foreach (pb::ByteString element in ValueList) { + dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); + } + size += dataSize; + size += 1 * value_.Count; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static UUIDListProperty ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static UUIDListProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static UUIDListProperty ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static UUIDListProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static UUIDListProperty ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static UUIDListProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static UUIDListProperty ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static UUIDListProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static UUIDListProperty ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static UUIDListProperty ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(UUIDListProperty prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + UUIDListProperty result = new UUIDListProperty(); + + protected override UUIDListProperty MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new UUIDListProperty(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty.Descriptor; } + } + + public override UUIDListProperty DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty.DefaultInstance; } + } + + public override UUIDListProperty BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.value_.MakeReadOnly(); + UUIDListProperty returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is UUIDListProperty) { + return MergeFrom((UUIDListProperty) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(UUIDListProperty other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty.DefaultInstance) return this; + if (other.value_.Count != 0) { + base.AddRange(other.value_, result.value_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 82: { + AddValue(input.ReadBytes()); + break; + } + } + } + } + + + public pbc::IPopsicleList ValueList { + get { return result.value_; } + } + public int ValueCount { + get { return result.ValueCount; } + } + public pb::ByteString GetValue(int index) { + return result.GetValue(index); + } + public Builder SetValue(int index, pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.value_[index] = value; + return this; + } + public Builder AddValue(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.value_.Add(value); + return this; + } + public Builder AddRangeValue(scg::IEnumerable values) { + base.AddRange(values, result.value_); + return this; + } + public Builder ClearValue() { + result.value_.Clear(); + return this; + } + } + static UUIDListProperty() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class ConnectToSpace : pb::GeneratedMessage { + private static readonly ConnectToSpace defaultInstance = new Builder().BuildPartial(); + public static ConnectToSpace DefaultInstance { + get { return defaultInstance; } + } + + public override ConnectToSpace DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ConnectToSpace ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__FieldAccessorTable; } + } + + public const int SpaceIdFieldNumber = 1; + private bool hasSpaceId; + private pb::ByteString spaceId_ = pb::ByteString.Empty; + public bool HasSpaceId { + get { return hasSpaceId; } + } + public pb::ByteString SpaceId { + get { return spaceId_; } + } + + public const int ObjectUuidEvidenceFieldNumber = 2; + private bool hasObjectUuidEvidence; + private pb::ByteString objectUuidEvidence_ = pb::ByteString.Empty; + public bool HasObjectUuidEvidence { + get { return hasObjectUuidEvidence; } + } + public pb::ByteString ObjectUuidEvidence { + get { return objectUuidEvidence_; } + } + + public const int RequestedObjectLocFieldNumber = 3; + private bool hasRequestedObjectLoc; + private global::Sirikata.Protocol._PBJ_Internal.ObjLoc requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; + public bool HasRequestedObjectLoc { + get { return hasRequestedObjectLoc; } + } + public global::Sirikata.Protocol._PBJ_Internal.ObjLoc RequestedObjectLoc { + get { return requestedObjectLoc_; } + } + + public const int BoundingSphereFieldNumber = 4; + private int boundingSphereMemoizedSerializedSize; + private pbc::PopsicleList boundingSphere_ = new pbc::PopsicleList(); + public scg::IList BoundingSphereList { + get { return pbc::Lists.AsReadOnly(boundingSphere_); } + } + public int BoundingSphereCount { + get { return boundingSphere_.Count; } + } + public float GetBoundingSphere(int index) { + return boundingSphere_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasSpaceId) { + output.WriteBytes(1, SpaceId); + } + if (HasObjectUuidEvidence) { + output.WriteBytes(2, ObjectUuidEvidence); + } + if (HasRequestedObjectLoc) { + output.WriteMessage(3, RequestedObjectLoc); + } + if (boundingSphere_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) boundingSphereMemoizedSerializedSize); + foreach (float element in boundingSphere_) { + output.WriteFloatNoTag(element); + } + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasSpaceId) { + size += pb::CodedOutputStream.ComputeBytesSize(1, SpaceId); + } + if (HasObjectUuidEvidence) { + size += pb::CodedOutputStream.ComputeBytesSize(2, ObjectUuidEvidence); + } + if (HasRequestedObjectLoc) { + size += pb::CodedOutputStream.ComputeMessageSize(3, RequestedObjectLoc); + } + { + int dataSize = 0; + dataSize = 4 * boundingSphere_.Count; + size += dataSize; + if (boundingSphere_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + boundingSphereMemoizedSerializedSize = dataSize; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ConnectToSpace ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ConnectToSpace ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ConnectToSpace ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ConnectToSpace ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ConnectToSpace ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ConnectToSpace ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ConnectToSpace ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static ConnectToSpace ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static ConnectToSpace ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ConnectToSpace ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ConnectToSpace prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ConnectToSpace result = new ConnectToSpace(); + + protected override ConnectToSpace MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ConnectToSpace(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Descriptor; } + } + + public override ConnectToSpace DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.DefaultInstance; } + } + + public override ConnectToSpace BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.boundingSphere_.MakeReadOnly(); + ConnectToSpace returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ConnectToSpace) { + return MergeFrom((ConnectToSpace) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ConnectToSpace other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.DefaultInstance) return this; + if (other.HasSpaceId) { + SpaceId = other.SpaceId; + } + if (other.HasObjectUuidEvidence) { + ObjectUuidEvidence = other.ObjectUuidEvidence; + } + if (other.HasRequestedObjectLoc) { + MergeRequestedObjectLoc(other.RequestedObjectLoc); + } + if (other.boundingSphere_.Count != 0) { + base.AddRange(other.boundingSphere_, result.boundingSphere_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 10: { + SpaceId = input.ReadBytes(); + break; + } + case 18: { + ObjectUuidEvidence = input.ReadBytes(); + break; + } + case 26: { + global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(); + if (HasRequestedObjectLoc) { + subBuilder.MergeFrom(RequestedObjectLoc); + } + input.ReadMessage(subBuilder, extensionRegistry); + RequestedObjectLoc = subBuilder.BuildPartial(); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddBoundingSphere(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + } + } + } + + + public bool HasSpaceId { + get { return result.HasSpaceId; } + } + public pb::ByteString SpaceId { + get { return result.SpaceId; } + set { SetSpaceId(value); } + } + public Builder SetSpaceId(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasSpaceId = true; + result.spaceId_ = value; + return this; + } + public Builder ClearSpaceId() { + result.hasSpaceId = false; + result.spaceId_ = pb::ByteString.Empty; + return this; + } + + public bool HasObjectUuidEvidence { + get { return result.HasObjectUuidEvidence; } + } + public pb::ByteString ObjectUuidEvidence { + get { return result.ObjectUuidEvidence; } + set { SetObjectUuidEvidence(value); } + } + public Builder SetObjectUuidEvidence(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectUuidEvidence = true; + result.objectUuidEvidence_ = value; + return this; + } + public Builder ClearObjectUuidEvidence() { + result.hasObjectUuidEvidence = false; + result.objectUuidEvidence_ = pb::ByteString.Empty; + return this; + } + + public bool HasRequestedObjectLoc { + get { return result.HasRequestedObjectLoc; } + } + public global::Sirikata.Protocol._PBJ_Internal.ObjLoc RequestedObjectLoc { + get { return result.RequestedObjectLoc; } + set { SetRequestedObjectLoc(value); } + } + public Builder SetRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasRequestedObjectLoc = true; + result.requestedObjectLoc_ = value; + return this; + } + public Builder SetRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasRequestedObjectLoc = true; + result.requestedObjectLoc_ = builderForValue.Build(); + return this; + } + public Builder MergeRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasRequestedObjectLoc && + result.requestedObjectLoc_ != global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance) { + result.requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(result.requestedObjectLoc_).MergeFrom(value).BuildPartial(); + } else { + result.requestedObjectLoc_ = value; + } + result.hasRequestedObjectLoc = true; + return this; + } + public Builder ClearRequestedObjectLoc() { + result.hasRequestedObjectLoc = false; + result.requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; + return this; + } + + public pbc::IPopsicleList BoundingSphereList { + get { return result.boundingSphere_; } + } + public int BoundingSphereCount { + get { return result.BoundingSphereCount; } + } + public float GetBoundingSphere(int index) { + return result.GetBoundingSphere(index); + } + public Builder SetBoundingSphere(int index, float value) { + result.boundingSphere_[index] = value; + return this; + } + public Builder AddBoundingSphere(float value) { + result.boundingSphere_.Add(value); + return this; + } + public Builder AddRangeBoundingSphere(scg::IEnumerable values) { + base.AddRange(values, result.boundingSphere_); + return this; + } + public Builder ClearBoundingSphere() { + result.boundingSphere_.Clear(); + return this; + } + } + static ConnectToSpace() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + public sealed partial class CreateObject : pb::GeneratedMessage { + private static readonly CreateObject defaultInstance = new Builder().BuildPartial(); + public static CreateObject DefaultInstance { + get { return defaultInstance; } + } + + public override CreateObject DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CreateObject ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__FieldAccessorTable; } + } + + public const int ObjectUuidFieldNumber = 1; + private bool hasObjectUuid; + private pb::ByteString objectUuid_ = pb::ByteString.Empty; + public bool HasObjectUuid { + get { return hasObjectUuid; } + } + public pb::ByteString ObjectUuid { + get { return objectUuid_; } + } + + public const int SpacePropertiesFieldNumber = 2; + private pbc::PopsicleList spaceProperties_ = new pbc::PopsicleList(); + public scg::IList SpacePropertiesList { + get { return spaceProperties_; } + } + public int SpacePropertiesCount { + get { return spaceProperties_.Count; } + } + public global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace GetSpaceProperties(int index) { + return spaceProperties_[index]; + } + + public const int MeshFieldNumber = 3; + private bool hasMesh; + private string mesh_ = ""; + public bool HasMesh { + get { return hasMesh; } + } + public string Mesh { + get { return mesh_; } + } + + public const int ScaleFieldNumber = 4; + private int scaleMemoizedSerializedSize; + private pbc::PopsicleList scale_ = new pbc::PopsicleList(); + public scg::IList ScaleList { + get { return pbc::Lists.AsReadOnly(scale_); } + } + public int ScaleCount { + get { return scale_.Count; } + } + public float GetScale(int index) { + return scale_[index]; + } + + public const int WeburlFieldNumber = 5; + private bool hasWeburl; + private string weburl_ = ""; + public bool HasWeburl { + get { return hasWeburl; } + } + public string Weburl { + get { return weburl_; } + } + + public const int LightInfoFieldNumber = 6; + private bool hasLightInfo; + private global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty lightInfo_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance; + public bool HasLightInfo { + get { return hasLightInfo; } + } + public global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty LightInfo { + get { return lightInfo_; } + } + + public const int CameraFieldNumber = 7; + private bool hasCamera; + private bool camera_ = false; + public bool HasCamera { + get { return hasCamera; } + } + public bool Camera { + get { return camera_; } + } + + public const int PhysicalFieldNumber = 8; + private bool hasPhysical; + private global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters physical_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance; + public bool HasPhysical { + get { return hasPhysical; } + } + public global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters Physical { + get { return physical_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasObjectUuid) { + output.WriteBytes(1, ObjectUuid); + } + foreach (global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace element in SpacePropertiesList) { + output.WriteMessage(2, element); + } + if (HasMesh) { + output.WriteString(3, Mesh); + } + if (scale_.Count > 0) { + output.WriteRawVarint32(34); + output.WriteRawVarint32((uint) scaleMemoizedSerializedSize); + foreach (float element in scale_) { + output.WriteFloatNoTag(element); + } + } + if (HasWeburl) { + output.WriteString(5, Weburl); + } + if (HasLightInfo) { + output.WriteMessage(6, LightInfo); + } + if (HasCamera) { + output.WriteBool(7, Camera); + } + if (HasPhysical) { + output.WriteMessage(8, Physical); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasObjectUuid) { + size += pb::CodedOutputStream.ComputeBytesSize(1, ObjectUuid); + } + foreach (global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace element in SpacePropertiesList) { + size += pb::CodedOutputStream.ComputeMessageSize(2, element); + } + if (HasMesh) { + size += pb::CodedOutputStream.ComputeStringSize(3, Mesh); + } + { + int dataSize = 0; + dataSize = 4 * scale_.Count; + size += dataSize; + if (scale_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); + scaleMemoizedSerializedSize = dataSize; + } + if (HasWeburl) { + size += pb::CodedOutputStream.ComputeStringSize(5, Weburl); + } + if (HasLightInfo) { + size += pb::CodedOutputStream.ComputeMessageSize(6, LightInfo); + } + if (HasCamera) { + size += pb::CodedOutputStream.ComputeBoolSize(7, Camera); + } + if (HasPhysical) { + size += pb::CodedOutputStream.ComputeMessageSize(8, Physical); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static CreateObject ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CreateObject ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CreateObject ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CreateObject ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CreateObject ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CreateObject ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CreateObject ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static CreateObject ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static CreateObject ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CreateObject ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(CreateObject prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CreateObject result = new CreateObject(); + + protected override CreateObject MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CreateObject(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Sirikata.Protocol._PBJ_Internal.CreateObject.Descriptor; } + } + + public override CreateObject DefaultInstanceForType { + get { return global::Sirikata.Protocol._PBJ_Internal.CreateObject.DefaultInstance; } + } + + public override CreateObject BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.spaceProperties_.MakeReadOnly(); + result.scale_.MakeReadOnly(); + CreateObject returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is CreateObject) { + return MergeFrom((CreateObject) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(CreateObject other) { + if (other == global::Sirikata.Protocol._PBJ_Internal.CreateObject.DefaultInstance) return this; + if (other.HasObjectUuid) { + ObjectUuid = other.ObjectUuid; + } + if (other.spaceProperties_.Count != 0) { + base.AddRange(other.spaceProperties_, result.spaceProperties_); + } + if (other.HasMesh) { + Mesh = other.Mesh; + } + if (other.scale_.Count != 0) { + base.AddRange(other.scale_, result.scale_); + } + if (other.HasWeburl) { + Weburl = other.Weburl; + } + if (other.HasLightInfo) { + MergeLightInfo(other.LightInfo); + } + if (other.HasCamera) { + Camera = other.Camera; + } + if (other.HasPhysical) { + MergePhysical(other.Physical); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag); + break; + } + case 10: { + ObjectUuid = input.ReadBytes(); + break; + } + case 18: { + global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddSpaceProperties(subBuilder.BuildPartial()); + break; + } + case 26: { + Mesh = input.ReadString(); + break; + } + case 34: { + int length = input.ReadInt32(); + int limit = input.PushLimit(length); + while (!input.ReachedLimit) { + AddScale(input.ReadFloat()); + } + input.PopLimit(limit); + break; + } + case 42: { + Weburl = input.ReadString(); + break; + } + case 50: { + global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.CreateBuilder(); + if (HasLightInfo) { + subBuilder.MergeFrom(LightInfo); + } + input.ReadMessage(subBuilder, extensionRegistry); + LightInfo = subBuilder.BuildPartial(); + break; + } + case 56: { + Camera = input.ReadBool(); + break; + } + case 66: { + global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.CreateBuilder(); + if (HasPhysical) { + subBuilder.MergeFrom(Physical); + } + input.ReadMessage(subBuilder, extensionRegistry); + Physical = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasObjectUuid { + get { return result.HasObjectUuid; } + } + public pb::ByteString ObjectUuid { + get { return result.ObjectUuid; } + set { SetObjectUuid(value); } + } + public Builder SetObjectUuid(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasObjectUuid = true; + result.objectUuid_ = value; + return this; + } + public Builder ClearObjectUuid() { + result.hasObjectUuid = false; + result.objectUuid_ = pb::ByteString.Empty; + return this; + } + + public pbc::IPopsicleList SpacePropertiesList { + get { return result.spaceProperties_; } + } + public int SpacePropertiesCount { + get { return result.SpacePropertiesCount; } + } + public global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace GetSpaceProperties(int index) { + return result.GetSpaceProperties(index); + } + public Builder SetSpaceProperties(int index, global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.spaceProperties_[index] = value; + return this; + } + public Builder SetSpaceProperties(int index, global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.spaceProperties_[index] = builderForValue.Build(); + return this; + } + public Builder AddSpaceProperties(global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.spaceProperties_.Add(value); + return this; + } + public Builder AddSpaceProperties(global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.spaceProperties_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeSpaceProperties(scg::IEnumerable values) { + base.AddRange(values, result.spaceProperties_); + return this; + } + public Builder ClearSpaceProperties() { + result.spaceProperties_.Clear(); + return this; + } + + public bool HasMesh { + get { return result.HasMesh; } + } + public string Mesh { + get { return result.Mesh; } + set { SetMesh(value); } + } + public Builder SetMesh(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasMesh = true; + result.mesh_ = value; + return this; + } + public Builder ClearMesh() { + result.hasMesh = false; + result.mesh_ = ""; + return this; + } + + public pbc::IPopsicleList ScaleList { + get { return result.scale_; } + } + public int ScaleCount { + get { return result.ScaleCount; } + } + public float GetScale(int index) { + return result.GetScale(index); + } + public Builder SetScale(int index, float value) { + result.scale_[index] = value; + return this; + } + public Builder AddScale(float value) { + result.scale_.Add(value); + return this; + } + public Builder AddRangeScale(scg::IEnumerable values) { + base.AddRange(values, result.scale_); + return this; + } + public Builder ClearScale() { + result.scale_.Clear(); + return this; + } + + public bool HasWeburl { + get { return result.HasWeburl; } + } + public string Weburl { + get { return result.Weburl; } + set { SetWeburl(value); } + } + public Builder SetWeburl(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasWeburl = true; + result.weburl_ = value; + return this; + } + public Builder ClearWeburl() { + result.hasWeburl = false; + result.weburl_ = ""; + return this; + } + + public bool HasLightInfo { + get { return result.HasLightInfo; } + } + public global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty LightInfo { + get { return result.LightInfo; } + set { SetLightInfo(value); } + } + public Builder SetLightInfo(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasLightInfo = true; + result.lightInfo_ = value; + return this; + } + public Builder SetLightInfo(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasLightInfo = true; + result.lightInfo_ = builderForValue.Build(); + return this; + } + public Builder MergeLightInfo(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasLightInfo && + result.lightInfo_ != global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance) { + result.lightInfo_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.CreateBuilder(result.lightInfo_).MergeFrom(value).BuildPartial(); + } else { + result.lightInfo_ = value; + } + result.hasLightInfo = true; + return this; + } + public Builder ClearLightInfo() { + result.hasLightInfo = false; + result.lightInfo_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance; + return this; + } + + public bool HasCamera { + get { return result.HasCamera; } + } + public bool Camera { + get { return result.Camera; } + set { SetCamera(value); } + } + public Builder SetCamera(bool value) { + result.hasCamera = true; + result.camera_ = value; + return this; + } + public Builder ClearCamera() { + result.hasCamera = false; + result.camera_ = false; + return this; + } + + public bool HasPhysical { + get { return result.HasPhysical; } + } + public global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters Physical { + get { return result.Physical; } + set { SetPhysical(value); } + } + public Builder SetPhysical(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + result.hasPhysical = true; + result.physical_ = value; + return this; + } + public Builder SetPhysical(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + result.hasPhysical = true; + result.physical_ = builderForValue.Build(); + return this; + } + public Builder MergePhysical(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + if (result.HasPhysical && + result.physical_ != global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance) { + result.physical_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.CreateBuilder(result.physical_).MergeFrom(value).BuildPartial(); + } else { + result.physical_ = value; + } + result.hasPhysical = true; + return this; + } + public Builder ClearPhysical() { + result.hasPhysical = false; + result.physical_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance; + return this; + } + } + static CreateObject() { + object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); + } + } + + #endregion + +} -- cgit v1.1