com.google.cloud.tools.opensource.classpath.AutoValue_JarLinkageReport Maven / Gradle / Ivy

Go to download


package com.google.cloud.tools.opensource.classpath;

import com.google.common.collect.ImmutableList;
import java.nio.file.Path;
import javax.annotation.Generated;

@Generated("com.google.auto.value.processor.AutoValueProcessor")
final class AutoValue_JarLinkageReport extends JarLinkageReport {

  private final Path jarPath;

  private final ImmutableList> missingClassErrors;

  private final ImmutableList> missingMethodErrors;

  private final ImmutableList> missingFieldErrors;

  private AutoValue_JarLinkageReport(
      Path jarPath,
      ImmutableList> missingClassErrors,
      ImmutableList> missingMethodErrors,
      ImmutableList> missingFieldErrors) {
    this.jarPath = jarPath;
    this.missingClassErrors = missingClassErrors;
    this.missingMethodErrors = missingMethodErrors;
    this.missingFieldErrors = missingFieldErrors;
  }

  @Override
  public Path getJarPath() {
    return jarPath;
  }

  @Override
  public ImmutableList> getMissingClassErrors() {
    return missingClassErrors;
  }

  @Override
  public ImmutableList> getMissingMethodErrors() {
    return missingMethodErrors;
  }

  @Override
  public ImmutableList> getMissingFieldErrors() {
    return missingFieldErrors;
  }

  @Override
  public boolean equals(Object o) {
    if (o == this) {
      return true;
    }
    if (o instanceof JarLinkageReport) {
      JarLinkageReport that = (JarLinkageReport) o;
      return (this.jarPath.equals(that.getJarPath()))
           && (this.missingClassErrors.equals(that.getMissingClassErrors()))
           && (this.missingMethodErrors.equals(that.getMissingMethodErrors()))
           && (this.missingFieldErrors.equals(that.getMissingFieldErrors()));
    }
    return false;
  }

  @Override
  public int hashCode() {
    int h$ = 1;
    h$ *= 1000003;
    h$ ^= jarPath.hashCode();
    h$ *= 1000003;
    h$ ^= missingClassErrors.hashCode();
    h$ *= 1000003;
    h$ ^= missingMethodErrors.hashCode();
    h$ *= 1000003;
    h$ ^= missingFieldErrors.hashCode();
    return h$;
  }

  static final class Builder extends JarLinkageReport.Builder {
    private Path jarPath;
    private ImmutableList> missingClassErrors;
    private ImmutableList> missingMethodErrors;
    private ImmutableList> missingFieldErrors;
    Builder() {
    }
    @Override
    JarLinkageReport.Builder setJarPath(Path jarPath) {
      if (jarPath == null) {
        throw new NullPointerException("Null jarPath");
      }
      this.jarPath = jarPath;
      return this;
    }
    @Override
    JarLinkageReport.Builder setMissingClassErrors(Iterable> missingClassErrors) {
      this.missingClassErrors = ImmutableList.copyOf(missingClassErrors);
      return this;
    }
    @Override
    JarLinkageReport.Builder setMissingMethodErrors(Iterable> missingMethodErrors) {
      this.missingMethodErrors = ImmutableList.copyOf(missingMethodErrors);
      return this;
    }
    @Override
    JarLinkageReport.Builder setMissingFieldErrors(Iterable> missingFieldErrors) {
      this.missingFieldErrors = ImmutableList.copyOf(missingFieldErrors);
      return this;
    }
    @Override
    JarLinkageReport build() {
      String missing = "";
      if (this.jarPath == null) {
        missing += " jarPath";
      }
      if (this.missingClassErrors == null) {
        missing += " missingClassErrors";
      }
      if (this.missingMethodErrors == null) {
        missing += " missingMethodErrors";
      }
      if (this.missingFieldErrors == null) {
        missing += " missingFieldErrors";
      }
      if (!missing.isEmpty()) {
        throw new IllegalStateException("Missing required properties:" + missing);
      }
      return new AutoValue_JarLinkageReport(
          this.jarPath,
          this.missingClassErrors,
          this.missingMethodErrors,
          this.missingFieldErrors);
    }
  }

}