org.jclouds.azurecompute.arm.domain.loadbalancer.AutoValue_LoadBalancingRuleProperties Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jclouds-shaded Show documentation
Provides a shaded jclouds with relocated guava and guice
The newest version!

package org.jclouds.azurecompute.arm.domain.loadbalancer;

import javax.annotation.Generated;
import org.jclouds.azurecompute.arm.domain.IdReference;
import org.jclouds.javax.annotation.Nullable;

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

  private final IdReference frontendIPConfiguration;
  private final IdReference backendAddressPool;
  private final LoadBalancingRuleProperties.Protocol protocol;
  private final int frontendPort;
  private final int backendPort;
  private final IdReference probe;
  private final Boolean enableFloatingIP;
  private final Integer idleTimeoutInMinutes;
  private final LoadBalancingRuleProperties.LoadDistribution loadDistribution;
  private final String provisioningState;

  private AutoValue_LoadBalancingRuleProperties(
      @Nullable IdReference frontendIPConfiguration,
      @Nullable IdReference backendAddressPool,
      LoadBalancingRuleProperties.Protocol protocol,
      int frontendPort,
      int backendPort,
      @Nullable IdReference probe,
      @Nullable Boolean enableFloatingIP,
      @Nullable Integer idleTimeoutInMinutes,
      @Nullable LoadBalancingRuleProperties.LoadDistribution loadDistribution,
      @Nullable String provisioningState) {
    this.frontendIPConfiguration = frontendIPConfiguration;
    this.backendAddressPool = backendAddressPool;
    this.protocol = protocol;
    this.frontendPort = frontendPort;
    this.backendPort = backendPort;
    this.probe = probe;
    this.enableFloatingIP = enableFloatingIP;
    this.idleTimeoutInMinutes = idleTimeoutInMinutes;
    this.loadDistribution = loadDistribution;
    this.provisioningState = provisioningState;
  }

  @Nullable
  @Override
  public IdReference frontendIPConfiguration() {
    return frontendIPConfiguration;
  }

  @Nullable
  @Override
  public IdReference backendAddressPool() {
    return backendAddressPool;
  }

  @Override
  public LoadBalancingRuleProperties.Protocol protocol() {
    return protocol;
  }

  @Override
  public int frontendPort() {
    return frontendPort;
  }

  @Override
  public int backendPort() {
    return backendPort;
  }

  @Nullable
  @Override
  public IdReference probe() {
    return probe;
  }

  @Nullable
  @Override
  public Boolean enableFloatingIP() {
    return enableFloatingIP;
  }

  @Nullable
  @Override
  public Integer idleTimeoutInMinutes() {
    return idleTimeoutInMinutes;
  }

  @Nullable
  @Override
  public LoadBalancingRuleProperties.LoadDistribution loadDistribution() {
    return loadDistribution;
  }

  @Nullable
  @Override
  public String provisioningState() {
    return provisioningState;
  }

  @Override
  public String toString() {
    return "LoadBalancingRuleProperties{"
        + "frontendIPConfiguration=" + frontendIPConfiguration + ", "
        + "backendAddressPool=" + backendAddressPool + ", "
        + "protocol=" + protocol + ", "
        + "frontendPort=" + frontendPort + ", "
        + "backendPort=" + backendPort + ", "
        + "probe=" + probe + ", "
        + "enableFloatingIP=" + enableFloatingIP + ", "
        + "idleTimeoutInMinutes=" + idleTimeoutInMinutes + ", "
        + "loadDistribution=" + loadDistribution + ", "
        + "provisioningState=" + provisioningState
        + "}";
  }

  @Override
  public boolean equals(Object o) {
    if (o == this) {
      return true;
    }
    if (o instanceof LoadBalancingRuleProperties) {
      LoadBalancingRuleProperties that = (LoadBalancingRuleProperties) o;
      return ((this.frontendIPConfiguration == null) ? (that.frontendIPConfiguration() == null) : this.frontendIPConfiguration.equals(that.frontendIPConfiguration()))
           && ((this.backendAddressPool == null) ? (that.backendAddressPool() == null) : this.backendAddressPool.equals(that.backendAddressPool()))
           && (this.protocol.equals(that.protocol()))
           && (this.frontendPort == that.frontendPort())
           && (this.backendPort == that.backendPort())
           && ((this.probe == null) ? (that.probe() == null) : this.probe.equals(that.probe()))
           && ((this.enableFloatingIP == null) ? (that.enableFloatingIP() == null) : this.enableFloatingIP.equals(that.enableFloatingIP()))
           && ((this.idleTimeoutInMinutes == null) ? (that.idleTimeoutInMinutes() == null) : this.idleTimeoutInMinutes.equals(that.idleTimeoutInMinutes()))
           && ((this.loadDistribution == null) ? (that.loadDistribution() == null) : this.loadDistribution.equals(that.loadDistribution()))
           && ((this.provisioningState == null) ? (that.provisioningState() == null) : this.provisioningState.equals(that.provisioningState()));
    }
    return false;
  }

  @Override
  public int hashCode() {
    int h = 1;
    h *= 1000003;
    h ^= (frontendIPConfiguration == null) ? 0 : this.frontendIPConfiguration.hashCode();
    h *= 1000003;
    h ^= (backendAddressPool == null) ? 0 : this.backendAddressPool.hashCode();
    h *= 1000003;
    h ^= this.protocol.hashCode();
    h *= 1000003;
    h ^= this.frontendPort;
    h *= 1000003;
    h ^= this.backendPort;
    h *= 1000003;
    h ^= (probe == null) ? 0 : this.probe.hashCode();
    h *= 1000003;
    h ^= (enableFloatingIP == null) ? 0 : this.enableFloatingIP.hashCode();
    h *= 1000003;
    h ^= (idleTimeoutInMinutes == null) ? 0 : this.idleTimeoutInMinutes.hashCode();
    h *= 1000003;
    h ^= (loadDistribution == null) ? 0 : this.loadDistribution.hashCode();
    h *= 1000003;
    h ^= (provisioningState == null) ? 0 : this.provisioningState.hashCode();
    return h;
  }

  @Override
  public LoadBalancingRuleProperties.Builder toBuilder() {
    return new Builder(this);
  }

  static final class Builder extends LoadBalancingRuleProperties.Builder {
    private IdReference frontendIPConfiguration;
    private IdReference backendAddressPool;
    private LoadBalancingRuleProperties.Protocol protocol;
    private Integer frontendPort;
    private Integer backendPort;
    private IdReference probe;
    private Boolean enableFloatingIP;
    private Integer idleTimeoutInMinutes;
    private LoadBalancingRuleProperties.LoadDistribution loadDistribution;
    private String provisioningState;
    Builder() {
    }
    private Builder(LoadBalancingRuleProperties source) {
      this.frontendIPConfiguration = source.frontendIPConfiguration();
      this.backendAddressPool = source.backendAddressPool();
      this.protocol = source.protocol();
      this.frontendPort = source.frontendPort();
      this.backendPort = source.backendPort();
      this.probe = source.probe();
      this.enableFloatingIP = source.enableFloatingIP();
      this.idleTimeoutInMinutes = source.idleTimeoutInMinutes();
      this.loadDistribution = source.loadDistribution();
      this.provisioningState = source.provisioningState();
    }
    @Override
    public LoadBalancingRuleProperties.Builder frontendIPConfiguration(@Nullable IdReference frontendIPConfiguration) {
      this.frontendIPConfiguration = frontendIPConfiguration;
      return this;
    }
    @Override
    public LoadBalancingRuleProperties.Builder backendAddressPool(@Nullable IdReference backendAddressPool) {
      this.backendAddressPool = backendAddressPool;
      return this;
    }
    @Override
    public LoadBalancingRuleProperties.Builder protocol(LoadBalancingRuleProperties.Protocol protocol) {
      if (protocol == null) {
        throw new NullPointerException("Null protocol");
      }
      this.protocol = protocol;
      return this;
    }
    @Override
    public LoadBalancingRuleProperties.Builder frontendPort(int frontendPort) {
      this.frontendPort = frontendPort;
      return this;
    }
    @Override
    public LoadBalancingRuleProperties.Builder backendPort(int backendPort) {
      this.backendPort = backendPort;
      return this;
    }
    @Override
    public LoadBalancingRuleProperties.Builder probe(@Nullable IdReference probe) {
      this.probe = probe;
      return this;
    }
    @Override
    public LoadBalancingRuleProperties.Builder enableFloatingIP(@Nullable Boolean enableFloatingIP) {
      this.enableFloatingIP = enableFloatingIP;
      return this;
    }
    @Override
    public LoadBalancingRuleProperties.Builder idleTimeoutInMinutes(@Nullable Integer idleTimeoutInMinutes) {
      this.idleTimeoutInMinutes = idleTimeoutInMinutes;
      return this;
    }
    @Override
    public LoadBalancingRuleProperties.Builder loadDistribution(@Nullable LoadBalancingRuleProperties.LoadDistribution loadDistribution) {
      this.loadDistribution = loadDistribution;
      return this;
    }
    @Override
    public LoadBalancingRuleProperties.Builder provisioningState(@Nullable String provisioningState) {
      this.provisioningState = provisioningState;
      return this;
    }
    @Override
    public LoadBalancingRuleProperties build() {
      String missing = "";
      if (this.protocol == null) {
        missing += " protocol";
      }
      if (this.frontendPort == null) {
        missing += " frontendPort";
      }
      if (this.backendPort == null) {
        missing += " backendPort";
      }
      if (!missing.isEmpty()) {
        throw new IllegalStateException("Missing required properties:" + missing);
      }
      return new AutoValue_LoadBalancingRuleProperties(
          this.frontendIPConfiguration,
          this.backendAddressPool,
          this.protocol,
          this.frontendPort,
          this.backendPort,
          this.probe,
          this.enableFloatingIP,
          this.idleTimeoutInMinutes,
          this.loadDistribution,
          this.provisioningState);
    }
  }

}