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

using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Sirikata.Network.Protocol._PBJ_Internal {
  
  public static partial class Time {
  
    #region Extension registration
    public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
    }
    #endregion
    #region Static variables
    internal static pbd::MessageDescriptor internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync, global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.Builder> internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__FieldAccessorTable;
    #endregion
    #region Descriptor
    public static pbd::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbd::FileDescriptor descriptor;
    
    static Time() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          "CgpUaW1lLnByb3RvEidTaXJpa2F0YS5OZXR3b3JrLlByb3RvY29sLl9QQkpf" + 
          "SW50ZXJuYWwirQEKCFRpbWVTeW5jEhMKC2NsaWVudF90aW1lGAkgASgGEhMK" + 
          "C3NlcnZlcl90aW1lGAogASgGEhIKCnN5bmNfcm91bmQYCyABKAQSFgoOcmV0" + 
          "dXJuX29wdGlvbnMYDiABKA0SEwoKcm91bmRfdHJpcBiBFCABKAYiNgoNUmV0" + 
          "dXJuT3B0aW9ucxISCg5SRVBMWV9SRUxJQUJMRRABEhEKDVJFUExZX09SREVS" + 
          "RUQQAg==");
      pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
        descriptor = root;
        internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__Descriptor = Descriptor.MessageTypes[0];
        internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync, global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.Builder>(internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__Descriptor,
                new string[] { "ClientTime", "ServerTime", "SyncRound", "ReturnOptions", "RoundTrip", });
        return null;
      };
      pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
          new pbd::FileDescriptor[] {
          }, assigner);
    }
    #endregion
    
  }
  #region Messages
  public sealed partial class TimeSync : pb::GeneratedMessage<TimeSync, TimeSync.Builder> {
    private static readonly TimeSync defaultInstance = new Builder().BuildPartial();
    public static TimeSync DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override TimeSync DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override TimeSync ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Sirikata.Network.Protocol._PBJ_Internal.Time.internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<TimeSync, TimeSync.Builder> InternalFieldAccessors {
      get { return global::Sirikata.Network.Protocol._PBJ_Internal.Time.internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__FieldAccessorTable; }
    }
    
    #region Nested types
    public static class Types {
      public enum ReturnOptions {
        REPLY_RELIABLE = 1,
        REPLY_ORDERED = 2,
      }
      
    }
    #endregion
    
    public const int ClientTimeFieldNumber = 9;
    private bool hasClientTime;
    private ulong clientTime_ = 0;
    public bool HasClientTime {
      get { return hasClientTime; }
    }
    [global::System.CLSCompliant(false)]
    public ulong ClientTime {
      get { return clientTime_; }
    }
    
    public const int ServerTimeFieldNumber = 10;
    private bool hasServerTime;
    private ulong serverTime_ = 0;
    public bool HasServerTime {
      get { return hasServerTime; }
    }
    [global::System.CLSCompliant(false)]
    public ulong ServerTime {
      get { return serverTime_; }
    }
    
    public const int SyncRoundFieldNumber = 11;
    private bool hasSyncRound;
    private ulong syncRound_ = 0UL;
    public bool HasSyncRound {
      get { return hasSyncRound; }
    }
    [global::System.CLSCompliant(false)]
    public ulong SyncRound {
      get { return syncRound_; }
    }
    
    public const int ReturnOptionsFieldNumber = 14;
    private bool hasReturnOptions;
    private uint returnOptions_ = 0;
    public bool HasReturnOptions {
      get { return hasReturnOptions; }
    }
    [global::System.CLSCompliant(false)]
    public uint ReturnOptions {
      get { return returnOptions_; }
    }
    
    public const int RoundTripFieldNumber = 2561;
    private bool hasRoundTrip;
    private ulong roundTrip_ = 0;
    public bool HasRoundTrip {
      get { return hasRoundTrip; }
    }
    [global::System.CLSCompliant(false)]
    public ulong RoundTrip {
      get { return roundTrip_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasClientTime) {
        output.WriteFixed64(9, ClientTime);
      }
      if (HasServerTime) {
        output.WriteFixed64(10, ServerTime);
      }
      if (HasSyncRound) {
        output.WriteUInt64(11, SyncRound);
      }
      if (HasReturnOptions) {
        output.WriteUInt32(14, ReturnOptions);
      }
      if (HasRoundTrip) {
        output.WriteFixed64(2561, RoundTrip);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasClientTime) {
          size += pb::CodedOutputStream.ComputeFixed64Size(9, ClientTime);
        }
        if (HasServerTime) {
          size += pb::CodedOutputStream.ComputeFixed64Size(10, ServerTime);
        }
        if (HasSyncRound) {
          size += pb::CodedOutputStream.ComputeUInt64Size(11, SyncRound);
        }
        if (HasReturnOptions) {
          size += pb::CodedOutputStream.ComputeUInt32Size(14, ReturnOptions);
        }
        if (HasRoundTrip) {
          size += pb::CodedOutputStream.ComputeFixed64Size(2561, RoundTrip);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static TimeSync ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static TimeSync ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static TimeSync ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static TimeSync ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static TimeSync ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static TimeSync ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static TimeSync ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static TimeSync ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static TimeSync ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static TimeSync ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder ToBuilder() { return CreateBuilder(this); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(TimeSync prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<TimeSync, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {}
      
      TimeSync result = new TimeSync();
      
      protected override TimeSync MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new TimeSync();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.Descriptor; }
      }
      
      public override TimeSync DefaultInstanceForType {
        get { return global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.DefaultInstance; }
      }
      
      public override TimeSync BuildPartial() {
        if (result == null) {
          throw new global::System.InvalidOperationException("build() has already been called on this Builder");
        }
        TimeSync returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is TimeSync) {
          return MergeFrom((TimeSync) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(TimeSync other) {
        if (other == global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.DefaultInstance) return this;
        if (other.HasClientTime) {
          ClientTime = other.ClientTime;
        }
        if (other.HasServerTime) {
          ServerTime = other.ServerTime;
        }
        if (other.HasSyncRound) {
          SyncRound = other.SyncRound;
        }
        if (other.HasReturnOptions) {
          ReturnOptions = other.ReturnOptions;
        }
        if (other.HasRoundTrip) {
          RoundTrip = other.RoundTrip;
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields = null;
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0: {
              if (unknownFields != null) {
                this.UnknownFields = unknownFields.Build();
              }
              return this;
            }
            default: {
              if (pb::WireFormat.IsEndGroupTag(tag)) {
                if (unknownFields != null) {
                  this.UnknownFields = unknownFields.Build();
                }
                return this;
              }
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag);
              break;
            }
            case 73: {
              ClientTime = input.ReadFixed64();
              break;
            }
            case 81: {
              ServerTime = input.ReadFixed64();
              break;
            }
            case 88: {
              SyncRound = input.ReadUInt64();
              break;
            }
            case 112: {
              ReturnOptions = input.ReadUInt32();
              break;
            }
            case 20489: {
              RoundTrip = input.ReadFixed64();
              break;
            }
          }
        }
      }
      
      
      public bool HasClientTime {
        get { return result.HasClientTime; }
      }
      [global::System.CLSCompliant(false)]
      public ulong ClientTime {
        get { return result.ClientTime; }
        set { SetClientTime(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetClientTime(ulong value) {
        result.hasClientTime = true;
        result.clientTime_ = value;
        return this;
      }
      public Builder ClearClientTime() {
        result.hasClientTime = false;
        result.clientTime_ = 0;
        return this;
      }
      
      public bool HasServerTime {
        get { return result.HasServerTime; }
      }
      [global::System.CLSCompliant(false)]
      public ulong ServerTime {
        get { return result.ServerTime; }
        set { SetServerTime(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetServerTime(ulong value) {
        result.hasServerTime = true;
        result.serverTime_ = value;
        return this;
      }
      public Builder ClearServerTime() {
        result.hasServerTime = false;
        result.serverTime_ = 0;
        return this;
      }
      
      public bool HasSyncRound {
        get { return result.HasSyncRound; }
      }
      [global::System.CLSCompliant(false)]
      public ulong SyncRound {
        get { return result.SyncRound; }
        set { SetSyncRound(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetSyncRound(ulong value) {
        result.hasSyncRound = true;
        result.syncRound_ = value;
        return this;
      }
      public Builder ClearSyncRound() {
        result.hasSyncRound = false;
        result.syncRound_ = 0UL;
        return this;
      }
      
      public bool HasReturnOptions {
        get { return result.HasReturnOptions; }
      }
      [global::System.CLSCompliant(false)]
      public uint ReturnOptions {
        get { return result.ReturnOptions; }
        set { SetReturnOptions(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetReturnOptions(uint value) {
        result.hasReturnOptions = true;
        result.returnOptions_ = value;
        return this;
      }
      public Builder ClearReturnOptions() {
        result.hasReturnOptions = false;
        result.returnOptions_ = 0;
        return this;
      }
      
      public bool HasRoundTrip {
        get { return result.HasRoundTrip; }
      }
      [global::System.CLSCompliant(false)]
      public ulong RoundTrip {
        get { return result.RoundTrip; }
        set { SetRoundTrip(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetRoundTrip(ulong value) {
        result.hasRoundTrip = true;
        result.roundTrip_ = value;
        return this;
      }
      public Builder ClearRoundTrip() {
        result.hasRoundTrip = false;
        result.roundTrip_ = 0;
        return this;
      }
    }
    static TimeSync() {
      object.ReferenceEquals(global::Sirikata.Network.Protocol._PBJ_Internal.Time.Descriptor, null);
    }
  }
  
  #endregion
  
}
