org.apache.beam.sdk.transforms.reflect.AutoValue_DoFnSignature Maven / Gradle / Ivy


package org.apache.beam.sdk.transforms.reflect;

import java.util.Map;
import javax.annotation.Generated;
import org.apache.beam.sdk.transforms.DoFn;
import org.apache.beam.sdk.values.PCollection.IsBounded;

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

  private final Class> fnClass;
  private final IsBounded isBoundedPerElement;
  private final DoFnSignature.ProcessElementMethod processElement;
  private final Map stateDeclarations;
  private final DoFnSignature.BundleMethod startBundle;
  private final DoFnSignature.BundleMethod finishBundle;
  private final DoFnSignature.LifecycleMethod setup;
  private final DoFnSignature.LifecycleMethod teardown;
  private final Map timerDeclarations;
  private final DoFnSignature.GetInitialRestrictionMethod getInitialRestriction;
  private final DoFnSignature.SplitRestrictionMethod splitRestriction;
  private final DoFnSignature.GetRestrictionCoderMethod getRestrictionCoder;
  private final DoFnSignature.NewTrackerMethod newTracker;
  private final Map onTimerMethods;

  private AutoValue_DoFnSignature(
      Class> fnClass,
      IsBounded isBoundedPerElement,
      DoFnSignature.ProcessElementMethod processElement,
      Map stateDeclarations,
      @javax.annotation.Nullable DoFnSignature.BundleMethod startBundle,
      @javax.annotation.Nullable DoFnSignature.BundleMethod finishBundle,
      @javax.annotation.Nullable DoFnSignature.LifecycleMethod setup,
      @javax.annotation.Nullable DoFnSignature.LifecycleMethod teardown,
      Map timerDeclarations,
      @javax.annotation.Nullable DoFnSignature.GetInitialRestrictionMethod getInitialRestriction,
      @javax.annotation.Nullable DoFnSignature.SplitRestrictionMethod splitRestriction,
      @javax.annotation.Nullable DoFnSignature.GetRestrictionCoderMethod getRestrictionCoder,
      @javax.annotation.Nullable DoFnSignature.NewTrackerMethod newTracker,
      @javax.annotation.Nullable Map onTimerMethods) {
    if (fnClass == null) {
      throw new NullPointerException("Null fnClass");
    }
    this.fnClass = fnClass;
    if (isBoundedPerElement == null) {
      throw new NullPointerException("Null isBoundedPerElement");
    }
    this.isBoundedPerElement = isBoundedPerElement;
    if (processElement == null) {
      throw new NullPointerException("Null processElement");
    }
    this.processElement = processElement;
    if (stateDeclarations == null) {
      throw new NullPointerException("Null stateDeclarations");
    }
    this.stateDeclarations = stateDeclarations;
    this.startBundle = startBundle;
    this.finishBundle = finishBundle;
    this.setup = setup;
    this.teardown = teardown;
    if (timerDeclarations == null) {
      throw new NullPointerException("Null timerDeclarations");
    }
    this.timerDeclarations = timerDeclarations;
    this.getInitialRestriction = getInitialRestriction;
    this.splitRestriction = splitRestriction;
    this.getRestrictionCoder = getRestrictionCoder;
    this.newTracker = newTracker;
    this.onTimerMethods = onTimerMethods;
  }

  @Override
  public Class> fnClass() {
    return fnClass;
  }

  @Override
  public IsBounded isBoundedPerElement() {
    return isBoundedPerElement;
  }

  @Override
  public DoFnSignature.ProcessElementMethod processElement() {
    return processElement;
  }

  @Override
  public Map stateDeclarations() {
    return stateDeclarations;
  }

  @javax.annotation.Nullable
  @Override
  public DoFnSignature.BundleMethod startBundle() {
    return startBundle;
  }

  @javax.annotation.Nullable
  @Override
  public DoFnSignature.BundleMethod finishBundle() {
    return finishBundle;
  }

  @javax.annotation.Nullable
  @Override
  public DoFnSignature.LifecycleMethod setup() {
    return setup;
  }

  @javax.annotation.Nullable
  @Override
  public DoFnSignature.LifecycleMethod teardown() {
    return teardown;
  }

  @Override
  public Map timerDeclarations() {
    return timerDeclarations;
  }

  @javax.annotation.Nullable
  @Override
  public DoFnSignature.GetInitialRestrictionMethod getInitialRestriction() {
    return getInitialRestriction;
  }

  @javax.annotation.Nullable
  @Override
  public DoFnSignature.SplitRestrictionMethod splitRestriction() {
    return splitRestriction;
  }

  @javax.annotation.Nullable
  @Override
  public DoFnSignature.GetRestrictionCoderMethod getRestrictionCoder() {
    return getRestrictionCoder;
  }

  @javax.annotation.Nullable
  @Override
  public DoFnSignature.NewTrackerMethod newTracker() {
    return newTracker;
  }

  @javax.annotation.Nullable
  @Override
  public Map onTimerMethods() {
    return onTimerMethods;
  }

  @Override
  public String toString() {
    return "DoFnSignature{"
        + "fnClass=" + fnClass + ", "
        + "isBoundedPerElement=" + isBoundedPerElement + ", "
        + "processElement=" + processElement + ", "
        + "stateDeclarations=" + stateDeclarations + ", "
        + "startBundle=" + startBundle + ", "
        + "finishBundle=" + finishBundle + ", "
        + "setup=" + setup + ", "
        + "teardown=" + teardown + ", "
        + "timerDeclarations=" + timerDeclarations + ", "
        + "getInitialRestriction=" + getInitialRestriction + ", "
        + "splitRestriction=" + splitRestriction + ", "
        + "getRestrictionCoder=" + getRestrictionCoder + ", "
        + "newTracker=" + newTracker + ", "
        + "onTimerMethods=" + onTimerMethods
        + "}";
  }

  @Override
  public boolean equals(Object o) {
    if (o == this) {
      return true;
    }
    if (o instanceof DoFnSignature) {
      DoFnSignature that = (DoFnSignature) o;
      return (this.fnClass.equals(that.fnClass()))
           && (this.isBoundedPerElement.equals(that.isBoundedPerElement()))
           && (this.processElement.equals(that.processElement()))
           && (this.stateDeclarations.equals(that.stateDeclarations()))
           && ((this.startBundle == null) ? (that.startBundle() == null) : this.startBundle.equals(that.startBundle()))
           && ((this.finishBundle == null) ? (that.finishBundle() == null) : this.finishBundle.equals(that.finishBundle()))
           && ((this.setup == null) ? (that.setup() == null) : this.setup.equals(that.setup()))
           && ((this.teardown == null) ? (that.teardown() == null) : this.teardown.equals(that.teardown()))
           && (this.timerDeclarations.equals(that.timerDeclarations()))
           && ((this.getInitialRestriction == null) ? (that.getInitialRestriction() == null) : this.getInitialRestriction.equals(that.getInitialRestriction()))
           && ((this.splitRestriction == null) ? (that.splitRestriction() == null) : this.splitRestriction.equals(that.splitRestriction()))
           && ((this.getRestrictionCoder == null) ? (that.getRestrictionCoder() == null) : this.getRestrictionCoder.equals(that.getRestrictionCoder()))
           && ((this.newTracker == null) ? (that.newTracker() == null) : this.newTracker.equals(that.newTracker()))
           && ((this.onTimerMethods == null) ? (that.onTimerMethods() == null) : this.onTimerMethods.equals(that.onTimerMethods()));
    }
    return false;
  }

  @Override
  public int hashCode() {
    int h = 1;
    h *= 1000003;
    h ^= fnClass.hashCode();
    h *= 1000003;
    h ^= isBoundedPerElement.hashCode();
    h *= 1000003;
    h ^= processElement.hashCode();
    h *= 1000003;
    h ^= stateDeclarations.hashCode();
    h *= 1000003;
    h ^= (startBundle == null) ? 0 : startBundle.hashCode();
    h *= 1000003;
    h ^= (finishBundle == null) ? 0 : finishBundle.hashCode();
    h *= 1000003;
    h ^= (setup == null) ? 0 : setup.hashCode();
    h *= 1000003;
    h ^= (teardown == null) ? 0 : teardown.hashCode();
    h *= 1000003;
    h ^= timerDeclarations.hashCode();
    h *= 1000003;
    h ^= (getInitialRestriction == null) ? 0 : getInitialRestriction.hashCode();
    h *= 1000003;
    h ^= (splitRestriction == null) ? 0 : splitRestriction.hashCode();
    h *= 1000003;
    h ^= (getRestrictionCoder == null) ? 0 : getRestrictionCoder.hashCode();
    h *= 1000003;
    h ^= (newTracker == null) ? 0 : newTracker.hashCode();
    h *= 1000003;
    h ^= (onTimerMethods == null) ? 0 : onTimerMethods.hashCode();
    return h;
  }

  static final class Builder extends DoFnSignature.Builder {
    private Class> fnClass;
    private IsBounded isBoundedPerElement;
    private DoFnSignature.ProcessElementMethod processElement;
    private Map stateDeclarations;
    private DoFnSignature.BundleMethod startBundle;
    private DoFnSignature.BundleMethod finishBundle;
    private DoFnSignature.LifecycleMethod setup;
    private DoFnSignature.LifecycleMethod teardown;
    private Map timerDeclarations;
    private DoFnSignature.GetInitialRestrictionMethod getInitialRestriction;
    private DoFnSignature.SplitRestrictionMethod splitRestriction;
    private DoFnSignature.GetRestrictionCoderMethod getRestrictionCoder;
    private DoFnSignature.NewTrackerMethod newTracker;
    private Map onTimerMethods;
    Builder() {
    }
    Builder(DoFnSignature source) {
      this.fnClass = source.fnClass();
      this.isBoundedPerElement = source.isBoundedPerElement();
      this.processElement = source.processElement();
      this.stateDeclarations = source.stateDeclarations();
      this.startBundle = source.startBundle();
      this.finishBundle = source.finishBundle();
      this.setup = source.setup();
      this.teardown = source.teardown();
      this.timerDeclarations = source.timerDeclarations();
      this.getInitialRestriction = source.getInitialRestriction();
      this.splitRestriction = source.splitRestriction();
      this.getRestrictionCoder = source.getRestrictionCoder();
      this.newTracker = source.newTracker();
      this.onTimerMethods = source.onTimerMethods();
    }
    @Override
    public DoFnSignature.Builder setFnClass(Class> fnClass) {
      this.fnClass = fnClass;
      return this;
    }
    @Override
    public DoFnSignature.Builder setIsBoundedPerElement(IsBounded isBoundedPerElement) {
      this.isBoundedPerElement = isBoundedPerElement;
      return this;
    }
    @Override
    public DoFnSignature.Builder setProcessElement(DoFnSignature.ProcessElementMethod processElement) {
      this.processElement = processElement;
      return this;
    }
    @Override
    public DoFnSignature.Builder setStateDeclarations(Map stateDeclarations) {
      this.stateDeclarations = stateDeclarations;
      return this;
    }
    @Override
    public DoFnSignature.Builder setStartBundle(DoFnSignature.BundleMethod startBundle) {
      this.startBundle = startBundle;
      return this;
    }
    @Override
    public DoFnSignature.Builder setFinishBundle(DoFnSignature.BundleMethod finishBundle) {
      this.finishBundle = finishBundle;
      return this;
    }
    @Override
    public DoFnSignature.Builder setSetup(DoFnSignature.LifecycleMethod setup) {
      this.setup = setup;
      return this;
    }
    @Override
    public DoFnSignature.Builder setTeardown(DoFnSignature.LifecycleMethod teardown) {
      this.teardown = teardown;
      return this;
    }
    @Override
    public DoFnSignature.Builder setTimerDeclarations(Map timerDeclarations) {
      this.timerDeclarations = timerDeclarations;
      return this;
    }
    @Override
    public DoFnSignature.Builder setGetInitialRestriction(DoFnSignature.GetInitialRestrictionMethod getInitialRestriction) {
      this.getInitialRestriction = getInitialRestriction;
      return this;
    }
    @Override
    public DoFnSignature.Builder setSplitRestriction(DoFnSignature.SplitRestrictionMethod splitRestriction) {
      this.splitRestriction = splitRestriction;
      return this;
    }
    @Override
    public DoFnSignature.Builder setGetRestrictionCoder(DoFnSignature.GetRestrictionCoderMethod getRestrictionCoder) {
      this.getRestrictionCoder = getRestrictionCoder;
      return this;
    }
    @Override
    public DoFnSignature.Builder setNewTracker(DoFnSignature.NewTrackerMethod newTracker) {
      this.newTracker = newTracker;
      return this;
    }
    @Override
    public DoFnSignature.Builder setOnTimerMethods(Map onTimerMethods) {
      this.onTimerMethods = onTimerMethods;
      return this;
    }
    @Override
    public DoFnSignature build() {
      String missing = "";
      if (fnClass == null) {
        missing += " fnClass";
      }
      if (isBoundedPerElement == null) {
        missing += " isBoundedPerElement";
      }
      if (processElement == null) {
        missing += " processElement";
      }
      if (stateDeclarations == null) {
        missing += " stateDeclarations";
      }
      if (timerDeclarations == null) {
        missing += " timerDeclarations";
      }
      if (!missing.isEmpty()) {
        throw new IllegalStateException("Missing required properties:" + missing);
      }
      return new AutoValue_DoFnSignature(
          this.fnClass,
          this.isBoundedPerElement,
          this.processElement,
          this.stateDeclarations,
          this.startBundle,
          this.finishBundle,
          this.setup,
          this.teardown,
          this.timerDeclarations,
          this.getInitialRestriction,
          this.splitRestriction,
          this.getRestrictionCoder,
          this.newTracker,
          this.onTimerMethods);
    }
  }
}