/proto_src/org/waveprotocol/wave/diff/Diff.java

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: org/waveprotocol/wave/diff/diff.proto

package org.waveprotocol.wave.diff;

public final class Diff {
  private Diff() {}
  public static void registerAllExtensions(
      com.google.protobuf.ExtensionRegistry registry) {
  }
  public static final class FetchDiffRequest extends
      com.google.protobuf.GeneratedMessage {
    // Use FetchDiffRequest.newBuilder() to construct.
    private FetchDiffRequest() {
      initFields();
    }
    private FetchDiffRequest(boolean noInit) {}
    
    private static final FetchDiffRequest defaultInstance;
    public static FetchDiffRequest getDefaultInstance() {
      return defaultInstance;
    }
    
    public FetchDiffRequest getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return org.waveprotocol.wave.diff.Diff.internal_static_diff_FetchDiffRequest_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return org.waveprotocol.wave.diff.Diff.internal_static_diff_FetchDiffRequest_fieldAccessorTable;
    }
    
    // required string waveId = 1;
    public static final int WAVEID_FIELD_NUMBER = 1;
    private boolean hasWaveId;
    private java.lang.String waveId_ = "";
    public boolean hasWaveId() { return hasWaveId; }
    public java.lang.String getWaveId() { return waveId_; }
    
    // repeated .concurrencycontrol.WaveletVersion knownWavelet = 2;
    public static final int KNOWNWAVELET_FIELD_NUMBER = 2;
    private java.util.List<org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion> knownWavelet_ =
      java.util.Collections.emptyList();
    public java.util.List<org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion> getKnownWaveletList() {
      return knownWavelet_;
    }
    public int getKnownWaveletCount() { return knownWavelet_.size(); }
    public org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion getKnownWavelet(int index) {
      return knownWavelet_.get(index);
    }
    
    private void initFields() {
    }
    public final boolean isInitialized() {
      if (!hasWaveId) return false;
      for (org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion element : getKnownWaveletList()) {
        if (!element.isInitialized()) return false;
      }
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasWaveId()) {
        output.writeString(1, getWaveId());
      }
      for (org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion element : getKnownWaveletList()) {
        output.writeMessage(2, element);
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasWaveId()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(1, getWaveId());
      }
      for (org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion element : getKnownWaveletList()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(2, element);
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static org.waveprotocol.wave.diff.Diff.FetchDiffRequest parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffRequest parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffRequest parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffRequest parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffRequest parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffRequest parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffRequest parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffRequest parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffRequest parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffRequest parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(org.waveprotocol.wave.diff.Diff.FetchDiffRequest prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private org.waveprotocol.wave.diff.Diff.FetchDiffRequest result;
      
      // Construct using org.waveprotocol.wave.diff.Diff.FetchDiffRequest.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new org.waveprotocol.wave.diff.Diff.FetchDiffRequest();
        return builder;
      }
      
      protected org.waveprotocol.wave.diff.Diff.FetchDiffRequest internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new org.waveprotocol.wave.diff.Diff.FetchDiffRequest();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return org.waveprotocol.wave.diff.Diff.FetchDiffRequest.getDescriptor();
      }
      
      public org.waveprotocol.wave.diff.Diff.FetchDiffRequest getDefaultInstanceForType() {
        return org.waveprotocol.wave.diff.Diff.FetchDiffRequest.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public org.waveprotocol.wave.diff.Diff.FetchDiffRequest build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private org.waveprotocol.wave.diff.Diff.FetchDiffRequest buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public org.waveprotocol.wave.diff.Diff.FetchDiffRequest buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        if (result.knownWavelet_ != java.util.Collections.EMPTY_LIST) {
          result.knownWavelet_ =
            java.util.Collections.unmodifiableList(result.knownWavelet_);
        }
        org.waveprotocol.wave.diff.Diff.FetchDiffRequest returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof org.waveprotocol.wave.diff.Diff.FetchDiffRequest) {
          return mergeFrom((org.waveprotocol.wave.diff.Diff.FetchDiffRequest)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(org.waveprotocol.wave.diff.Diff.FetchDiffRequest other) {
        if (other == org.waveprotocol.wave.diff.Diff.FetchDiffRequest.getDefaultInstance()) return this;
        if (other.hasWaveId()) {
          setWaveId(other.getWaveId());
        }
        if (!other.knownWavelet_.isEmpty()) {
          if (result.knownWavelet_.isEmpty()) {
            result.knownWavelet_ = new java.util.ArrayList<org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion>();
          }
          result.knownWavelet_.addAll(other.knownWavelet_);
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              setWaveId(input.readString());
              break;
            }
            case 18: {
              org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion.Builder subBuilder = org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion.newBuilder();
              input.readMessage(subBuilder, extensionRegistry);
              addKnownWavelet(subBuilder.buildPartial());
              break;
            }
          }
        }
      }
      
      
      // required string waveId = 1;
      public boolean hasWaveId() {
        return result.hasWaveId();
      }
      public java.lang.String getWaveId() {
        return result.getWaveId();
      }
      public Builder setWaveId(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasWaveId = true;
        result.waveId_ = value;
        return this;
      }
      public Builder clearWaveId() {
        result.hasWaveId = false;
        result.waveId_ = getDefaultInstance().getWaveId();
        return this;
      }
      
