com.google.gerrit.server.account.AutoValue_Preferences_Diff Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gerrit-plugin-api Show documentation
API for Gerrit Plugins
There is a newer version: 3.11.1
package com.google.gerrit.server.account;

import com.google.gerrit.common.Nullable;
import com.google.gerrit.extensions.client.DiffPreferencesInfo;
import java.util.Optional;
import javax.annotation.Generated;

@Generated("com.google.auto.value.processor.AutoValueProcessor")
final class AutoValue_Preferences_Diff extends Preferences.Diff {

  private final Optional context;

  private final Optional tabSize;

  private final Optional fontSize;

  private final Optional lineLength;

  private final Optional cursorBlinkRate;

  private final Optional expandAllComments;

  private final Optional intralineDifference;

  private final Optional manualReview;

  private final Optional showLineEndings;

  private final Optional showTabs;

  private final Optional showWhitespaceErrors;

  private final Optional syntaxHighlighting;

  private final Optional hideTopMenu;

  private final Optional autoHideDiffTableHeader;

  private final Optional hideLineNumbers;

  private final Optional renderEntireFile;

  private final Optional hideEmptyPane;

  private final Optional matchBrackets;

  private final Optional lineWrapping;

  private final Optional ignoreWhitespace;

  private final Optional retainHeader;

  private final Optional skipDeleted;

  private final Optional skipUnchanged;

  private final Optional skipUncommented;

  private AutoValue_Preferences_Diff(
      Optional context,
      Optional tabSize,
      Optional fontSize,
      Optional lineLength,
      Optional cursorBlinkRate,
      Optional expandAllComments,
      Optional intralineDifference,
      Optional manualReview,
      Optional showLineEndings,
      Optional showTabs,
      Optional showWhitespaceErrors,
      Optional syntaxHighlighting,
      Optional hideTopMenu,
      Optional autoHideDiffTableHeader,
      Optional hideLineNumbers,
      Optional renderEntireFile,
      Optional hideEmptyPane,
      Optional matchBrackets,
      Optional lineWrapping,
      Optional ignoreWhitespace,
      Optional retainHeader,
      Optional skipDeleted,
      Optional skipUnchanged,
      Optional skipUncommented) {
    this.context = context;
    this.tabSize = tabSize;
    this.fontSize = fontSize;
    this.lineLength = lineLength;
    this.cursorBlinkRate = cursorBlinkRate;
    this.expandAllComments = expandAllComments;
    this.intralineDifference = intralineDifference;
    this.manualReview = manualReview;
    this.showLineEndings = showLineEndings;
    this.showTabs = showTabs;
    this.showWhitespaceErrors = showWhitespaceErrors;
    this.syntaxHighlighting = syntaxHighlighting;
    this.hideTopMenu = hideTopMenu;
    this.autoHideDiffTableHeader = autoHideDiffTableHeader;
    this.hideLineNumbers = hideLineNumbers;
    this.renderEntireFile = renderEntireFile;
    this.hideEmptyPane = hideEmptyPane;
    this.matchBrackets = matchBrackets;
    this.lineWrapping = lineWrapping;
    this.ignoreWhitespace = ignoreWhitespace;
    this.retainHeader = retainHeader;
    this.skipDeleted = skipDeleted;
    this.skipUnchanged = skipUnchanged;
    this.skipUncommented = skipUncommented;
  }

  @Override
  public Optional context() {
    return context;
  }

  @Override
  public Optional tabSize() {
    return tabSize;
  }

  @Override
  public Optional fontSize() {
    return fontSize;
  }

  @Override
  public Optional lineLength() {
    return lineLength;
  }

  @Override
  public Optional cursorBlinkRate() {
    return cursorBlinkRate;
  }

  @Override
  public Optional expandAllComments() {
    return expandAllComments;
  }

  @Override
  public Optional intralineDifference() {
    return intralineDifference;
  }

  @Override
  public Optional manualReview() {
    return manualReview;
  }

  @Override
  public Optional showLineEndings() {
    return showLineEndings;
  }

  @Override
  public Optional showTabs() {
    return showTabs;
  }

  @Override
  public Optional showWhitespaceErrors() {
    return showWhitespaceErrors;
  }

  @Override
  public Optional syntaxHighlighting() {
    return syntaxHighlighting;
  }

  @Override
  public Optional hideTopMenu() {
    return hideTopMenu;
  }

