opensim/OpenSim/Client/Sirikata/Protocol/Physics.cs

// Generated by the protocol buffer compiler.  DO NOT EDIT!

using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Sirikata.Physics.Protocol._PBJ_Internal {
  
  public static partial class Physics {
  
    #region Extension registration
    public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
    }
    #endregion
    #region Static variables
    internal static pbd::MessageDescriptor internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin, global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.Builder> internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd, global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.Builder> internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__FieldAccessorTable;
    #endregion
    #region Descriptor
    public static pbd::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbd::FileDescriptor descriptor;
    
    static Physics() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          "Cg1QaHlzaWNzLnByb3RvEidTaXJpa2F0YS5QaHlzaWNzLlByb3RvY29sLl9Q" + 
          "QkpfSW50ZXJuYWwiqAEKDkNvbGxpc2lvbkJlZ2luEhEKCXRpbWVzdGFtcBgC" + 
          "IAEoBhIZCg10aGlzX3Bvc2l0aW9uGAMgAygBQgIQARIaCg5vdGhlcl9wb3Np" + 
          "dGlvbhgEIAMoAUICEAESFwoLdGhpc19ub3JtYWwYBSADKAJCAhABEhMKB2lt" + 
          "cHVsc2UYBiADKAJCAhABEh4KFm90aGVyX29iamVjdF9yZWZlcmVuY2UYByAB" + 
          "KAwiQQoMQ29sbGlzaW9uRW5kEhEKCXRpbWVzdGFtcBgCIAEoBhIeChZvdGhl" + 
          "cl9vYmplY3RfcmVmZXJlbmNlGAYgASgM");
      pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
        descriptor = root;
        internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__Descriptor = Descriptor.MessageTypes[0];
        internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin, global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.Builder>(internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__Descriptor,
                new string[] { "Timestamp", "ThisPosition", "OtherPosition", "ThisNormal", "Impulse", "OtherObjectReference", });
        internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__Descriptor = Descriptor.MessageTypes[1];
        internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd, global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.Builder>(internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__Descriptor,
                new string[] { "Timestamp", "OtherObjectReference", });
        return null;
      };
      pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
          new pbd::FileDescriptor[] {
          }, assigner);
    }
    #endregion
    
  }
  #region Messages
  public sealed partial class CollisionBegin : pb::GeneratedMessage<CollisionBegin, CollisionBegin.Builder> {
    private static readonly CollisionBegin defaultInstance = new Builder().BuildPartial();
    public static CollisionBegin DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override CollisionBegin DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override CollisionBegin ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<CollisionBegin, CollisionBegin.Builder> InternalFieldAccessors {
      get { return global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__FieldAccessorTable; }
    }
    
    public const int TimestampFieldNumber = 2;
    private bool hasTimestamp;
    private ulong timestamp_ = 0;
    public bool HasTimestamp {
      get { return hasTimestamp; }
    }
    [global::System.CLSCompliant(false)]
    public ulong Timestamp {
      get { return timestamp_; }
    }
    
    public const int ThisPositionFieldNumber = 3;
    private int thisPositionMemoizedSerializedSize;
    private pbc::PopsicleList<double> thisPosition_ = new pbc::PopsicleList<double>();
    public scg::IList<double> ThisPositionList {
      get { return pbc::Lists.AsReadOnly(thisPosition_); }
    }
    public int ThisPositionCount {
      get { return thisPosition_.Count; }
    }
    public double GetThisPosition(int index) {
      return thisPosition_[index];
    }
    
    public const int OtherPositionFieldNumber = 4;
    private int otherPositionMemoizedSerializedSize;
    private pbc::PopsicleList<double> otherPosition_ = new pbc::PopsicleList<double>();
    public scg::IList<double> OtherPositionList {
      get { return pbc::Lists.AsReadOnly(otherPosition_); }
    }
    public int OtherPositionCount {
      get { return otherPosition_.Count; }
    }
    public double GetOtherPosition(int index) {
      return otherPosition_[index];
    }
    
    public const int ThisNormalFieldNumber = 5;
    private int thisNormalMemoizedSerializedSize;
    private pbc::PopsicleList<float> thisNormal_ = new pbc::PopsicleList<float>();
    public scg::IList<float> ThisNormalList {
      get { return pbc::Lists.AsReadOnly(thisNormal_); }
    }
    public int ThisNormalCount {
      get { return thisNormal_.Count; }
    }
    public float GetThisNormal(int index) {
      return thisNormal_[index];
    }
    
    public const int ImpulseFieldNumber = 6;
    private int impulseMemoizedSerializedSize;
    private pbc::PopsicleList<float> impulse_ = new pbc::PopsicleList<float>();
    public scg::IList<float> ImpulseList {
      get { return pbc::Lists.AsReadOnly(impulse_); }
    }
    public int ImpulseCount {
      get { return impulse_.Count; }
    }
    public float GetImpulse(int index) {
      return impulse_[index];
    }
    
    public const int OtherObjectReferenceFieldNumber = 7;
    private bool hasOtherObjectReference;
    private pb::ByteString otherObjectReference_ = pb::ByteString.Empty;
    public bool HasOtherObjectReference {
      get { return hasOtherObjectReference; }
    }
    public pb::ByteString OtherObjectReference {
      get { return otherObjectReference_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasTimestamp) {
        output.WriteFixed64(2, Timestamp);
      }
      if (thisPosition_.Count > 0) {
        output.WriteRawVarint32(26);
        output.WriteRawVarint32((uint) thisPositionMemoizedSerializedSize);
        foreach (double element in thisPosition_) {
          output.WriteDoubleNoTag(element);
        }
      }
      if (otherPosition_.Count > 0) {
        output.WriteRawVarint32(34);
        output.WriteRawVarint32((uint) otherPositionMemoizedSerializedSize);
        foreach (double element in otherPosition_) {
          output.WriteDoubleNoTag(element);
        }
      }
      if (thisNormal_.Count > 0) {
        output.WriteRawVarint32(42);
        output.WriteRawVarint32((uint) thisNormalMemoizedSerializedSize);
        foreach (float element in thisNormal_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (impulse_.Count > 0) {
        output.WriteRawVarint32(50);
        output.WriteRawVarint32((uint) impulseMemoizedSerializedSize);
        foreach (float element in impulse_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (HasOtherObjectReference) {
        output.WriteBytes(7, OtherObjectReference);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasTimestamp) {
          size += pb::CodedOutputStream.ComputeFixed64Size(2, Timestamp);
        }
        {
          int dataSize = 0;
          dataSize = 8 * thisPosition_.Count;
          size += dataSize;
          if (thisPosition_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          thisPositionMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 8 * otherPosition_.Count;
          size += dataSize;
          if (otherPosition_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          otherPositionMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 4 * thisNormal_.Count;
          size += dataSize;
          if (thisNormal_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          thisNormalMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 4 * impulse_.Count;
          size += dataSize;
          if (impulse_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          impulseMemoizedSerializedSize = dataSize;
        }
        if (HasOtherObjectReference) {
          size += pb::CodedOutputStream.ComputeBytesSize(7, OtherObjectReference);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static CollisionBegin ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CollisionBegin ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CollisionBegin ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CollisionBegin ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CollisionBegin ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CollisionBegin ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static CollisionBegin ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static CollisionBegin ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static CollisionBegin ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CollisionBegin ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder ToBuilder() { return CreateBuilder(this); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(CollisionBegin prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<CollisionBegin, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {}
      
      CollisionBegin result = new CollisionBegin();
      
      protected override CollisionBegin MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new CollisionBegin();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.Descriptor; }
      }
      
      public override CollisionBegin DefaultInstanceForType {
        get { return global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.DefaultInstance; }
      }
      
      public override CollisionBegin BuildPartial() {
        if (result == null) {
          throw new global::System.InvalidOperationException("build() has already been called on this Builder");
        }
        result.thisPosition_.MakeReadOnly();
        result.otherPosition_.MakeReadOnly();
        result.thisNormal_.MakeReadOnly();
        result.impulse_.MakeReadOnly();
        CollisionBegin returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is CollisionBegin) {
          return MergeFrom((CollisionBegin) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(CollisionBegin other) {
        if (other == global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.DefaultInstance) return this;
        if (other.HasTimestamp) {
          Timestamp = other.Timestamp;
        }
        if (other.thisPosition_.Count != 0) {
          base.AddRange(other.thisPosition_, result.thisPosition_);
        }
        if (other.otherPosition_.Count != 0) {
          base.AddRange(other.otherPosition_, result.otherPosition_);
        }
        if (other.thisNormal_.Count != 0) {
          base.AddRange(other.thisNormal_, result.thisNormal_);
        }
        if (other.impulse_.Count != 0) {
          base.AddRange(other.impulse_, result.impulse_);
        }
        if (other.HasOtherObjectReference) {
          OtherObjectReference = other.OtherObjectReference;
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields = null;
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0: {
              if (unknownFields != null) {
                this.UnknownFields = unknownFields.Build();
              }
              return this;
            }
            default: {
              if (pb::WireFormat.IsEndGroupTag(tag)) {
                if (unknownFields != null) {
                  this.UnknownFields = unknownFields.Build();
                }
                return this;
              }
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag);
              break;
            }
            case 17: {
              Timestamp = input.ReadFixed64();
              break;
            }
            case 26: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddThisPosition(input.ReadDouble());
              }
              input.PopLimit(limit);
              break;
            }
            case 34: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddOtherPosition(input.ReadDouble());
              }
              input.PopLimit(limit);
              break;
            }
            case 42: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddThisNormal(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 50: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddImpulse(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 58: {
              OtherObjectReference = input.ReadBytes();
              break;
            }
          }
        }
      }
      
      
      public bool HasTimestamp {
        get { return result.HasTimestamp; }
      }
      [global::System.CLSCompliant(false)]
      public ulong Timestamp {
        get { return result.Timestamp; }
        set { SetTimestamp(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetTimestamp(ulong value) {
        result.hasTimestamp = true;
        result.timestamp_ = value;
        return this;
      }
      public Builder ClearTimestamp() {
        result.hasTimestamp = false;
        result.timestamp_ = 0;
        return this;
      }
      
      public pbc::IPopsicleList<double> ThisPositionList {
        get { return result.thisPosition_; }
      }
      public int ThisPositionCount {
        get { return result.ThisPositionCount; }
      }
      public double GetThisPosition(int index) {
        return result.GetThisPosition(index);
      }
      public Builder SetThisPosition(int index, double value) {
        result.thisPosition_[index] = value;
        return this;
      }
      public Builder AddThisPosition(double value) {
        result.thisPosition_.Add(value);
        return this;
      }
      public Builder AddRangeThisPosition(scg::IEnumerable<double> values) {
        base.AddRange(values, result.thisPosition_);
        return this;
      }
      public Builder ClearThisPosition() {
        result.thisPosition_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<double> OtherPositionList {
        get { return result.otherPosition_; }
      }
      public int OtherPositionCount {
        get { return result.OtherPositionCount; }
      }
      public double GetOtherPosition(int index) {
        return result.GetOtherPosition(index);
      }
      public Builder SetOtherPosition(int index, double value) {
        result.otherPosition_[index] = value;
        return this;
      }
      public Builder AddOtherPosition(double value) {
        result.otherPosition_.Add(value);
        return this;
      }
      public Builder AddRangeOtherPosition(scg::IEnumerable<double> values) {
        base.AddRange(values, result.otherPosition_);
        return this;
      }
      public Builder ClearOtherPosition() {
        result.otherPosition_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<float> ThisNormalList {
        get { return result.thisNormal_; }
      }
      public int ThisNormalCount {
        get { return result.ThisNormalCount; }
      }
      public float GetThisNormal(int index) {
        return result.GetThisNormal(index);
      }
      public Builder SetThisNormal(int index, float value) {
        result.thisNormal_[index] = value;
        return this;
      }
      public Builder AddThisNormal(float value) {
        result.thisNormal_.Add(value);
        return this;
      }
      public Builder AddRangeThisNormal(scg::IEnumerable<float> values) {
        base.AddRange(values, result.thisNormal_);
        return this;
      }
      public Builder ClearThisNormal() {
        result.thisNormal_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<float> ImpulseList {
        get { return result.impulse_; }
      }
      public int ImpulseCount {
        get { return result.ImpulseCount; }
      }
      public float GetImpulse(int index) {
        return result.GetImpulse(index);
      }
      public Builder SetImpulse(int index, float value) {
        result.impulse_[index] = value;
        return this;
      }
      public Builder AddImpulse(float value) {
        result.impulse_.Add(value);
        return this;
      }
      public Builder AddRangeImpulse(scg::IEnumerable<float> values) {
        base.AddRange(values, result.impulse_);
        return this;
      }
      public Builder ClearImpulse() {
        result.impulse_.Clear();
        return this;
      }
      
      public bool HasOtherObjectReference {
        get { return result.HasOtherObjectReference; }
      }
      public pb::ByteString OtherObjectReference {
        get { return result.OtherObjectReference; }
        set { SetOtherObjectReference(value); }
      }
      public Builder SetOtherObjectReference(pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasOtherObjectReference = true;
        result.otherObjectReference_ = value;
        return this;
      }
      public Builder ClearOtherObjectReference() {
        result.hasOtherObjectReference = false;
        result.otherObjectReference_ = pb::ByteString.Empty;
        return this;
      }
    }
    static CollisionBegin() {
      object.ReferenceEquals(global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.Descriptor, null);
    }
  }
  
  public sealed partial class CollisionEnd : pb::GeneratedMessage<CollisionEnd, CollisionEnd.Builder> {
    private static readonly CollisionEnd defaultInstance = new Builder().BuildPartial();
    public static CollisionEnd DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override CollisionEnd DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override CollisionEnd ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<CollisionEnd, CollisionEnd.Builder> InternalFieldAccessors {
      get { return global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__FieldAccessorTable; }
    }
    
    public const int TimestampFieldNumber = 2;
    private bool hasTimestamp;
    private ulong timestamp_ = 0;
    public bool HasTimestamp {
      get { return hasTimestamp; }
    }
    [global::System.CLSCompliant(false)]
    public ulong Timestamp {
      get { return timestamp_; }
    }
    
    public const int OtherObjectReferenceFieldNumber = 6;
    private bool hasOtherObjectReference;
    private pb::ByteString otherObjectReference_ = pb::ByteString.Empty;
    public bool HasOtherObjectReference {
      get { return hasOtherObjectReference; }
    }
    public pb::ByteString OtherObjectReference {
      get { return otherObjectReference_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasTimestamp) {
        output.WriteFixed64(2, Timestamp);
      }
      if (HasOtherObjectReference) {
        output.WriteBytes(6, OtherObjectReference);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasTimestamp) {
          size += pb::CodedOutputStream.ComputeFixed64Size(2, Timestamp);
        }
        if (HasOtherObjectReference) {
          size += pb::CodedOutputStream.ComputeBytesSize(6, OtherObjectReference);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static CollisionEnd ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CollisionEnd ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CollisionEnd ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CollisionEnd ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CollisionEnd ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CollisionEnd ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static CollisionEnd ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static CollisionEnd ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static CollisionEnd ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CollisionEnd ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder ToBuilder() { return CreateBuilder(this); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(CollisionEnd prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<CollisionEnd, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {}
      
      CollisionEnd result = new CollisionEnd();
      
      protected override CollisionEnd MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new CollisionEnd();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.Descriptor; }
      }
      
      public override CollisionEnd DefaultInstanceForType {
        get { return global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.DefaultInstance; }
      }
      
      public override CollisionEnd BuildPartial() {
        if (result == null) {
          throw new global::System.InvalidOperationException("build() has already been called on this Builder");
        }
        CollisionEnd returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is CollisionEnd) {
          return MergeFrom((CollisionEnd) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(CollisionEnd other) {
        if (other == global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.DefaultInstance) return this;
        if (other.HasTimestamp) {
          Timestamp = other.Timestamp;
        }
        if (other.HasOtherObjectReference) {
          OtherObjectReference = other.OtherObjectReference;
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields = null;
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0: {
              if (unknownFields != null) {
                this.UnknownFields = unknownFields.Build();
              }
              return this;
            }
            default: {
              if (pb::WireFormat.IsEndGroupTag(tag)) {
                if (unknownFields != null) {
                  this.UnknownFields = unknownFields.Build();
                }
                return this;
              }
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag);
              break;
            }
            case 17: {
              Timestamp = input.ReadFixed64();
              break;
            }
            case 50: {
              OtherObjectReference = input.ReadBytes();
              break;
            }
          }
        }
      }
      
      
      public bool HasTimestamp {
        get { return result.HasTimestamp; }
      }
      [global::System.CLSCompliant(false)]
      public ulong Timestamp {
        get { return result.Timestamp; }
        set { SetTimestamp(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetTimestamp(ulong value) {
        result.hasTimestamp = true;
        result.timestamp_ = value;
        return this;
      }
      public Builder ClearTimestamp() {
        result.hasTimestamp = false;
        result.timestamp_ = 0;
        return this;
      }
      
      public bool HasOtherObjectReference {
        get { return result.HasOtherObjectReference; }
      }
      public pb::ByteString OtherObjectReference {
        get { return result.OtherObjectReference; }
        set { SetOtherObjectReference(value); }
      }
      public Builder SetOtherObjectReference(pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasOtherObjectReference = true;
        result.otherObjectReference_ = value;
        return this;
      }
      public Builder ClearOtherObjectReference() {
        result.hasOtherObjectReference = false;
        result.otherObjectReference_ = pb::ByteString.Empty;
        return this;
      }
    }
    static CollisionEnd() {
      object.ReferenceEquals(global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.Descriptor, null);
    }
  }
  
  #endregion
  
}