Checks if an alternative has been recorded in {@link AttributeDefinition#getAlternatives() names of alternative attributes}
@param alternative the alternative
@return a builder that can be used to continue building the attribute definition
172392
@SuppressWarnings("deprecation")
    private boolean isAlternativePresent(final String alternative) {
        if (alternatives == null) {
            return false;
        }
        for (String alt : alternatives) {
            if (alt.equals(alternative)) {
                return true;
            }
        }
        return false;
    }
940314
@Override
	public Collection<Alternative> getAlternatives() {

		List<Alternative> allSuggestions = new ArrayList<>();
		for (List<Alternative> suggestions : this.suggestions.values()) {
			allSuggestions.addAll(suggestions);
		}
		return allSuggestions;
	}
1191028
def visit_alternative(alternativeNd)
      broadcast(:before_alternative, alternativeNd)
      unless alternativeNd.signature_exist?
        alternativeNd.add_edge_signatures(prime_enum)
      end

      traverse_children(alternativeNd)
      broadcast(:after_alternative, alternativeNd)
    end
1313872
public List<Alternatives<Beans<T>>> getAllAlternatives()
   {
      List<Alternatives<Beans<T>>> list = new ArrayList<Alternatives<Beans<T>>>();
      List<Node> nodeList = childNode.get("alternatives");
      for(Node node: nodeList)
      {
         Alternatives<Beans<T>>  type = new AlternativesImpl<Beans<T>>(this, "alternatives", childNode, node);
         list.add(type);
      }
      return list;
   }
1346805
@Nonnull
	public static <T> LConsumer<T> consumerFrom(Consumer<LConsumerBuilder<T>> buildingFunction) {
		LConsumerBuilder builder = new LConsumerBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
396894
public static AlternateCoordinate getMainAlternate(Variant variant) {
        VariantType type;
        switch (variant.getType()) {
            case SNP:
                type = VariantType.SNV;
                break;
            case MNP:
                type = VariantType.MNV;
                break;
            case SV:
                type = VariantBuilder.inferType(variant.getReference(), variant.getAlternate());
                break;
            default:
                type = variant.getType();

        }
        return new AlternateCoordinate(variant.getChromosome(), variant.getStart(), variant.getEnd(),
                variant.getReference(), variant.getAlternate(), type);
    }
658267
public alluxio.grpc.CheckConsistencyPOptionsOrBuilder getOptionsOrBuilder() {
    return options_ == null ? alluxio.grpc.CheckConsistencyPOptions.getDefaultInstance() : options_;
  }
792077
@Nonnull
	public static <T> LTieByteConsumer<T> tieByteConsumerFrom(Consumer<LTieByteConsumerBuilder<T>> buildingFunction) {
		LTieByteConsumerBuilder builder = new LTieByteConsumerBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
166827
@Nonnull
	public static LongUnaryOperator longUnaryOperatorFrom(Consumer<LongUnaryOperatorBuilder> buildingFunction) {
		LongUnaryOperatorBuilder builder = new LongUnaryOperatorBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
677440
@Nonnull
	public static <T> LObjIntDblPredicate<T> objIntDblPredicateFrom(Consumer<LObjIntDblPredicateBuilder<T>> buildingFunction) {
		LObjIntDblPredicateBuilder builder = new LObjIntDblPredicateBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
122058
@ManyToOne(targetEntity = org.openprovenance.prov.sql.QualifiedName.class, cascade = {
        CascadeType.ALL
    })
    @JoinColumn(name = "ALTERNATE2")
    public org.openprovenance.prov.model.QualifiedName getAlternate2() {
        return alternate2;
    }
888315
public Datatype.Builder setHasToBuilderMethod(boolean hasToBuilderMethod) {
    this.hasToBuilderMethod = hasToBuilderMethod;
    _unsetProperties.remove(Property.HAS_TO_BUILDER_METHOD);
    return (Datatype.Builder) this;
  }
650513
@Nonnull
	public static LFltConsumer fltConsumerFrom(Consumer<LFltConsumerBuilder> buildingFunction) {
		LFltConsumerBuilder builder = new LFltConsumerBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
412108
@Nonnull
	public static LSrtIntPredicate srtIntPredicateFrom(Consumer<LSrtIntPredicateBuilder> buildingFunction) {
		LSrtIntPredicateBuilder builder = new LSrtIntPredicateBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
2559
@Nonnull
	public static <T> LObjFltConsumer<T> objFltConsumerFrom(Consumer<LObjFltConsumerBuilder<T>> buildingFunction) {
		LObjFltConsumerBuilder builder = new LObjFltConsumerBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
931946
@Nonnull
	public static LSrtIntConsumer srtIntConsumerFrom(Consumer<LSrtIntConsumerBuilder> buildingFunction) {
		LSrtIntConsumerBuilder builder = new LSrtIntConsumerBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
1277683
Optional<Builder> getBuilder() {
    Optional<TypeElement> builderTypeElement = Optional.empty();
    for (TypeElement containedClass : ElementFilter.typesIn(autoValueClass.getEnclosedElements())) {
      if (hasAnnotationMirror(containedClass, AUTO_VALUE_BUILDER_NAME)) {
        if (!CLASS_OR_INTERFACE.contains(containedClass.getKind())) {
          errorReporter.reportError(
              "@AutoValue.Builder can only apply to a class or an interface", containedClass);
        } else if (!containedClass.getModifiers().contains(Modifier.STATIC)) {
          errorReporter.reportError(
              "@AutoValue.Builder cannot be applied to a non-static class", containedClass);
        } else if (builderTypeElement.isPresent()) {
          errorReporter.reportError(
              autoValueClass + " already has a Builder: " + builderTypeElement.get(),
              containedClass);
        } else {
          builderTypeElement = Optional.of(containedClass);
        }
      }
    }

    if (builderTypeElement.isPresent()) {
      return builderFrom(builderTypeElement.get());
    } else {
      return Optional.empty();
    }
  }