  @Override
  public Optional autoHideDiffTableHeader() {
    return autoHideDiffTableHeader;
  }

  @Override
  public Optional hideLineNumbers() {
    return hideLineNumbers;
  }

  @Override
  public Optional renderEntireFile() {
    return renderEntireFile;
  }

  @Override
  public Optional hideEmptyPane() {
    return hideEmptyPane;
  }

  @Override
  public Optional matchBrackets() {
    return matchBrackets;
  }

  @Override
  public Optional lineWrapping() {
    return lineWrapping;
  }

  @Override
  public Optional ignoreWhitespace() {
    return ignoreWhitespace;
  }

  @Override
  public Optional retainHeader() {
    return retainHeader;
  }

  @Override
  public Optional skipDeleted() {
    return skipDeleted;
  }

  @Override
  public Optional skipUnchanged() {
    return skipUnchanged;
  }

  @Override
  public Optional skipUncommented() {
    return skipUncommented;
  }

  @Override
  public String toString() {
    return "Diff{"
         + "context=" + context + ", "
         + "tabSize=" + tabSize + ", "
         + "fontSize=" + fontSize + ", "
         + "lineLength=" + lineLength + ", "
         + "cursorBlinkRate=" + cursorBlinkRate + ", "
         + "expandAllComments=" + expandAllComments + ", "
         + "intralineDifference=" + intralineDifference + ", "
         + "manualReview=" + manualReview + ", "
         + "showLineEndings=" + showLineEndings + ", "
         + "showTabs=" + showTabs + ", "
         + "showWhitespaceErrors=" + showWhitespaceErrors + ", "
         + "syntaxHighlighting=" + syntaxHighlighting + ", "
         + "hideTopMenu=" + hideTopMenu + ", "
         + "autoHideDiffTableHeader=" + autoHideDiffTableHeader + ", "
         + "hideLineNumbers=" + hideLineNumbers + ", "
         + "renderEntireFile=" + renderEntireFile + ", "
         + "hideEmptyPane=" + hideEmptyPane + ", "
         + "matchBrackets=" + matchBrackets + ", "
         + "lineWrapping=" + lineWrapping + ", "
         + "ignoreWhitespace=" + ignoreWhitespace + ", "
         + "retainHeader=" + retainHeader + ", "
         + "skipDeleted=" + skipDeleted + ", "
         + "skipUnchanged=" + skipUnchanged + ", "
         + "skipUncommented=" + skipUncommented
        + "}";
  }

  @Override
  public boolean equals(Object o) {
    if (o == this) {
      return true;
    }
    if (o instanceof Preferences.Diff) {
      Preferences.Diff that = (Preferences.Diff) o;
      return this.context.equals(that.context())
          && this.tabSize.equals(that.tabSize())
          && this.fontSize.equals(that.fontSize())
          && this.lineLength.equals(that.lineLength())
          && this.cursorBlinkRate.equals(that.cursorBlinkRate())
          && this.expandAllComments.equals(that.expandAllComments())
          && this.intralineDifference.equals(that.intralineDifference())
          && this.manualReview.equals(that.manualReview())
          && this.showLineEndings.equals(that.showLineEndings())
          && this.showTabs.equals(that.showTabs())
          && this.showWhitespaceErrors.equals(that.showWhitespaceErrors())
          && this.syntaxHighlighting.equals(that.syntaxHighlighting())
          && this.hideTopMenu.equals(that.hideTopMenu())
          && this.autoHideDiffTableHeader.equals(that.autoHideDiffTableHeader())
          && this.hideLineNumbers.equals(that.hideLineNumbers())
          && this.renderEntireFile.equals(that.renderEntireFile())
          && this.hideEmptyPane.equals(that.hideEmptyPane())
          && this.matchBrackets.equals(that.matchBrackets())
          && this.lineWrapping.equals(that.lineWrapping())
          && this.ignoreWhitespace.equals(that.ignoreWhitespace())
          && this.retainHeader.equals(that.retainHeader())
          && this.skipDeleted.equals(that.skipDeleted())
          && this.skipUnchanged.equals(that.skipUnchanged())
          && this.skipUncommented.equals(that.skipUncommented());
    }
    return false;
  }

