com.google.javascript.jscomp.AutoValue_ModuleMetadata_Module Maven / Gradle / Ivy

Go to download

package com.google.javascript.jscomp;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.javascript.jscomp.deps.ModuleLoader;
import javax.annotation.Generated;
import javax.annotation.Nullable;

@Generated("com.google.auto.value.processor.AutoValueProcessor")
 final class AutoValue_ModuleMetadata_Module extends ModuleMetadata.Module {

  private final ModuleMetadata.ModuleType moduleType;
  private final boolean usesClosure;
  private final boolean isTestOnly;
  private final ImmutableSet googNamespaces;
  private final ImmutableSet requiredGoogNamespaces;
  private final ImmutableSet requiredTypes;
  private final ImmutableSet es6ImportSpecifiers;
  private final ImmutableList nestedModules;
  private final ModuleLoader.ModulePath path;

  private AutoValue_ModuleMetadata_Module(
      ModuleMetadata.ModuleType moduleType,
      boolean usesClosure,
      boolean isTestOnly,
      ImmutableSet googNamespaces,
      ImmutableSet requiredGoogNamespaces,
      ImmutableSet requiredTypes,
      ImmutableSet es6ImportSpecifiers,
      ImmutableList nestedModules,
      @Nullable ModuleLoader.ModulePath path) {
    this.moduleType = moduleType;
    this.usesClosure = usesClosure;
    this.isTestOnly = isTestOnly;
    this.googNamespaces = googNamespaces;
    this.requiredGoogNamespaces = requiredGoogNamespaces;
    this.requiredTypes = requiredTypes;
    this.es6ImportSpecifiers = es6ImportSpecifiers;
    this.nestedModules = nestedModules;
    this.path = path;
  }

  @Override
  public ModuleMetadata.ModuleType moduleType() {
    return moduleType;
  }

  @Override
  public boolean usesClosure() {
    return usesClosure;
  }

  @Override
  public boolean isTestOnly() {
    return isTestOnly;
  }

  @Override
  public ImmutableSet googNamespaces() {
    return googNamespaces;
  }

  @Override
  public ImmutableSet requiredGoogNamespaces() {
    return requiredGoogNamespaces;
  }

  @Override
  public ImmutableSet requiredTypes() {
    return requiredTypes;
  }

  @Override
  public ImmutableSet es6ImportSpecifiers() {
    return es6ImportSpecifiers;
  }

  @Override
  ImmutableList nestedModules() {
    return nestedModules;
  }

  @Nullable
  @Override
  public ModuleLoader.ModulePath path() {
    return path;
  }

  @Override
  public String toString() {
    return "Module{"
        + "moduleType=" + moduleType + ", "
        + "usesClosure=" + usesClosure + ", "
        + "isTestOnly=" + isTestOnly + ", "
        + "googNamespaces=" + googNamespaces + ", "
        + "requiredGoogNamespaces=" + requiredGoogNamespaces + ", "
        + "requiredTypes=" + requiredTypes + ", "
        + "es6ImportSpecifiers=" + es6ImportSpecifiers + ", "
        + "nestedModules=" + nestedModules + ", "
        + "path=" + path
        + "}";
  }

  @Override
  public boolean equals(Object o) {
    if (o == this) {
      return true;
    }
    if (o instanceof ModuleMetadata.Module) {
      ModuleMetadata.Module that = (ModuleMetadata.Module) o;
      return (this.moduleType.equals(that.moduleType()))
           && (this.usesClosure == that.usesClosure())
           && (this.isTestOnly == that.isTestOnly())
           && (this.googNamespaces.equals(that.googNamespaces()))
           && (this.requiredGoogNamespaces.equals(that.requiredGoogNamespaces()))
           && (this.requiredTypes.equals(that.requiredTypes()))
           && (this.es6ImportSpecifiers.equals(that.es6ImportSpecifiers()))
           && (this.nestedModules.equals(that.nestedModules()))
           && ((this.path == null) ? (that.path() == null) : this.path.equals(that.path()));
    }
    return false;
  }

  @Override
  public int hashCode() {
    int h = 1;
    h *= 1000003;
    h ^= this.moduleType.hashCode();
    h *= 1000003;
    h ^= this.usesClosure ? 1231 : 1237;
    h *= 1000003;
    h ^= this.isTestOnly ? 1231 : 1237;
    h *= 1000003;
    h ^= this.googNamespaces.hashCode();
    h *= 1000003;
    h ^= this.requiredGoogNamespaces.hashCode();
    h *= 1000003;
    h ^= this.requiredTypes.hashCode();
    h *= 1000003;
    h ^= this.es6ImportSpecifiers.hashCode();
    h *= 1000003;
    h ^= this.nestedModules.hashCode();
    h *= 1000003;
    h ^= (path == null) ? 0 : this.path.hashCode();
    return h;
  }

  static final class Builder extends ModuleMetadata.Module.Builder {
    private ModuleMetadata.ModuleType moduleType;
    private Boolean usesClosure;
    private Boolean isTestOnly;
    private ImmutableSet.Builder googNamespacesBuilder$;
    private ImmutableSet googNamespaces;
    private ImmutableSet.Builder requiredGoogNamespacesBuilder$;
    private ImmutableSet requiredGoogNamespaces;
    private ImmutableSet.Builder requiredTypesBuilder$;
    private ImmutableSet requiredTypes;
    private ImmutableSet.Builder es6ImportSpecifiersBuilder$;
    private ImmutableSet es6ImportSpecifiers;
    private ImmutableList.Builder nestedModulesBuilder$;
    private ImmutableList nestedModules;
    private ModuleLoader.ModulePath path;
    Builder() {
    }
    @Override
    ModuleMetadata.Module.Builder moduleType(ModuleMetadata.ModuleType moduleType) {
      if (moduleType == null) {
        throw new NullPointerException("Null moduleType");
      }
      this.moduleType = moduleType;
      return this;
    }
    @Override
    ModuleMetadata.ModuleType moduleType() {
      if (moduleType == null) {
        throw new IllegalStateException("Property \"moduleType\" has not been set");
      }
      return moduleType;
    }
    @Override
    ModuleMetadata.Module.Builder usesClosure(boolean usesClosure) {
      this.usesClosure = usesClosure;
      return this;
    }
    @Override
    ModuleMetadata.Module.Builder isTestOnly(boolean isTestOnly) {
      this.isTestOnly = isTestOnly;
      return this;
    }
    @Override
    ImmutableSet.Builder googNamespacesBuilder() {
      if (googNamespacesBuilder$ == null) {
        googNamespacesBuilder$ = ImmutableSet.builder();
      }
      return googNamespacesBuilder$;
    }
    @Override
    ImmutableSet.Builder requiredGoogNamespacesBuilder() {
      if (requiredGoogNamespacesBuilder$ == null) {
        requiredGoogNamespacesBuilder$ = ImmutableSet.builder();
      }
      return requiredGoogNamespacesBuilder$;
    }
    @Override
    ImmutableSet.Builder requiredTypesBuilder() {
      if (requiredTypesBuilder$ == null) {
        requiredTypesBuilder$ = ImmutableSet.builder();
      }
      return requiredTypesBuilder$;
    }
    @Override
    ImmutableSet.Builder es6ImportSpecifiersBuilder() {
      if (es6ImportSpecifiersBuilder$ == null) {
        es6ImportSpecifiersBuilder$ = ImmutableSet.builder();
      }
      return es6ImportSpecifiersBuilder$;
    }
    @Override
    ImmutableList.Builder nestedModulesBuilder() {
      if (nestedModulesBuilder$ == null) {
        nestedModulesBuilder$ = ImmutableList.builder();
      }
      return nestedModulesBuilder$;
    }
    @Override
    ModuleMetadata.Module.Builder path(@Nullable ModuleLoader.ModulePath path) {
      this.path = path;
      return this;
    }
    @Override
    ModuleMetadata.Module buildInternal() {
      if (googNamespacesBuilder$ != null) {
        this.googNamespaces = googNamespacesBuilder$.build();
      } else if (this.googNamespaces == null) {
        this.googNamespaces = ImmutableSet.of();
      }
      if (requiredGoogNamespacesBuilder$ != null) {
        this.requiredGoogNamespaces = requiredGoogNamespacesBuilder$.build();
      } else if (this.requiredGoogNamespaces == null) {
        this.requiredGoogNamespaces = ImmutableSet.of();
      }
      if (requiredTypesBuilder$ != null) {
        this.requiredTypes = requiredTypesBuilder$.build();
      } else if (this.requiredTypes == null) {
        this.requiredTypes = ImmutableSet.of();
      }
      if (es6ImportSpecifiersBuilder$ != null) {
        this.es6ImportSpecifiers = es6ImportSpecifiersBuilder$.build();
      } else if (this.es6ImportSpecifiers == null) {
        this.es6ImportSpecifiers = ImmutableSet.of();
      }
      if (nestedModulesBuilder$ != null) {
        this.nestedModules = nestedModulesBuilder$.build();
      } else if (this.nestedModules == null) {
        this.nestedModules = ImmutableList.of();
      }
      String missing = "";
      if (this.moduleType == null) {
        missing += " moduleType";
      }
      if (this.usesClosure == null) {
        missing += " usesClosure";
      }
      if (this.isTestOnly == null) {
        missing += " isTestOnly";
      }
      if (!missing.isEmpty()) {
        throw new IllegalStateException("Missing required properties:" + missing);
      }
      return new AutoValue_ModuleMetadata_Module(
          this.moduleType,
          this.usesClosure,
          this.isTestOnly,
          this.googNamespaces,
          this.requiredGoogNamespaces,
          this.requiredTypes,
          this.es6ImportSpecifiers,
          this.nestedModules,
          this.path);
    }
  }

}