      // repeated .concurrencycontrol.WaveletVersion knownWavelet = 2;
      public java.util.List<org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion> getKnownWaveletList() {
        return java.util.Collections.unmodifiableList(result.knownWavelet_);
      }
      public int getKnownWaveletCount() {
        return result.getKnownWaveletCount();
      }
      public org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion getKnownWavelet(int index) {
        return result.getKnownWavelet(index);
      }
      public Builder setKnownWavelet(int index, org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.knownWavelet_.set(index, value);
        return this;
      }
      public Builder setKnownWavelet(int index, org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion.Builder builderForValue) {
        result.knownWavelet_.set(index, builderForValue.build());
        return this;
      }
      public Builder addKnownWavelet(org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion value) {
        if (value == null) {
          throw new NullPointerException();
        }
        if (result.knownWavelet_.isEmpty()) {
          result.knownWavelet_ = new java.util.ArrayList<org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion>();
        }
        result.knownWavelet_.add(value);
        return this;
      }
      public Builder addKnownWavelet(org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion.Builder builderForValue) {
        if (result.knownWavelet_.isEmpty()) {
          result.knownWavelet_ = new java.util.ArrayList<org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion>();
        }
        result.knownWavelet_.add(builderForValue.build());
        return this;
      }
      public Builder addAllKnownWavelet(
          java.lang.Iterable<? extends org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion> values) {
        if (result.knownWavelet_.isEmpty()) {
          result.knownWavelet_ = new java.util.ArrayList<org.waveprotocol.wave.concurrencycontrol.ClientServer.WaveletVersion>();
        }
        super.addAll(values, result.knownWavelet_);
        return this;
      }
      public Builder clearKnownWavelet() {
        result.knownWavelet_ = java.util.Collections.emptyList();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:diff.FetchDiffRequest)
    }
    
    static {
      defaultInstance = new FetchDiffRequest(true);
      org.waveprotocol.wave.diff.Diff.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:diff.FetchDiffRequest)
  }
  
  public static final class FetchDiffResponse extends
      com.google.protobuf.GeneratedMessage {
    // Use FetchDiffResponse.newBuilder() to construct.
    private FetchDiffResponse() {
      initFields();
    }
    private FetchDiffResponse(boolean noInit) {}
    
    private static final FetchDiffResponse defaultInstance;
    public static FetchDiffResponse getDefaultInstance() {
      return defaultInstance;
    }
    
    public FetchDiffResponse getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return org.waveprotocol.wave.diff.Diff.internal_static_diff_FetchDiffResponse_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return org.waveprotocol.wave.diff.Diff.internal_static_diff_FetchDiffResponse_fieldAccessorTable;
    }
    
    public static final class WaveletDiff extends
        com.google.protobuf.GeneratedMessage {
      // Use WaveletDiff.newBuilder() to construct.
      private WaveletDiff() {
        initFields();
      }
      private WaveletDiff(boolean noInit) {}
      
      private static final WaveletDiff defaultInstance;
      public static WaveletDiff getDefaultInstance() {
        return defaultInstance;
      }
      
      public WaveletDiff getDefaultInstanceForType() {
        return defaultInstance;
      }
      
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return org.waveprotocol.wave.diff.Diff.internal_static_diff_FetchDiffResponse_WaveletDiff_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return org.waveprotocol.wave.diff.Diff.internal_static_diff_FetchDiffResponse_WaveletDiff_fieldAccessorTable;
      }
      
      // required string waveletId = 1;
      public static final int WAVELETID_FIELD_NUMBER = 1;
      private boolean hasWaveletId;
      private java.lang.String waveletId_ = "";
      public boolean hasWaveletId() { return hasWaveletId; }
      public java.lang.String getWaveletId() { return waveletId_; }
      
      // optional .diff.WaveletDiffSnapshot snapshot = 2;
      public static final int SNAPSHOT_FIELD_NUMBER = 2;
      private boolean hasSnapshot;
      private org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot snapshot_;
      public boolean hasSnapshot() { return hasSnapshot; }
      public org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot getSnapshot() { return snapshot_; }
      
      private void initFields() {
        snapshot_ = org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.getDefaultInstance();
      }
      public final boolean isInitialized() {
        if (!hasWaveletId) return false;
        if (hasSnapshot()) {
          if (!getSnapshot().isInitialized()) return false;
        }
        return true;
      }
      
      public void writeTo(com.google.protobuf.CodedOutputStream output)
                          throws java.io.IOException {
        getSerializedSize();
        if (hasWaveletId()) {
          output.writeString(1, getWaveletId());
        }
        if (hasSnapshot()) {
          output.writeMessage(2, getSnapshot());
        }
        getUnknownFields().writeTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int getSerializedSize() {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
      
        size = 0;
        if (hasWaveletId()) {
          size += com.google.protobuf.CodedOutputStream
            .computeStringSize(1, getWaveletId());
        }
        if (hasSnapshot()) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(2, getSnapshot());
        }
        size += getUnknownFields().getSerializedSize();
        memoizedSerializedSize = size;
        return size;
      }
      
      public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff parseFrom(
          com.google.protobuf.ByteString data)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff parseFrom(
          com.google.protobuf.ByteString data,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff parseFrom(byte[] data)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff parseFrom(
          byte[] data,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff parseFrom(java.io.InputStream input)
          throws java.io.IOException {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff parseFrom(
          java.io.InputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff parseDelimitedFrom(java.io.InputStream input)
          throws java.io.IOException {
        Builder builder = newBuilder();
        if (builder.mergeDelimitedFrom(input)) {
          return builder.buildParsed();
        } else {
          return null;
        }
      }
      public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff parseDelimitedFrom(
          java.io.InputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        Builder builder = newBuilder();
        if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
          return builder.buildParsed();
        } else {
          return null;
        }
      }
      public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff parseFrom(
          com.google.protobuf.CodedInputStream input)
          throws java.io.IOException {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff parseFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return Builder.create(); }
      public Builder newBuilderForType() { return newBuilder(); }
      public static Builder newBuilder(org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff prototype) {
        return newBuilder().mergeFrom(prototype);
      }
      public Builder toBuilder() { return newBuilder(this); }
      
      public static final class Builder extends
          com.google.protobuf.GeneratedMessage.Builder<Builder> {
        private org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff result;
        
        // Construct using org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff.newBuilder()
        private Builder() {}
        
        private static Builder create() {
          Builder builder = new Builder();
          builder.result = new org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff();
          return builder;
        }
        
        protected org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          if (result == null) {
            throw new IllegalStateException(
              "Cannot call clear() after build().");
          }
          result = new org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff();
          return this;
        }
        
        public Builder clone() {
          return create().mergeFrom(result);
        }
        
        public com.google.protobuf.Descriptors.Descriptor
            getDescriptorForType() {
          return org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff.getDescriptor();
        }
        
        public org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff getDefaultInstanceForType() {
          return org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff.getDefaultInstance();
        }
        
        public boolean isInitialized() {
          return result.isInitialized();
        }
        public org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff build() {
          if (result != null && !isInitialized()) {
            throw newUninitializedMessageException(result);
          }
          return buildPartial();
        }
        
        private org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff buildParsed()
            throws com.google.protobuf.InvalidProtocolBufferException {
          if (!isInitialized()) {
            throw newUninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff buildPartial() {
          if (result == null) {
            throw new IllegalStateException(
              "build() has already been called on this Builder.");
          }
          org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(com.google.protobuf.Message other) {
          if (other instanceof org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff) {
            return mergeFrom((org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff other) {
          if (other == org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff.getDefaultInstance()) return this;
          if (other.hasWaveletId()) {
            setWaveletId(other.getWaveletId());
          }
          if (other.hasSnapshot()) {
            mergeSnapshot(other.getSnapshot());
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            com.google.protobuf.CodedInputStream input,
            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
            throws java.io.IOException {
          com.google.protobuf.UnknownFieldSet.Builder unknownFields =
            com.google.protobuf.UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
              case 10: {
                setWaveletId(input.readString());
                break;
              }
              case 18: {
                org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.Builder subBuilder = org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.newBuilder();
                if (hasSnapshot()) {
                  subBuilder.mergeFrom(getSnapshot());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setSnapshot(subBuilder.buildPartial());
                break;
              }
            }
          }
        }
        
        
        // required string waveletId = 1;
        public boolean hasWaveletId() {
          return result.hasWaveletId();
        }
        public java.lang.String getWaveletId() {
          return result.getWaveletId();
        }
        public Builder setWaveletId(java.lang.String value) {
          if (value == null) {
    throw new NullPointerException();
  }
  result.hasWaveletId = true;
          result.waveletId_ = value;
          return this;
        }
        public Builder clearWaveletId() {
          result.hasWaveletId = false;
          result.waveletId_ = getDefaultInstance().getWaveletId();
          return this;
        }
        
        // optional .diff.WaveletDiffSnapshot snapshot = 2;
        public boolean hasSnapshot() {
          return result.hasSnapshot();
        }
        public org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot getSnapshot() {
          return result.getSnapshot();
        }
        public Builder setSnapshot(org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot value) {
          if (value == null) {
            throw new NullPointerException();
          }
          result.hasSnapshot = true;
          result.snapshot_ = value;
          return this;
        }
        public Builder setSnapshot(org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.Builder builderForValue) {
          result.hasSnapshot = true;
          result.snapshot_ = builderForValue.build();
          return this;
        }
        public Builder mergeSnapshot(org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot value) {
          if (result.hasSnapshot() &&
              result.snapshot_ != org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.getDefaultInstance()) {
            result.snapshot_ =
              org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.newBuilder(result.snapshot_).mergeFrom(value).buildPartial();
          } else {
            result.snapshot_ = value;
          }
          result.hasSnapshot = true;
          return this;
        }
        public Builder clearSnapshot() {
          result.hasSnapshot = false;
          result.snapshot_ = org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.getDefaultInstance();
          return this;
        }
        
        // @@protoc_insertion_point(builder_scope:diff.FetchDiffResponse.WaveletDiff)
      }
      
      static {
        defaultInstance = new WaveletDiff(true);
        org.waveprotocol.wave.diff.Diff.internalForceInit();
        defaultInstance.initFields();
      }
      
      // @@protoc_insertion_point(class_scope:diff.FetchDiffResponse.WaveletDiff)
    }
    
    // required .concurrencycontrol.ResponseStatus status = 1;
    public static final int STATUS_FIELD_NUMBER = 1;
    private boolean hasStatus;
    private org.waveprotocol.wave.concurrencycontrol.ClientServer.ResponseStatus status_;
    public boolean hasStatus() { return hasStatus; }
    public org.waveprotocol.wave.concurrencycontrol.ClientServer.ResponseStatus getStatus() { return status_; }
    
    // repeated .diff.FetchDiffResponse.WaveletDiff wavelet = 2;
    public static final int WAVELET_FIELD_NUMBER = 2;
    private java.util.List<org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff> wavelet_ =
      java.util.Collections.emptyList();
    public java.util.List<org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff> getWaveletList() {
      return wavelet_;
    }
    public int getWaveletCount() { return wavelet_.size(); }
    public org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff getWavelet(int index) {
      return wavelet_.get(index);
    }
    
    private void initFields() {
      status_ = org.waveprotocol.wave.concurrencycontrol.ClientServer.ResponseStatus.getDefaultInstance();
    }
    public final boolean isInitialized() {
      if (!hasStatus) return false;
      if (!getStatus().isInitialized()) return false;
      for (org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff element : getWaveletList()) {
        if (!element.isInitialized()) return false;
      }
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasStatus()) {
        output.writeMessage(1, getStatus());
      }
      for (org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff element : getWaveletList()) {
        output.writeMessage(2, element);
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasStatus()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(1, getStatus());
      }
      for (org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff element : getWaveletList()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(2, element);
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.FetchDiffResponse parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(org.waveprotocol.wave.diff.Diff.FetchDiffResponse prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private org.waveprotocol.wave.diff.Diff.FetchDiffResponse result;
      
      // Construct using org.waveprotocol.wave.diff.Diff.FetchDiffResponse.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new org.waveprotocol.wave.diff.Diff.FetchDiffResponse();
        return builder;
      }
      
      protected org.waveprotocol.wave.diff.Diff.FetchDiffResponse internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new org.waveprotocol.wave.diff.Diff.FetchDiffResponse();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return org.waveprotocol.wave.diff.Diff.FetchDiffResponse.getDescriptor();
      }
      
      public org.waveprotocol.wave.diff.Diff.FetchDiffResponse getDefaultInstanceForType() {
        return org.waveprotocol.wave.diff.Diff.FetchDiffResponse.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public org.waveprotocol.wave.diff.Diff.FetchDiffResponse build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private org.waveprotocol.wave.diff.Diff.FetchDiffResponse buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public org.waveprotocol.wave.diff.Diff.FetchDiffResponse buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        if (result.wavelet_ != java.util.Collections.EMPTY_LIST) {
          result.wavelet_ =
            java.util.Collections.unmodifiableList(result.wavelet_);
        }
        org.waveprotocol.wave.diff.Diff.FetchDiffResponse returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof org.waveprotocol.wave.diff.Diff.FetchDiffResponse) {
          return mergeFrom((org.waveprotocol.wave.diff.Diff.FetchDiffResponse)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(org.waveprotocol.wave.diff.Diff.FetchDiffResponse other) {
        if (other == org.waveprotocol.wave.diff.Diff.FetchDiffResponse.getDefaultInstance()) return this;
        if (other.hasStatus()) {
          mergeStatus(other.getStatus());
        }
        if (!other.wavelet_.isEmpty()) {
          if (result.wavelet_.isEmpty()) {
            result.wavelet_ = new java.util.ArrayList<org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff>();
          }
          result.wavelet_.addAll(other.wavelet_);
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              org.waveprotocol.wave.concurrencycontrol.ClientServer.ResponseStatus.Builder subBuilder = org.waveprotocol.wave.concurrencycontrol.ClientServer.ResponseStatus.newBuilder();
              if (hasStatus()) {
                subBuilder.mergeFrom(getStatus());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setStatus(subBuilder.buildPartial());
              break;
            }
            case 18: {
              org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff.Builder subBuilder = org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff.newBuilder();
              input.readMessage(subBuilder, extensionRegistry);
              addWavelet(subBuilder.buildPartial());
              break;
            }
          }
        }
      }
      
      
      // required .concurrencycontrol.ResponseStatus status = 1;
      public boolean hasStatus() {
        return result.hasStatus();
      }
      public org.waveprotocol.wave.concurrencycontrol.ClientServer.ResponseStatus getStatus() {
        return result.getStatus();
      }
      public Builder setStatus(org.waveprotocol.wave.concurrencycontrol.ClientServer.ResponseStatus value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasStatus = true;
        result.status_ = value;
        return this;
      }
      public Builder setStatus(org.waveprotocol.wave.concurrencycontrol.ClientServer.ResponseStatus.Builder builderForValue) {
        result.hasStatus = true;
        result.status_ = builderForValue.build();
        return this;
      }
      public Builder mergeStatus(org.waveprotocol.wave.concurrencycontrol.ClientServer.ResponseStatus value) {
        if (result.hasStatus() &&
            result.status_ != org.waveprotocol.wave.concurrencycontrol.ClientServer.ResponseStatus.getDefaultInstance()) {
          result.status_ =
            org.waveprotocol.wave.concurrencycontrol.ClientServer.ResponseStatus.newBuilder(result.status_).mergeFrom(value).buildPartial();
        } else {
          result.status_ = value;
        }
        result.hasStatus = true;
        return this;
      }
      public Builder clearStatus() {
        result.hasStatus = false;
        result.status_ = org.waveprotocol.wave.concurrencycontrol.ClientServer.ResponseStatus.getDefaultInstance();
        return this;
      }
      
      // repeated .diff.FetchDiffResponse.WaveletDiff wavelet = 2;
      public java.util.List<org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff> getWaveletList() {
        return java.util.Collections.unmodifiableList(result.wavelet_);
      }
      public int getWaveletCount() {
        return result.getWaveletCount();
      }
      public org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff getWavelet(int index) {
        return result.getWavelet(index);
      }
      public Builder setWavelet(int index, org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.wavelet_.set(index, value);
        return this;
      }
      public Builder setWavelet(int index, org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff.Builder builderForValue) {
        result.wavelet_.set(index, builderForValue.build());
        return this;
      }
      public Builder addWavelet(org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff value) {
        if (value == null) {
          throw new NullPointerException();
        }
        if (result.wavelet_.isEmpty()) {
          result.wavelet_ = new java.util.ArrayList<org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff>();
        }
        result.wavelet_.add(value);
        return this;
      }
      public Builder addWavelet(org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff.Builder builderForValue) {
        if (result.wavelet_.isEmpty()) {
          result.wavelet_ = new java.util.ArrayList<org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff>();
        }
        result.wavelet_.add(builderForValue.build());
        return this;
      }
      public Builder addAllWavelet(
          java.lang.Iterable<? extends org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff> values) {
        if (result.wavelet_.isEmpty()) {
          result.wavelet_ = new java.util.ArrayList<org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff>();
        }
        super.addAll(values, result.wavelet_);
        return this;
      }
      public Builder clearWavelet() {
        result.wavelet_ = java.util.Collections.emptyList();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:diff.FetchDiffResponse)
    }
    
    static {
      defaultInstance = new FetchDiffResponse(true);
      org.waveprotocol.wave.diff.Diff.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:diff.FetchDiffResponse)
  }
  
  public static final class WaveletDiffSnapshot extends
      com.google.protobuf.GeneratedMessage {
    // Use WaveletDiffSnapshot.newBuilder() to construct.
    private WaveletDiffSnapshot() {
      initFields();
    }
    private WaveletDiffSnapshot(boolean noInit) {}
    
    private static final WaveletDiffSnapshot defaultInstance;
    public static WaveletDiffSnapshot getDefaultInstance() {
      return defaultInstance;
    }
    
    public WaveletDiffSnapshot getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return org.waveprotocol.wave.diff.Diff.internal_static_diff_WaveletDiffSnapshot_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return org.waveprotocol.wave.diff.Diff.internal_static_diff_WaveletDiffSnapshot_fieldAccessorTable;
    }
    
    // required string waveletId = 1;
    public static final int WAVELETID_FIELD_NUMBER = 1;
    private boolean hasWaveletId;
    private java.lang.String waveletId_ = "";
    public boolean hasWaveletId() { return hasWaveletId; }
    public java.lang.String getWaveletId() { return waveletId_; }
    
    // repeated string participant = 2;
    public static final int PARTICIPANT_FIELD_NUMBER = 2;
    private java.util.List<java.lang.String> participant_ =
      java.util.Collections.emptyList();
    public java.util.List<java.lang.String> getParticipantList() {
      return participant_;
    }
    public int getParticipantCount() { return participant_.size(); }
    public java.lang.String getParticipant(int index) {
      return participant_.get(index);
    }
    
    // repeated string addedParticipant = 21;
    public static final int ADDEDPARTICIPANT_FIELD_NUMBER = 21;
    private java.util.List<java.lang.String> addedParticipant_ =
      java.util.Collections.emptyList();
    public java.util.List<java.lang.String> getAddedParticipantList() {
      return addedParticipant_;
    }
    public int getAddedParticipantCount() { return addedParticipant_.size(); }
    public java.lang.String getAddedParticipant(int index) {
      return addedParticipant_.get(index);
    }
    
    // repeated string removedParticipant = 22;
    public static final int REMOVEDPARTICIPANT_FIELD_NUMBER = 22;
    private java.util.List<java.lang.String> removedParticipant_ =
      java.util.Collections.emptyList();
    public java.util.List<java.lang.String> getRemovedParticipantList() {
      return removedParticipant_;
    }
    public int getRemovedParticipantCount() { return removedParticipant_.size(); }
    public java.lang.String getRemovedParticipant(int index) {
      return removedParticipant_.get(index);
    }
    
    // repeated .diff.DocumentDiffSnapshot document = 3;
    public static final int DOCUMENT_FIELD_NUMBER = 3;
    private java.util.List<org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot> document_ =
      java.util.Collections.emptyList();
    public java.util.List<org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot> getDocumentList() {
      return document_;
    }
    public int getDocumentCount() { return document_.size(); }
    public org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot getDocument(int index) {
      return document_.get(index);
    }
    
    // required .federation.ProtocolHashedVersion version = 4;
    public static final int VERSION_FIELD_NUMBER = 4;
    private boolean hasVersion;
    private org.waveprotocol.wave.federation.Proto.ProtocolHashedVersion version_;
    public boolean hasVersion() { return hasVersion; }
    public org.waveprotocol.wave.federation.Proto.ProtocolHashedVersion getVersion() { return version_; }
    
    // required int64 lastModifiedTime = 5;
    public static final int LASTMODIFIEDTIME_FIELD_NUMBER = 5;
    private boolean hasLastModifiedTime;
    private long lastModifiedTime_ = 0L;
    public boolean hasLastModifiedTime() { return hasLastModifiedTime; }
    public long getLastModifiedTime() { return lastModifiedTime_; }
    
    // required string creator = 6;
    public static final int CREATOR_FIELD_NUMBER = 6;
    private boolean hasCreator;
    private java.lang.String creator_ = "";
    public boolean hasCreator() { return hasCreator; }
    public java.lang.String getCreator() { return creator_; }
    
    // required int64 creationTime = 7;
    public static final int CREATIONTIME_FIELD_NUMBER = 7;
    private boolean hasCreationTime;
    private long creationTime_ = 0L;
    public boolean hasCreationTime() { return hasCreationTime; }
    public long getCreationTime() { return creationTime_; }
    
    private void initFields() {
      version_ = org.waveprotocol.wave.federation.Proto.ProtocolHashedVersion.getDefaultInstance();
    }
    public final boolean isInitialized() {
      if (!hasWaveletId) return false;
      if (!hasVersion) return false;
      if (!hasLastModifiedTime) return false;
      if (!hasCreator) return false;
      if (!hasCreationTime) return false;
      for (org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot element : getDocumentList()) {
        if (!element.isInitialized()) return false;
      }
      if (!getVersion().isInitialized()) return false;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasWaveletId()) {
        output.writeString(1, getWaveletId());
      }
      for (java.lang.String element : getParticipantList()) {
        output.writeString(2, element);
      }
      for (org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot element : getDocumentList()) {
        output.writeMessage(3, element);
      }
      if (hasVersion()) {
        output.writeMessage(4, getVersion());
      }
      if (hasLastModifiedTime()) {
        output.writeInt64(5, getLastModifiedTime());
      }
      if (hasCreator()) {
        output.writeString(6, getCreator());
      }
      if (hasCreationTime()) {
        output.writeInt64(7, getCreationTime());
      }
      for (java.lang.String element : getAddedParticipantList()) {
        output.writeString(21, element);
      }
      for (java.lang.String element : getRemovedParticipantList()) {
        output.writeString(22, element);
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasWaveletId()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(1, getWaveletId());
      }
      {
        int dataSize = 0;
        for (java.lang.String element : getParticipantList()) {
          dataSize += com.google.protobuf.CodedOutputStream
            .computeStringSizeNoTag(element);
        }
        size += dataSize;
        size += 1 * getParticipantList().size();
      }
      for (org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot element : getDocumentList()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(3, element);
      }
      if (hasVersion()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(4, getVersion());
      }
      if (hasLastModifiedTime()) {
        size += com.google.protobuf.CodedOutputStream
          .computeInt64Size(5, getLastModifiedTime());
      }
      if (hasCreator()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(6, getCreator());
      }
      if (hasCreationTime()) {
        size += com.google.protobuf.CodedOutputStream
          .computeInt64Size(7, getCreationTime());
      }
      {
        int dataSize = 0;
        for (java.lang.String element : getAddedParticipantList()) {
          dataSize += com.google.protobuf.CodedOutputStream
            .computeStringSizeNoTag(element);
        }
        size += dataSize;
        size += 2 * getAddedParticipantList().size();
      }
      {
        int dataSize = 0;
        for (java.lang.String element : getRemovedParticipantList()) {
          dataSize += com.google.protobuf.CodedOutputStream
            .computeStringSizeNoTag(element);
        }
        size += dataSize;
        size += 2 * getRemovedParticipantList().size();
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot result;
      
      // Construct using org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot();
        return builder;
      }
      
      protected org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.getDescriptor();
      }
      
      public org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot getDefaultInstanceForType() {
        return org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        if (result.participant_ != java.util.Collections.EMPTY_LIST) {
          result.participant_ =
            java.util.Collections.unmodifiableList(result.participant_);
        }
        if (result.addedParticipant_ != java.util.Collections.EMPTY_LIST) {
          result.addedParticipant_ =
            java.util.Collections.unmodifiableList(result.addedParticipant_);
        }
        if (result.removedParticipant_ != java.util.Collections.EMPTY_LIST) {
          result.removedParticipant_ =
            java.util.Collections.unmodifiableList(result.removedParticipant_);
        }
        if (result.document_ != java.util.Collections.EMPTY_LIST) {
          result.document_ =
            java.util.Collections.unmodifiableList(result.document_);
        }
        org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot) {
          return mergeFrom((org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot other) {
        if (other == org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.getDefaultInstance()) return this;
        if (other.hasWaveletId()) {
          setWaveletId(other.getWaveletId());
        }
        if (!other.participant_.isEmpty()) {
          if (result.participant_.isEmpty()) {
            result.participant_ = new java.util.ArrayList<java.lang.String>();
          }
          result.participant_.addAll(other.participant_);
        }
        if (!other.addedParticipant_.isEmpty()) {
          if (result.addedParticipant_.isEmpty()) {
            result.addedParticipant_ = new java.util.ArrayList<java.lang.String>();
          }
          result.addedParticipant_.addAll(other.addedParticipant_);
        }
        if (!other.removedParticipant_.isEmpty()) {
          if (result.removedParticipant_.isEmpty()) {
            result.removedParticipant_ = new java.util.ArrayList<java.lang.String>();
          }
          result.removedParticipant_.addAll(other.removedParticipant_);
        }
        if (!other.document_.isEmpty()) {
          if (result.document_.isEmpty()) {
            result.document_ = new java.util.ArrayList<org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot>();
          }
          result.document_.addAll(other.document_);
        }
        if (other.hasVersion()) {
          mergeVersion(other.getVersion());
        }
        if (other.hasLastModifiedTime()) {
          setLastModifiedTime(other.getLastModifiedTime());
        }
        if (other.hasCreator()) {
          setCreator(other.getCreator());
        }
        if (other.hasCreationTime()) {
          setCreationTime(other.getCreationTime());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              setWaveletId(input.readString());
              break;
            }
            case 18: {
              addParticipant(input.readString());
              break;
            }
            case 26: {
              org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot.Builder subBuilder = org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot.newBuilder();
              input.readMessage(subBuilder, extensionRegistry);
              addDocument(subBuilder.buildPartial());
              break;
            }
            case 34: {
              org.waveprotocol.wave.federation.Proto.ProtocolHashedVersion.Builder subBuilder = org.waveprotocol.wave.federation.Proto.ProtocolHashedVersion.newBuilder();
              if (hasVersion()) {
                subBuilder.mergeFrom(getVersion());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setVersion(subBuilder.buildPartial());
              break;
            }
            case 40: {
              setLastModifiedTime(input.readInt64());
              break;
            }
            case 50: {
              setCreator(input.readString());
              break;
            }
            case 56: {
              setCreationTime(input.readInt64());
              break;
            }
            case 170: {
              addAddedParticipant(input.readString());
              break;
            }
            case 178: {
              addRemovedParticipant(input.readString());
              break;
            }
          }
        }
      }
      
      
      // required string waveletId = 1;
      public boolean hasWaveletId() {
        return result.hasWaveletId();
      }
      public java.lang.String getWaveletId() {
        return result.getWaveletId();
      }
      public Builder setWaveletId(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasWaveletId = true;
        result.waveletId_ = value;
        return this;
      }
      public Builder clearWaveletId() {
        result.hasWaveletId = false;
        result.waveletId_ = getDefaultInstance().getWaveletId();
        return this;
      }
      
      // repeated string participant = 2;
      public java.util.List<java.lang.String> getParticipantList() {
        return java.util.Collections.unmodifiableList(result.participant_);
      }
      public int getParticipantCount() {
        return result.getParticipantCount();
      }
      public java.lang.String getParticipant(int index) {
        return result.getParticipant(index);
      }
      public Builder setParticipant(int index, java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.participant_.set(index, value);
        return this;
      }
      public Builder addParticipant(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  if (result.participant_.isEmpty()) {
          result.participant_ = new java.util.ArrayList<java.lang.String>();
        }
        result.participant_.add(value);
        return this;
      }
      public Builder addAllParticipant(
          java.lang.Iterable<? extends java.lang.String> values) {
        if (result.participant_.isEmpty()) {
          result.participant_ = new java.util.ArrayList<java.lang.String>();
        }
        super.addAll(values, result.participant_);
        return this;
      }
      public Builder clearParticipant() {
        result.participant_ = java.util.Collections.emptyList();
        return this;
      }
      
      // repeated string addedParticipant = 21;
      public java.util.List<java.lang.String> getAddedParticipantList() {
        return java.util.Collections.unmodifiableList(result.addedParticipant_);
      }
      public int getAddedParticipantCount() {
        return result.getAddedParticipantCount();
      }
      public java.lang.String getAddedParticipant(int index) {
        return result.getAddedParticipant(index);
      }
      public Builder setAddedParticipant(int index, java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.addedParticipant_.set(index, value);
        return this;
      }
      public Builder addAddedParticipant(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  if (result.addedParticipant_.isEmpty()) {
          result.addedParticipant_ = new java.util.ArrayList<java.lang.String>();
        }
        result.addedParticipant_.add(value);
        return this;
      }
      public Builder addAllAddedParticipant(
          java.lang.Iterable<? extends java.lang.String> values) {
        if (result.addedParticipant_.isEmpty()) {
          result.addedParticipant_ = new java.util.ArrayList<java.lang.String>();
        }
        super.addAll(values, result.addedParticipant_);
        return this;
      }
      public Builder clearAddedParticipant() {
        result.addedParticipant_ = java.util.Collections.emptyList();
        return this;
      }
      
      // repeated string removedParticipant = 22;
      public java.util.List<java.lang.String> getRemovedParticipantList() {
        return java.util.Collections.unmodifiableList(result.removedParticipant_);
      }
      public int getRemovedParticipantCount() {
        return result.getRemovedParticipantCount();
      }
      public java.lang.String getRemovedParticipant(int index) {
        return result.getRemovedParticipant(index);
      }
      public Builder setRemovedParticipant(int index, java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.removedParticipant_.set(index, value);
        return this;
      }
      public Builder addRemovedParticipant(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  if (result.removedParticipant_.isEmpty()) {
          result.removedParticipant_ = new java.util.ArrayList<java.lang.String>();
        }
        result.removedParticipant_.add(value);
        return this;
      }
      public Builder addAllRemovedParticipant(
          java.lang.Iterable<? extends java.lang.String> values) {
        if (result.removedParticipant_.isEmpty()) {
          result.removedParticipant_ = new java.util.ArrayList<java.lang.String>();
        }
        super.addAll(values, result.removedParticipant_);
        return this;
      }
      public Builder clearRemovedParticipant() {
        result.removedParticipant_ = java.util.Collections.emptyList();
        return this;
      }
      
      // repeated .diff.DocumentDiffSnapshot document = 3;
      public java.util.List<org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot> getDocumentList() {
        return java.util.Collections.unmodifiableList(result.document_);
      }
      public int getDocumentCount() {
        return result.getDocumentCount();
      }
      public org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot getDocument(int index) {
        return result.getDocument(index);
      }
      public Builder setDocument(int index, org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.document_.set(index, value);
        return this;
      }
      public Builder setDocument(int index, org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot.Builder builderForValue) {
        result.document_.set(index, builderForValue.build());
        return this;
      }
      public Builder addDocument(org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot value) {
        if (value == null) {
          throw new NullPointerException();
        }
        if (result.document_.isEmpty()) {
          result.document_ = new java.util.ArrayList<org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot>();
        }
        result.document_.add(value);
        return this;
      }
      public Builder addDocument(org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot.Builder builderForValue) {
        if (result.document_.isEmpty()) {
          result.document_ = new java.util.ArrayList<org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot>();
        }
        result.document_.add(builderForValue.build());
        return this;
      }
      public Builder addAllDocument(
          java.lang.Iterable<? extends org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot> values) {
        if (result.document_.isEmpty()) {
          result.document_ = new java.util.ArrayList<org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot>();
        }
        super.addAll(values, result.document_);
        return this;
      }
      public Builder clearDocument() {
        result.document_ = java.util.Collections.emptyList();
        return this;
      }
      
      // required .federation.ProtocolHashedVersion version = 4;
      public boolean hasVersion() {
        return result.hasVersion();
      }
      public org.waveprotocol.wave.federation.Proto.ProtocolHashedVersion getVersion() {
        return result.getVersion();
      }
      public Builder setVersion(org.waveprotocol.wave.federation.Proto.ProtocolHashedVersion value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasVersion = true;
        result.version_ = value;
        return this;
      }
      public Builder setVersion(org.waveprotocol.wave.federation.Proto.ProtocolHashedVersion.Builder builderForValue) {
        result.hasVersion = true;
        result.version_ = builderForValue.build();
        return this;
      }
      public Builder mergeVersion(org.waveprotocol.wave.federation.Proto.ProtocolHashedVersion value) {
        if (result.hasVersion() &&
            result.version_ != org.waveprotocol.wave.federation.Proto.ProtocolHashedVersion.getDefaultInstance()) {
          result.version_ =
            org.waveprotocol.wave.federation.Proto.ProtocolHashedVersion.newBuilder(result.version_).mergeFrom(value).buildPartial();
        } else {
          result.version_ = value;
        }
        result.hasVersion = true;
        return this;
      }
      public Builder clearVersion() {
        result.hasVersion = false;
        result.version_ = org.waveprotocol.wave.federation.Proto.ProtocolHashedVersion.getDefaultInstance();
        return this;
      }
      
      // required int64 lastModifiedTime = 5;
      public boolean hasLastModifiedTime() {
        return result.hasLastModifiedTime();
      }
      public long getLastModifiedTime() {
        return result.getLastModifiedTime();
      }
      public Builder setLastModifiedTime(long value) {
        result.hasLastModifiedTime = true;
        result.lastModifiedTime_ = value;
        return this;
      }
      public Builder clearLastModifiedTime() {
        result.hasLastModifiedTime = false;
        result.lastModifiedTime_ = 0L;
        return this;
      }
      
      // required string creator = 6;
      public boolean hasCreator() {
        return result.hasCreator();
      }
      public java.lang.String getCreator() {
        return result.getCreator();
      }
      public Builder setCreator(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasCreator = true;
        result.creator_ = value;
        return this;
      }
      public Builder clearCreator() {
        result.hasCreator = false;
        result.creator_ = getDefaultInstance().getCreator();
        return this;
      }
      
      // required int64 creationTime = 7;
      public boolean hasCreationTime() {
        return result.hasCreationTime();
      }
      public long getCreationTime() {
        return result.getCreationTime();
      }
      public Builder setCreationTime(long value) {
        result.hasCreationTime = true;
        result.creationTime_ = value;
        return this;
      }
      public Builder clearCreationTime() {
        result.hasCreationTime = false;
        result.creationTime_ = 0L;
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:diff.WaveletDiffSnapshot)
    }
    
    static {
      defaultInstance = new WaveletDiffSnapshot(true);
      org.waveprotocol.wave.diff.Diff.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:diff.WaveletDiffSnapshot)
  }
  
  public static final class DocumentDiffSnapshot extends
      com.google.protobuf.GeneratedMessage {
    // Use DocumentDiffSnapshot.newBuilder() to construct.
    private DocumentDiffSnapshot() {
      initFields();
    }
    private DocumentDiffSnapshot(boolean noInit) {}
    
    private static final DocumentDiffSnapshot defaultInstance;
    public static DocumentDiffSnapshot getDefaultInstance() {
      return defaultInstance;
    }
    
    public DocumentDiffSnapshot getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return org.waveprotocol.wave.diff.Diff.internal_static_diff_DocumentDiffSnapshot_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return org.waveprotocol.wave.diff.Diff.internal_static_diff_DocumentDiffSnapshot_fieldAccessorTable;
    }
    
    // required string documentId = 1;
    public static final int DOCUMENTID_FIELD_NUMBER = 1;
    private boolean hasDocumentId;
    private java.lang.String documentId_ = "";
    public boolean hasDocumentId() { return hasDocumentId; }
    public java.lang.String getDocumentId() { return documentId_; }
    
    // optional .federation.ProtocolDocumentOperation state = 2;
    public static final int STATE_FIELD_NUMBER = 2;
    private boolean hasState;
    private org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation state_;
    public boolean hasState() { return hasState; }
    public org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation getState() { return state_; }
    
    // optional .federation.ProtocolDocumentOperation diff = 21;
    public static final int DIFF_FIELD_NUMBER = 21;
    private boolean hasDiff;
    private org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation diff_;
    public boolean hasDiff() { return hasDiff; }
    public org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation getDiff() { return diff_; }
    
    // required string author = 3;
    public static final int AUTHOR_FIELD_NUMBER = 3;
    private boolean hasAuthor;
    private java.lang.String author_ = "";
    public boolean hasAuthor() { return hasAuthor; }
    public java.lang.String getAuthor() { return author_; }
    
    // repeated string contributor = 4;
    public static final int CONTRIBUTOR_FIELD_NUMBER = 4;
    private java.util.List<java.lang.String> contributor_ =
      java.util.Collections.emptyList();
    public java.util.List<java.lang.String> getContributorList() {
      return contributor_;
    }
    public int getContributorCount() { return contributor_.size(); }
    public java.lang.String getContributor(int index) {
      return contributor_.get(index);
    }
    
    // repeated string addedContributor = 22;
    public static final int ADDEDCONTRIBUTOR_FIELD_NUMBER = 22;
    private java.util.List<java.lang.String> addedContributor_ =
      java.util.Collections.emptyList();
    public java.util.List<java.lang.String> getAddedContributorList() {
      return addedContributor_;
    }
    public int getAddedContributorCount() { return addedContributor_.size(); }
    public java.lang.String getAddedContributor(int index) {
      return addedContributor_.get(index);
    }
    
    // repeated string removedContributor = 23;
    public static final int REMOVEDCONTRIBUTOR_FIELD_NUMBER = 23;
    private java.util.List<java.lang.String> removedContributor_ =
      java.util.Collections.emptyList();
    public java.util.List<java.lang.String> getRemovedContributorList() {
      return removedContributor_;
    }
    public int getRemovedContributorCount() { return removedContributor_.size(); }
    public java.lang.String getRemovedContributor(int index) {
      return removedContributor_.get(index);
    }
    
    // required int64 lastModifiedVersion = 5;
    public static final int LASTMODIFIEDVERSION_FIELD_NUMBER = 5;
    private boolean hasLastModifiedVersion;
    private long lastModifiedVersion_ = 0L;
    public boolean hasLastModifiedVersion() { return hasLastModifiedVersion; }
    public long getLastModifiedVersion() { return lastModifiedVersion_; }
    
    // required int64 lastModifiedTime = 6;
    public static final int LASTMODIFIEDTIME_FIELD_NUMBER = 6;
    private boolean hasLastModifiedTime;
    private long lastModifiedTime_ = 0L;
    public boolean hasLastModifiedTime() { return hasLastModifiedTime; }
    public long getLastModifiedTime() { return lastModifiedTime_; }
    
    private void initFields() {
      state_ = org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.getDefaultInstance();
      diff_ = org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.getDefaultInstance();
    }
    public final boolean isInitialized() {
      if (!hasDocumentId) return false;
      if (!hasAuthor) return false;
      if (!hasLastModifiedVersion) return false;
      if (!hasLastModifiedTime) return false;
      if (hasState()) {
        if (!getState().isInitialized()) return false;
      }
      if (hasDiff()) {
        if (!getDiff().isInitialized()) return false;
      }
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasDocumentId()) {
        output.writeString(1, getDocumentId());
      }
      if (hasState()) {
        output.writeMessage(2, getState());
      }
      if (hasAuthor()) {
        output.writeString(3, getAuthor());
      }
      for (java.lang.String element : getContributorList()) {
        output.writeString(4, element);
      }
      if (hasLastModifiedVersion()) {
        output.writeInt64(5, getLastModifiedVersion());
      }
      if (hasLastModifiedTime()) {
        output.writeInt64(6, getLastModifiedTime());
      }
      if (hasDiff()) {
        output.writeMessage(21, getDiff());
      }
      for (java.lang.String element : getAddedContributorList()) {
        output.writeString(22, element);
      }
      for (java.lang.String element : getRemovedContributorList()) {
        output.writeString(23, element);
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasDocumentId()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(1, getDocumentId());
      }
      if (hasState()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(2, getState());
      }
      if (hasAuthor()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(3, getAuthor());
      }
      {
        int dataSize = 0;
        for (java.lang.String element : getContributorList()) {
          dataSize += com.google.protobuf.CodedOutputStream
            .computeStringSizeNoTag(element);
        }
        size += dataSize;
        size += 1 * getContributorList().size();
      }
      if (hasLastModifiedVersion()) {
        size += com.google.protobuf.CodedOutputStream
          .computeInt64Size(5, getLastModifiedVersion());
      }
      if (hasLastModifiedTime()) {
        size += com.google.protobuf.CodedOutputStream
          .computeInt64Size(6, getLastModifiedTime());
      }
      if (hasDiff()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(21, getDiff());
      }
      {
        int dataSize = 0;
        for (java.lang.String element : getAddedContributorList()) {
          dataSize += com.google.protobuf.CodedOutputStream
            .computeStringSizeNoTag(element);
        }
        size += dataSize;
        size += 2 * getAddedContributorList().size();
      }
      {
        int dataSize = 0;
        for (java.lang.String element : getRemovedContributorList()) {
          dataSize += com.google.protobuf.CodedOutputStream
            .computeStringSizeNoTag(element);
        }
        size += dataSize;
        size += 2 * getRemovedContributorList().size();
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot result;
      
      // Construct using org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot();
        return builder;
      }
      
      protected org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot.getDescriptor();
      }
      
      public org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot getDefaultInstanceForType() {
        return org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        if (result.contributor_ != java.util.Collections.EMPTY_LIST) {
          result.contributor_ =
            java.util.Collections.unmodifiableList(result.contributor_);
        }
        if (result.addedContributor_ != java.util.Collections.EMPTY_LIST) {
          result.addedContributor_ =
            java.util.Collections.unmodifiableList(result.addedContributor_);
        }
        if (result.removedContributor_ != java.util.Collections.EMPTY_LIST) {
          result.removedContributor_ =
            java.util.Collections.unmodifiableList(result.removedContributor_);
        }
        org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot) {
          return mergeFrom((org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot other) {
        if (other == org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot.getDefaultInstance()) return this;
        if (other.hasDocumentId()) {
          setDocumentId(other.getDocumentId());
        }
        if (other.hasState()) {
          mergeState(other.getState());
        }
        if (other.hasDiff()) {
          mergeDiff(other.getDiff());
        }
        if (other.hasAuthor()) {
          setAuthor(other.getAuthor());
        }
        if (!other.contributor_.isEmpty()) {
          if (result.contributor_.isEmpty()) {
            result.contributor_ = new java.util.ArrayList<java.lang.String>();
          }
          result.contributor_.addAll(other.contributor_);
        }
        if (!other.addedContributor_.isEmpty()) {
          if (result.addedContributor_.isEmpty()) {
            result.addedContributor_ = new java.util.ArrayList<java.lang.String>();
          }
          result.addedContributor_.addAll(other.addedContributor_);
        }
        if (!other.removedContributor_.isEmpty()) {
          if (result.removedContributor_.isEmpty()) {
            result.removedContributor_ = new java.util.ArrayList<java.lang.String>();
          }
          result.removedContributor_.addAll(other.removedContributor_);
        }
        if (other.hasLastModifiedVersion()) {
          setLastModifiedVersion(other.getLastModifiedVersion());
        }
        if (other.hasLastModifiedTime()) {
          setLastModifiedTime(other.getLastModifiedTime());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              setDocumentId(input.readString());
              break;
            }
            case 18: {
              org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.Builder subBuilder = org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.newBuilder();
              if (hasState()) {
                subBuilder.mergeFrom(getState());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setState(subBuilder.buildPartial());
              break;
            }
            case 26: {
              setAuthor(input.readString());
              break;
            }
            case 34: {
              addContributor(input.readString());
              break;
            }
            case 40: {
              setLastModifiedVersion(input.readInt64());
              break;
            }
            case 48: {
              setLastModifiedTime(input.readInt64());
              break;
            }
            case 170: {
              org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.Builder subBuilder = org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.newBuilder();
              if (hasDiff()) {
                subBuilder.mergeFrom(getDiff());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setDiff(subBuilder.buildPartial());
              break;
            }
            case 178: {
              addAddedContributor(input.readString());
              break;
            }
            case 186: {
              addRemovedContributor(input.readString());
              break;
            }
          }
        }
      }
      
      
      // required string documentId = 1;
      public boolean hasDocumentId() {
        return result.hasDocumentId();
      }
      public java.lang.String getDocumentId() {
        return result.getDocumentId();
      }
      public Builder setDocumentId(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasDocumentId = true;
        result.documentId_ = value;
        return this;
      }
      public Builder clearDocumentId() {
        result.hasDocumentId = false;
        result.documentId_ = getDefaultInstance().getDocumentId();
        return this;
      }
      
      // optional .federation.ProtocolDocumentOperation state = 2;
      public boolean hasState() {
        return result.hasState();
      }
      public org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation getState() {
        return result.getState();
      }
      public Builder setState(org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasState = true;
        result.state_ = value;
        return this;
      }
      public Builder setState(org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.Builder builderForValue) {
        result.hasState = true;
        result.state_ = builderForValue.build();
        return this;
      }
      public Builder mergeState(org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation value) {
        if (result.hasState() &&
            result.state_ != org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.getDefaultInstance()) {
          result.state_ =
            org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.newBuilder(result.state_).mergeFrom(value).buildPartial();
        } else {
          result.state_ = value;
        }
        result.hasState = true;
        return this;
      }
      public Builder clearState() {
        result.hasState = false;
        result.state_ = org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.getDefaultInstance();
        return this;
      }
      
      // optional .federation.ProtocolDocumentOperation diff = 21;
      public boolean hasDiff() {
        return result.hasDiff();
      }
      public org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation getDiff() {
        return result.getDiff();
      }
      public Builder setDiff(org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasDiff = true;
        result.diff_ = value;
        return this;
      }
      public Builder setDiff(org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.Builder builderForValue) {
        result.hasDiff = true;
        result.diff_ = builderForValue.build();
        return this;
      }
      public Builder mergeDiff(org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation value) {
        if (result.hasDiff() &&
            result.diff_ != org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.getDefaultInstance()) {
          result.diff_ =
            org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.newBuilder(result.diff_).mergeFrom(value).buildPartial();
        } else {
          result.diff_ = value;
        }
        result.hasDiff = true;
        return this;
      }
      public Builder clearDiff() {
        result.hasDiff = false;
        result.diff_ = org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.getDefaultInstance();
        return this;
      }
      
      // required string author = 3;
      public boolean hasAuthor() {
        return result.hasAuthor();
      }
      public java.lang.String getAuthor() {
        return result.getAuthor();
      }
      public Builder setAuthor(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasAuthor = true;
        result.author_ = value;
        return this;
      }
      public Builder clearAuthor() {
        result.hasAuthor = false;
        result.author_ = getDefaultInstance().getAuthor();
        return this;
      }
      
      // repeated string contributor = 4;
      public java.util.List<java.lang.String> getContributorList() {
        return java.util.Collections.unmodifiableList(result.contributor_);
      }
      public int getContributorCount() {
        return result.getContributorCount();
      }
      public java.lang.String getContributor(int index) {
        return result.getContributor(index);
      }
      public Builder setContributor(int index, java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.contributor_.set(index, value);
        return this;
      }
      public Builder addContributor(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  if (result.contributor_.isEmpty()) {
          result.contributor_ = new java.util.ArrayList<java.lang.String>();
        }
        result.contributor_.add(value);
        return this;
      }
      public Builder addAllContributor(
          java.lang.Iterable<? extends java.lang.String> values) {
        if (result.contributor_.isEmpty()) {
          result.contributor_ = new java.util.ArrayList<java.lang.String>();
        }
        super.addAll(values, result.contributor_);
        return this;
      }
      public Builder clearContributor() {
        result.contributor_ = java.util.Collections.emptyList();
        return this;
      }
      
      // repeated string addedContributor = 22;
      public java.util.List<java.lang.String> getAddedContributorList() {
        return java.util.Collections.unmodifiableList(result.addedContributor_);
      }
      public int getAddedContributorCount() {
        return result.getAddedContributorCount();
      }
      public java.lang.String getAddedContributor(int index) {
        return result.getAddedContributor(index);
      }
      public Builder setAddedContributor(int index, java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.addedContributor_.set(index, value);
        return this;
      }
      public Builder addAddedContributor(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  if (result.addedContributor_.isEmpty()) {
          result.addedContributor_ = new java.util.ArrayList<java.lang.String>();
        }
        result.addedContributor_.add(value);
        return this;
      }
      public Builder addAllAddedContributor(
          java.lang.Iterable<? extends java.lang.String> values) {
        if (result.addedContributor_.isEmpty()) {
          result.addedContributor_ = new java.util.ArrayList<java.lang.String>();
        }
        super.addAll(values, result.addedContributor_);
        return this;
      }
      public Builder clearAddedContributor() {
        result.addedContributor_ = java.util.Collections.emptyList();
        return this;
      }
      
      // repeated string removedContributor = 23;
      public java.util.List<java.lang.String> getRemovedContributorList() {
        return java.util.Collections.unmodifiableList(result.removedContributor_);
      }
      public int getRemovedContributorCount() {
        return result.getRemovedContributorCount();
      }
      public java.lang.String getRemovedContributor(int index) {
        return result.getRemovedContributor(index);
      }
      public Builder setRemovedContributor(int index, java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.removedContributor_.set(index, value);
        return this;
      }
      public Builder addRemovedContributor(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  if (result.removedContributor_.isEmpty()) {
          result.removedContributor_ = new java.util.ArrayList<java.lang.String>();
        }
        result.removedContributor_.add(value);
        return this;
      }
      public Builder addAllRemovedContributor(
          java.lang.Iterable<? extends java.lang.String> values) {
        if (result.removedContributor_.isEmpty()) {
          result.removedContributor_ = new java.util.ArrayList<java.lang.String>();
        }
        super.addAll(values, result.removedContributor_);
        return this;
      }
      public Builder clearRemovedContributor() {
        result.removedContributor_ = java.util.Collections.emptyList();
        return this;
      }
      
      // required int64 lastModifiedVersion = 5;
      public boolean hasLastModifiedVersion() {
        return result.hasLastModifiedVersion();
      }
      public long getLastModifiedVersion() {
        return result.getLastModifiedVersion();
      }
      public Builder setLastModifiedVersion(long value) {
        result.hasLastModifiedVersion = true;
        result.lastModifiedVersion_ = value;
        return this;
      }
      public Builder clearLastModifiedVersion() {
        result.hasLastModifiedVersion = false;
        result.lastModifiedVersion_ = 0L;
        return this;
      }
      
      // required int64 lastModifiedTime = 6;
      public boolean hasLastModifiedTime() {
        return result.hasLastModifiedTime();
      }
      public long getLastModifiedTime() {
        return result.getLastModifiedTime();
      }
      public Builder setLastModifiedTime(long value) {
        result.hasLastModifiedTime = true;
        result.lastModifiedTime_ = value;
        return this;
      }
      public Builder clearLastModifiedTime() {
        result.hasLastModifiedTime = false;
        result.lastModifiedTime_ = 0L;
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:diff.DocumentDiffSnapshot)
    }
    
    static {
      defaultInstance = new DocumentDiffSnapshot(true);
      org.waveprotocol.wave.diff.Diff.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:diff.DocumentDiffSnapshot)
  }
  
  public static abstract class FetchDiffService
      implements com.google.protobuf.Service {
    protected FetchDiffService() {}
    
    public interface Interface {
      public abstract void fetch(
          com.google.protobuf.RpcController controller,
          org.waveprotocol.wave.diff.Diff.FetchDiffRequest request,
          com.google.protobuf.RpcCallback<org.waveprotocol.wave.diff.Diff.FetchDiffResponse> done);
      
    }
    
    public static com.google.protobuf.Service newReflectiveService(
        final Interface impl) {
      return new FetchDiffService() {
        @Override
        public  void fetch(
            com.google.protobuf.RpcController controller,
            org.waveprotocol.wave.diff.Diff.FetchDiffRequest request,
            com.google.protobuf.RpcCallback<org.waveprotocol.wave.diff.Diff.FetchDiffResponse> done) {
          impl.fetch(controller, request, done);
        }
        
      };
    }
    
    public static com.google.protobuf.BlockingService
        newReflectiveBlockingService(final BlockingInterface impl) {
      return new com.google.protobuf.BlockingService() {
        public final com.google.protobuf.Descriptors.ServiceDescriptor
            getDescriptorForType() {
          return getDescriptor();
        }
        
        public final com.google.protobuf.Message callBlockingMethod(
            com.google.protobuf.Descriptors.MethodDescriptor method,
            com.google.protobuf.RpcController controller,
            com.google.protobuf.Message request)
            throws com.google.protobuf.ServiceException {
          if (method.getService() != getDescriptor()) {
            throw new java.lang.IllegalArgumentException(
              "Service.callBlockingMethod() given method descriptor for " +
              "wrong service type.");
          }
          switch(method.getIndex()) {
            case 0:
              return impl.fetch(controller, (org.waveprotocol.wave.diff.Diff.FetchDiffRequest)request);
            default:
              throw new java.lang.AssertionError("Can't get here.");
          }
        }
        
        public final com.google.protobuf.Message
            getRequestPrototype(
            com.google.protobuf.Descriptors.MethodDescriptor method) {
          if (method.getService() != getDescriptor()) {
            throw new java.lang.IllegalArgumentException(
              "Service.getRequestPrototype() given method " +
              "descriptor for wrong service type.");
          }
          switch(method.getIndex()) {
            case 0:
              return org.waveprotocol.wave.diff.Diff.FetchDiffRequest.getDefaultInstance();
            default:
              throw new java.lang.AssertionError("Can't get here.");
          }
        }
        
        public final com.google.protobuf.Message
            getResponsePrototype(
            com.google.protobuf.Descriptors.MethodDescriptor method) {
          if (method.getService() != getDescriptor()) {
            throw new java.lang.IllegalArgumentException(
              "Service.getResponsePrototype() given method " +
              "descriptor for wrong service type.");
          }
          switch(method.getIndex()) {
            case 0:
              return org.waveprotocol.wave.diff.Diff.FetchDiffResponse.getDefaultInstance();
            default:
              throw new java.lang.AssertionError("Can't get here.");
          }
        }
        
      };
    }
    
    public abstract void fetch(
        com.google.protobuf.RpcController controller,
        org.waveprotocol.wave.diff.Diff.FetchDiffRequest request,
        com.google.protobuf.RpcCallback<org.waveprotocol.wave.diff.Diff.FetchDiffResponse> done);
    
    public static final
        com.google.protobuf.Descriptors.ServiceDescriptor
        getDescriptor() {
      return org.waveprotocol.wave.diff.Diff.getDescriptor().getServices().get(0);
    }
    public final com.google.protobuf.Descriptors.ServiceDescriptor
        getDescriptorForType() {
      return getDescriptor();
    }
    
    public final void callMethod(
        com.google.protobuf.Descriptors.MethodDescriptor method,
        com.google.protobuf.RpcController controller,
        com.google.protobuf.Message request,
        com.google.protobuf.RpcCallback<
          com.google.protobuf.Message> done) {
      if (method.getService() != getDescriptor()) {
        throw new java.lang.IllegalArgumentException(
          "Service.callMethod() given method descriptor for wrong " +
          "service type.");
      }
      switch(method.getIndex()) {
        case 0:
          this.fetch(controller, (org.waveprotocol.wave.diff.Diff.FetchDiffRequest)request,
            com.google.protobuf.RpcUtil.<org.waveprotocol.wave.diff.Diff.FetchDiffResponse>specializeCallback(
              done));
          return;
        default:
          throw new java.lang.AssertionError("Can't get here.");
      }
    }
    
    public final com.google.protobuf.Message
        getRequestPrototype(
        com.google.protobuf.Descriptors.MethodDescriptor method) {
      if (method.getService() != getDescriptor()) {
        throw new java.lang.IllegalArgumentException(
          "Service.getRequestPrototype() given method " +
          "descriptor for wrong service type.");
      }
      switch(method.getIndex()) {
        case 0:
          return org.waveprotocol.wave.diff.Diff.FetchDiffRequest.getDefaultInstance();
        default:
          throw new java.lang.AssertionError("Can't get here.");
      }
    }
    
    public final com.google.protobuf.Message
        getResponsePrototype(
        com.google.protobuf.Descriptors.MethodDescriptor method) {
      if (method.getService() != getDescriptor()) {
        throw new java.lang.IllegalArgumentException(
          "Service.getResponsePrototype() given method " +
          "descriptor for wrong service type.");
      }
      switch(method.getIndex()) {
        case 0:
          return org.waveprotocol.wave.diff.Diff.FetchDiffResponse.getDefaultInstance();
        default:
          throw new java.lang.AssertionError("Can't get here.");
      }
    }
    
    public static Stub newStub(
        com.google.protobuf.RpcChannel channel) {
      return new Stub(channel);
    }
    
    public static final class Stub extends org.waveprotocol.wave.diff.Diff.FetchDiffService implements Interface {
      private Stub(com.google.protobuf.RpcChannel channel) {
        this.channel = channel;
      }
      
      private final com.google.protobuf.RpcChannel channel;
      
      public com.google.protobuf.RpcChannel getChannel() {
        return channel;
      }
      
      public  void fetch(
          com.google.protobuf.RpcController controller,
          org.waveprotocol.wave.diff.Diff.FetchDiffRequest request,
          com.google.protobuf.RpcCallback<org.waveprotocol.wave.diff.Diff.FetchDiffResponse> done) {
        channel.callMethod(
          getDescriptor().getMethods().get(0),
          controller,
          request,
          org.waveprotocol.wave.diff.Diff.FetchDiffResponse.getDefaultInstance(),
          com.google.protobuf.RpcUtil.generalizeCallback(
            done,
            org.waveprotocol.wave.diff.Diff.FetchDiffResponse.class,
            org.waveprotocol.wave.diff.Diff.FetchDiffResponse.getDefaultInstance()));
      }
    }
    
    public static BlockingInterface newBlockingStub(
        com.google.protobuf.BlockingRpcChannel channel) {
      return new BlockingStub(channel);
    }
    
    public interface BlockingInterface {
      public org.waveprotocol.wave.diff.Diff.FetchDiffResponse fetch(
          com.google.protobuf.RpcController controller,
          org.waveprotocol.wave.diff.Diff.FetchDiffRequest request)
          throws com.google.protobuf.ServiceException;
    }
    
    private static final class BlockingStub implements BlockingInterface {
      private BlockingStub(com.google.protobuf.BlockingRpcChannel channel) {
        this.channel = channel;
      }
      
      private final com.google.protobuf.BlockingRpcChannel channel;
      
      public org.waveprotocol.wave.diff.Diff.FetchDiffResponse fetch(
          com.google.protobuf.RpcController controller,
          org.waveprotocol.wave.diff.Diff.FetchDiffRequest request)
          throws com.google.protobuf.ServiceException {
        return (org.waveprotocol.wave.diff.Diff.FetchDiffResponse) channel.callBlockingMethod(
          getDescriptor().getMethods().get(0),
          controller,
          request,
          org.waveprotocol.wave.diff.Diff.FetchDiffResponse.getDefaultInstance());
      }
      
    }
  }
  
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_diff_FetchDiffRequest_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_diff_FetchDiffRequest_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_diff_FetchDiffResponse_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_diff_FetchDiffResponse_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_diff_FetchDiffResponse_WaveletDiff_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_diff_FetchDiffResponse_WaveletDiff_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_diff_WaveletDiffSnapshot_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_diff_WaveletDiffSnapshot_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_diff_DocumentDiffSnapshot_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_diff_DocumentDiffSnapshot_fieldAccessorTable;
  
  public static com.google.protobuf.Descriptors.FileDescriptor
      getDescriptor() {
    return descriptor;
  }
  private static com.google.protobuf.Descriptors.FileDescriptor
      descriptor;
  static {
    java.lang.String[] descriptorData = {
      "\n%org/waveprotocol/wave/diff/diff.proto\022" +
      "\004diff\032)org/waveprotocol/box/server/rpc/r" +
      "pc.proto\032;org/waveprotocol/wave/concurre" +
      "ncycontrol/clientserver.proto\0326org/wavep" +
      "rotocol/wave/federation/federation.proto" +
      "devel\032*org/waveprotocol/protobuf/extensi" +
      "ons.proto\"\\\n\020FetchDiffRequest\022\016\n\006waveId\030" +
      "\001 \002(\t\0228\n\014knownWavelet\030\002 \003(\0132\".concurrenc" +
      "ycontrol.WaveletVersion\"\314\001\n\021FetchDiffRes" +
      "ponse\0222\n\006status\030\001 \002(\0132\".concurrencycontr",
      "ol.ResponseStatus\0224\n\007wavelet\030\002 \003(\0132#.dif" +
      "f.FetchDiffResponse.WaveletDiff\032M\n\013Wavel" +
      "etDiff\022\021\n\twaveletId\030\001 \002(\t\022+\n\010snapshot\030\002 " +
      "\001(\0132\031.diff.WaveletDiffSnapshot\"\242\002\n\023Wavel" +
      "etDiffSnapshot\022\021\n\twaveletId\030\001 \002(\t\022\023\n\013par" +
      "ticipant\030\002 \003(\t\022\030\n\020addedParticipant\030\025 \003(\t" +
      "\022\032\n\022removedParticipant\030\026 \003(\t\022,\n\010document" +
      "\030\003 \003(\0132\032.diff.DocumentDiffSnapshot\0222\n\007ve" +
      "rsion\030\004 \002(\0132!.federation.ProtocolHashedV" +
      "ersion\022\036\n\020lastModifiedTime\030\005 \002(\003B\004\200\265\030\001\022\017",
      "\n\007creator\030\006 \002(\t\022\032\n\014creationTime\030\007 \002(\003B\004\200" +
      "\265\030\001\"\263\002\n\024DocumentDiffSnapshot\022\022\n\ndocument" +
      "Id\030\001 \002(\t\0224\n\005state\030\002 \001(\0132%.federation.Pro" +
      "tocolDocumentOperation\0223\n\004diff\030\025 \001(\0132%.f" +
      "ederation.ProtocolDocumentOperation\022\016\n\006a" +
      "uthor\030\003 \002(\t\022\023\n\013contributor\030\004 \003(\t\022\030\n\020adde" +
      "dContributor\030\026 \003(\t\022\032\n\022removedContributor" +
      "\030\027 \003(\t\022!\n\023lastModifiedVersion\030\005 \002(\003B\004\200\265\030" +
      "\001\022\036\n\020lastModifiedTime\030\006 \002(\003B\004\200\265\030\0012L\n\020Fet" +
      "chDiffService\0228\n\005Fetch\022\026.diff.FetchDiffR",
      "equest\032\027.diff.FetchDiffResponseB\"\n\032org.w" +
      "aveprotocol.wave.diffB\004Diff"
    };
    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
      new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
        public com.google.protobuf.ExtensionRegistry assignDescriptors(
            com.google.protobuf.Descriptors.FileDescriptor root) {
          descriptor = root;
          internal_static_diff_FetchDiffRequest_descriptor =
            getDescriptor().getMessageTypes().get(0);
          internal_static_diff_FetchDiffRequest_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_diff_FetchDiffRequest_descriptor,
              new java.lang.String[] { "WaveId", "KnownWavelet", },
              org.waveprotocol.wave.diff.Diff.FetchDiffRequest.class,
              org.waveprotocol.wave.diff.Diff.FetchDiffRequest.Builder.class);
          internal_static_diff_FetchDiffResponse_descriptor =
            getDescriptor().getMessageTypes().get(1);
          internal_static_diff_FetchDiffResponse_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_diff_FetchDiffResponse_descriptor,
              new java.lang.String[] { "Status", "Wavelet", },
              org.waveprotocol.wave.diff.Diff.FetchDiffResponse.class,
              org.waveprotocol.wave.diff.Diff.FetchDiffResponse.Builder.class);
          internal_static_diff_FetchDiffResponse_WaveletDiff_descriptor =
            internal_static_diff_FetchDiffResponse_descriptor.getNestedTypes().get(0);
          internal_static_diff_FetchDiffResponse_WaveletDiff_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_diff_FetchDiffResponse_WaveletDiff_descriptor,
              new java.lang.String[] { "WaveletId", "Snapshot", },
              org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff.class,
              org.waveprotocol.wave.diff.Diff.FetchDiffResponse.WaveletDiff.Builder.class);
          internal_static_diff_WaveletDiffSnapshot_descriptor =
            getDescriptor().getMessageTypes().get(2);
          internal_static_diff_WaveletDiffSnapshot_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_diff_WaveletDiffSnapshot_descriptor,
              new java.lang.String[] { "WaveletId", "Participant", "AddedParticipant", "RemovedParticipant", "Document", "Version", "LastModifiedTime", "Creator", "CreationTime", },
              org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.class,
              org.waveprotocol.wave.diff.Diff.WaveletDiffSnapshot.Builder.class);
          internal_static_diff_DocumentDiffSnapshot_descriptor =
            getDescriptor().getMessageTypes().get(3);
          internal_static_diff_DocumentDiffSnapshot_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_diff_DocumentDiffSnapshot_descriptor,
              new java.lang.String[] { "DocumentId", "State", "Diff", "Author", "Contributor", "AddedContributor", "RemovedContributor", "LastModifiedVersion", "LastModifiedTime", },
              org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot.class,
              org.waveprotocol.wave.diff.Diff.DocumentDiffSnapshot.Builder.class);
          com.google.protobuf.ExtensionRegistry registry =
            com.google.protobuf.ExtensionRegistry.newInstance();
          registerAllExtensions(registry);
          org.waveprotocol.box.server.rpc.Rpc.registerAllExtensions(registry);
          org.waveprotocol.wave.concurrencycontrol.ClientServer.registerAllExtensions(registry);
          org.waveprotocol.wave.federation.Proto.registerAllExtensions(registry);
          org.waveprotocol.protobuf.Extensions.registerAllExtensions(registry);
          return registry;
        }
      };
    com.google.protobuf.Descriptors.FileDescriptor
      .internalBuildGeneratedFileFrom(descriptorData,
        new com.google.protobuf.Descriptors.FileDescriptor[] {
          org.waveprotocol.box.server.rpc.Rpc.getDescriptor(),
          org.waveprotocol.wave.concurrencycontrol.ClientServer.getDescriptor(),
          org.waveprotocol.wave.federation.Proto.getDescriptor(),
          org.waveprotocol.protobuf.Extensions.getDescriptor(),
        }, assigner);
  }
  
  public static void internalForceInit() {}
  
  // @@protoc_insertion_point(outer_class_scope)
}