  @Override
  public int hashCode() {
    int h$ = 1;
    h$ *= 1000003;
    h$ ^= context.hashCode();
    h$ *= 1000003;
    h$ ^= tabSize.hashCode();
    h$ *= 1000003;
    h$ ^= fontSize.hashCode();
    h$ *= 1000003;
    h$ ^= lineLength.hashCode();
    h$ *= 1000003;
    h$ ^= cursorBlinkRate.hashCode();
    h$ *= 1000003;
    h$ ^= expandAllComments.hashCode();
    h$ *= 1000003;
    h$ ^= intralineDifference.hashCode();
    h$ *= 1000003;
    h$ ^= manualReview.hashCode();
    h$ *= 1000003;
    h$ ^= showLineEndings.hashCode();
    h$ *= 1000003;
    h$ ^= showTabs.hashCode();
    h$ *= 1000003;
    h$ ^= showWhitespaceErrors.hashCode();
    h$ *= 1000003;
    h$ ^= syntaxHighlighting.hashCode();
    h$ *= 1000003;
    h$ ^= hideTopMenu.hashCode();
    h$ *= 1000003;
    h$ ^= autoHideDiffTableHeader.hashCode();
    h$ *= 1000003;
    h$ ^= hideLineNumbers.hashCode();
    h$ *= 1000003;
    h$ ^= renderEntireFile.hashCode();
    h$ *= 1000003;
    h$ ^= hideEmptyPane.hashCode();
    h$ *= 1000003;
    h$ ^= matchBrackets.hashCode();
    h$ *= 1000003;
    h$ ^= lineWrapping.hashCode();
    h$ *= 1000003;
    h$ ^= ignoreWhitespace.hashCode();
    h$ *= 1000003;
    h$ ^= retainHeader.hashCode();
    h$ *= 1000003;
    h$ ^= skipDeleted.hashCode();
    h$ *= 1000003;
    h$ ^= skipUnchanged.hashCode();
    h$ *= 1000003;
    h$ ^= skipUncommented.hashCode();
    return h$;
  }

