org.immutables.fixture.style.AInterfaceBuilder Maven / Gradle / Ivy

Go to download
package org.immutables.fixture.style;

import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import java.util.List;
import javax.annotation.Generated;
import javax.annotation.Nullable;
import javax.annotation.ParametersAreNonnullByDefault;
import javax.annotation.concurrent.Immutable;
import javax.annotation.concurrent.NotThreadSafe;

/**
 * Builds instances of type {@link AInterfaceBuilder.ImmutableAInterface ImmutableAInterface}.
 * Initialize attributes and then invoke the {@link #build()} method to create an
 * immutable instance.
 * {@code AInterfaceBuilder} is not thread-safe and generally should not be stored in a field or collection,
 * but instead used immediately to create instances.
 */
@SuppressWarnings("all")
@ParametersAreNonnullByDefault
@Generated({"Immutables.generator", "AInterface"})
@NotThreadSafe
final class AInterfaceBuilder {
  private static final long INIT_BIT_STRING = 0x1L;
  private long initBits = 0x1L;

  private @Nullable String string;

  /**
   * Creates a builder for {@link AInterfaceBuilder.ImmutableAInterface ImmutableAInterface} instances.
   */
  AInterfaceBuilder() {
  }

  /**
   * Fill a builder with attribute values from the provided {@code AInterface} instance.
   * Regular attribute values will be replaced with those from the given instance.
   * Absent optional values will not replace present values.
   * @param instance The instance from which to copy values
   * @return {@code this} builder for use in a chained invocation
   */
  public final AInterfaceBuilder from(AInterface instance) {
    Preconditions.checkNotNull(instance, "instance");
    string(instance.getString());
    return this;
  }

  /**
   * Initializes the value for the {@link AInterface#getString() string} attribute.
   * @param string The value for string 
   * @return {@code this} builder for use in a chained invocation
   */
  public final AInterfaceBuilder string(String string) {
    this.string = Preconditions.checkNotNull(string, "string");
    initBits &= ~INIT_BIT_STRING;
    return this;
  }

  /**
   * Builds a new {@link AInterfaceBuilder.ImmutableAInterface ImmutableAInterface}.
   * @return An immutable instance of AInterface
   * @throws java.lang.IllegalStateException if any required attributes are missing
   */
  public ImmutableAInterface build() {
    if (initBits != 0) {
      throw new IllegalStateException(formatRequiredAttributesMessage());
    }
    return new AInterfaceBuilder.ImmutableAInterface(string);
  }

  private String formatRequiredAttributesMessage() {
    List attributes = Lists.newArrayList();
    if ((initBits & INIT_BIT_STRING) != 0) attributes.add("string");
    return "Cannot build AInterface, some of required attributes are not set " + attributes;
  }

  /**
   * Immutable implementation of {@link AInterface}.
   * 
   * Use the builder to create immutable instances:
   * {@code new AInterfaceBuilder()}.
   */
  @Immutable
  public static final class ImmutableAInterface implements AInterface {
    private final String string;

    private ImmutableAInterface(String string) {
      this.string = string;
    }

    /**
     * @return The value of the {@code string} attribute
     */
    @Override
    public String getString() {
      return string;
    }

    /**
     * Copy the current immutable object by setting a value for the {@link AInterface#getString() string} attribute.
     * An equals check used to prevent copying of the same value by returning {@code this}.
     * @param string A new value for string
     * @return A modified copy of the {@code this} object
     */
    public final ImmutableAInterface withString(String string) {
      if (this.string.equals(string)) return this;
      String newValue = Preconditions.checkNotNull(string, "string");
      return new ImmutableAInterface(newValue);
    }

    /**
     * This instance is equal to all instances of {@code ImmutableAInterface} that have equal attribute values.
     * @return {@code true} if {@code this} is equal to {@code another} instance
     */
    @Override
    public boolean equals(@Nullable Object another) {
      if (this == another) return true;
      return another instanceof ImmutableAInterface
          && equalTo((ImmutableAInterface) another);
    }

    private boolean equalTo(ImmutableAInterface another) {
      return string.equals(another.string);
    }

    /**
     * Computes a hash code from attributes: {@code string}.
     * @return hashCode value
     */
    @Override
    public int hashCode() {
      int h = 31;
      h = h * 17 + string.hashCode();
      return h;
    }

    /**
     * Prints the immutable value {@code AInterface} with attribute values.
     * @return A string representation of the value
     */
    @Override
    public String toString() {
      return MoreObjects.toStringHelper("AInterface")
          .omitNullValues()
          .add("string", string)
          .toString();
    }

    /**
     * Creates an immutable copy of a {@link AInterface} value.
     * Uses accessors to get values to initialize the new immutable instance.
     * If an instance is already immutable, it is returned as is.
     * @param instance The instance to copy
     * @return A copied immutable AInterface instance
     */
    public static AInterfaceBuilder.ImmutableAInterface copyOf(AInterface instance) {
      if (instance instanceof AInterfaceBuilder.ImmutableAInterface) {
        return (AInterfaceBuilder.ImmutableAInterface) instance;
      }
      return new AInterfaceBuilder()
          .from(instance)
          .build();
    }
  }
}