  static final class Builder extends Preferences.Diff.Builder {
    private Optional context = Optional.empty();
    private Optional tabSize = Optional.empty();
    private Optional fontSize = Optional.empty();
    private Optional lineLength = Optional.empty();
    private Optional cursorBlinkRate = Optional.empty();
    private Optional expandAllComments = Optional.empty();
    private Optional intralineDifference = Optional.empty();
    private Optional manualReview = Optional.empty();
    private Optional showLineEndings = Optional.empty();
    private Optional showTabs = Optional.empty();
    private Optional showWhitespaceErrors = Optional.empty();
    private Optional syntaxHighlighting = Optional.empty();
    private Optional hideTopMenu = Optional.empty();
    private Optional autoHideDiffTableHeader = Optional.empty();
    private Optional hideLineNumbers = Optional.empty();
    private Optional renderEntireFile = Optional.empty();
    private Optional hideEmptyPane = Optional.empty();
    private Optional matchBrackets = Optional.empty();
    private Optional lineWrapping = Optional.empty();
    private Optional ignoreWhitespace = Optional.empty();
    private Optional retainHeader = Optional.empty();
    private Optional skipDeleted = Optional.empty();
    private Optional skipUnchanged = Optional.empty();
    private Optional skipUncommented = Optional.empty();
    Builder() {
    }
    @Override
    Preferences.Diff.Builder context(@Nullable Integer context) {
      this.context = Optional.ofNullable(context);
      return this;
    }
    @Override
    Preferences.Diff.Builder tabSize(@Nullable Integer tabSize) {
      this.tabSize = Optional.ofNullable(tabSize);
      return this;
    }
    @Override
    Preferences.Diff.Builder fontSize(@Nullable Integer fontSize) {
      this.fontSize = Optional.ofNullable(fontSize);
      return this;
    }
    @Override
    Preferences.Diff.Builder lineLength(@Nullable Integer lineLength) {
      this.lineLength = Optional.ofNullable(lineLength);
      return this;
    }
    @Override
    Preferences.Diff.Builder cursorBlinkRate(@Nullable Integer cursorBlinkRate) {
      this.cursorBlinkRate = Optional.ofNullable(cursorBlinkRate);
      return this;
    }
    @Override
    Preferences.Diff.Builder expandAllComments(@Nullable Boolean expandAllComments) {
      this.expandAllComments = Optional.ofNullable(expandAllComments);
      return this;
    }
    @Override
    Preferences.Diff.Builder intralineDifference(@Nullable Boolean intralineDifference) {
      this.intralineDifference = Optional.ofNullable(intralineDifference);
      return this;
    }
    @Override
    Preferences.Diff.Builder manualReview(@Nullable Boolean manualReview) {
      this.manualReview = Optional.ofNullable(manualReview);
      return this;
    }
    @Override
    Preferences.Diff.Builder showLineEndings(@Nullable Boolean showLineEndings) {
      this.showLineEndings = Optional.ofNullable(showLineEndings);
      return this;
    }
    @Override
    Preferences.Diff.Builder showTabs(@Nullable Boolean showTabs) {
      this.showTabs = Optional.ofNullable(showTabs);
      return this;
    }
    @Override
    Preferences.Diff.Builder showWhitespaceErrors(@Nullable Boolean showWhitespaceErrors) {
      this.showWhitespaceErrors = Optional.ofNullable(showWhitespaceErrors);
      return this;
    }
    @Override
    Preferences.Diff.Builder syntaxHighlighting(@Nullable Boolean syntaxHighlighting) {
      this.syntaxHighlighting = Optional.ofNullable(syntaxHighlighting);
      return this;
    }
    @Override
    Preferences.Diff.Builder hideTopMenu(@Nullable Boolean hideTopMenu) {
      this.hideTopMenu = Optional.ofNullable(hideTopMenu);
      return this;
    }
    @Override
    Preferences.Diff.Builder autoHideDiffTableHeader(@Nullable Boolean autoHideDiffTableHeader) {
      this.autoHideDiffTableHeader = Optional.ofNullable(autoHideDiffTableHeader);
      return this;
    }
    @Override
    Preferences.Diff.Builder hideLineNumbers(@Nullable Boolean hideLineNumbers) {
      this.hideLineNumbers = Optional.ofNullable(hideLineNumbers);
      return this;
    }
    @Override
    Preferences.Diff.Builder renderEntireFile(@Nullable Boolean renderEntireFile) {
      this.renderEntireFile = Optional.ofNullable(renderEntireFile);
      return this;
    }
    @Override
    Preferences.Diff.Builder hideEmptyPane(@Nullable Boolean hideEmptyPane) {
      this.hideEmptyPane = Optional.ofNullable(hideEmptyPane);
      return this;
    }
    @Override
    Preferences.Diff.Builder matchBrackets(@Nullable Boolean matchBrackets) {
      this.matchBrackets = Optional.ofNullable(matchBrackets);
      return this;
    }
    @Override
    Preferences.Diff.Builder lineWrapping(@Nullable Boolean lineWrapping) {
      this.lineWrapping = Optional.ofNullable(lineWrapping);
      return this;
    }
    @Override
    Preferences.Diff.Builder ignoreWhitespace(@Nullable DiffPreferencesInfo.Whitespace ignoreWhitespace) {
      this.ignoreWhitespace = Optional.ofNullable(ignoreWhitespace);
      return this;
    }
    @Override
    Preferences.Diff.Builder retainHeader(@Nullable Boolean retainHeader) {
      this.retainHeader = Optional.ofNullable(retainHeader);
      return this;
    }
    @Override
    Preferences.Diff.Builder skipDeleted(@Nullable Boolean skipDeleted) {
      this.skipDeleted = Optional.ofNullable(skipDeleted);
      return this;
    }
    @Override
    Preferences.Diff.Builder skipUnchanged(@Nullable Boolean skipUnchanged) {
      this.skipUnchanged = Optional.ofNullable(skipUnchanged);
      return this;
    }
    @Override
    Preferences.Diff.Builder skipUncommented(@Nullable Boolean skipUncommented) {
      this.skipUncommented = Optional.ofNullable(skipUncommented);
      return this;
    }
    @Override
    Preferences.Diff build() {
      return new AutoValue_Preferences_Diff(
          this.context,
          this.tabSize,
          this.fontSize,
          this.lineLength,
          this.cursorBlinkRate,
          this.expandAllComments,
          this.intralineDifference,
          this.manualReview,
          this.showLineEndings,
          this.showTabs,
          this.showWhitespaceErrors,
          this.syntaxHighlighting,
          this.hideTopMenu,
          this.autoHideDiffTableHeader,
          this.hideLineNumbers,
          this.renderEntireFile,
          this.hideEmptyPane,
          this.matchBrackets,
          this.lineWrapping,
          this.ignoreWhitespace,
          this.retainHeader,
          this.skipDeleted,
          this.skipUnchanged,
          this.skipUncommented);
    }
  }

}