`.
*
* When the {@link #resultType} of a function is a generic type param, the type param name also
* appears as the `type` of on at least one params.
*/
public abstract ImmutableList parameterTypes();
/** The type param names associated with the function declaration. */
public abstract ImmutableSet typeParameterNames();
/**
* Required. The result type of the function. For example, the operator `string.isEmpty()` would
* have `result_type` of `CelKind.BOOL`.
*/
public abstract CelType resultType();
/**
* Denotes whether the function is declared in a global function `Ex: f(x, ...)` or a method call
* style `Ex: x.f(...)`.
*/
public abstract boolean isInstanceFunction();
/** Documentation string for the overload. */
public abstract String doc();
public abstract Builder toBuilder();
/** Create a new builder to construct a {@link CelOverloadDecl} instance */
public static Builder newBuilder() {
return new AutoValue_CelOverloadDecl.Builder().setDoc("");
}
/** Builder for configuring the {@link CelOverloadDecl}. */
@AutoValue.Builder
public abstract static class Builder {
/** Sets the value for {@link #overloadId()} */
public abstract Builder setOverloadId(String overloadId);
/**
* Sets the parameter types {@link #parameterTypes()}. Note that this will override any
* parameter types added via the accumulator methods {@link #addParameterTypes}.
*/
public abstract Builder setParameterTypes(ImmutableList value);
public abstract CelType resultType();
/** Sets the result type {@link #resultType()} */
public abstract Builder setResultType(CelType value);
/**
* Sets the function declaration style {@link #isInstanceFunction()}. False for global function
* style, true for member call style
*/
public abstract Builder setIsInstanceFunction(boolean value);
/** Sets the documentation for the overload */
public abstract Builder setDoc(String value);
public abstract boolean isInstanceFunction();
public abstract ImmutableList parameterTypes();
/**
* Not public. This is collected in {@link #build()} by visiting all the parameter types and the
* expected result type.
*/
abstract Builder setTypeParameterNames(ImmutableSet value);
abstract ImmutableList.Builder parameterTypesBuilder();
/** Accumulates parameter types into {@link #parameterTypesBuilder()} */
@CanIgnoreReturnValue
public final Builder addParameterTypes(Iterable parameterTypes) {
checkNotNull(parameterTypes);
parameterTypesBuilder().addAll(parameterTypes);
return this;
}
/** Accumulates parameter types into {@link #parameterTypesBuilder()} */
@CanIgnoreReturnValue
public Builder addParameterTypes(CelType... parameterTypes) {
checkNotNull(parameterTypes);
parameterTypesBuilder().add(parameterTypes);
return this;
}
@CheckReturnValue
abstract CelOverloadDecl autoBuild();
/** Build a new instance of the {@link CelOverloadDecl} */
@CheckReturnValue
public CelOverloadDecl build() {
ImmutableSet.Builder typeParamNameBuilder = new ImmutableSet.Builder<>();
for (CelType type : parameterTypes()) {
collectParamNames(typeParamNameBuilder, type);
}
collectParamNames(typeParamNameBuilder, resultType());
setTypeParameterNames(typeParamNameBuilder.build());
return autoBuild();
}
}
/** Helper method for declaring a member function overload */
@CheckReturnValue
public static CelOverloadDecl newMemberOverload(
String overloadId, CelType resultType, CelType... paramTypes) {
return newMemberOverload(overloadId, resultType, Arrays.asList(paramTypes));
}
/** Helper method for declaring a member function overload */
@CheckReturnValue
public static CelOverloadDecl newMemberOverload(
String overloadId, CelType resultType, List paramTypes) {
return newMemberOverload(overloadId, /* doc= */ "", resultType, paramTypes);
}
/** Helper method for declaring a member function overload */
@CheckReturnValue
public static CelOverloadDecl newMemberOverload(
String overloadId, String doc, CelType resultType, CelType... paramTypes) {
return newMemberOverload(overloadId, doc, resultType, Arrays.asList(paramTypes));
}
/** Helper method for declaring a member function overload */
@CheckReturnValue
public static CelOverloadDecl newMemberOverload(
String overloadId, String doc, CelType resultType, List paramTypes) {
return newOverload(overloadId, doc, resultType, paramTypes, /* isInstanceFunction= */ true);
}
/** Helper method for declaring a global function overload */
@CheckReturnValue
public static CelOverloadDecl newGlobalOverload(
String overloadId, CelType resultType, CelType... paramTypes) {
return newGlobalOverload(overloadId, resultType, Arrays.asList(paramTypes));
}
/** Helper method for declaring a global function overload */
@CheckReturnValue
public static CelOverloadDecl newGlobalOverload(
String overloadId, CelType resultType, List paramTypes) {
return newGlobalOverload(overloadId, /* doc= */ "", resultType, paramTypes);
}
/** Helper method for declaring a global function overload */
@CheckReturnValue
public static CelOverloadDecl newGlobalOverload(
String overloadId, String doc, CelType resultType, CelType... paramTypes) {
return newGlobalOverload(overloadId, doc, resultType, Arrays.asList(paramTypes));
}
/** Helper method for declaring a global function overload */
@CheckReturnValue
public static CelOverloadDecl newGlobalOverload(
String overloadId, String doc, CelType resultType, List paramTypes) {
return newOverload(overloadId, doc, resultType, paramTypes, /* isInstanceFunction= */ false);
}
private static CelOverloadDecl newOverload(
String overloadId,
String doc,
CelType resultType,
List paramTypes,
boolean isInstanceFunction) {
return CelOverloadDecl.newBuilder()
.setOverloadId(overloadId)
.setIsInstanceFunction(isInstanceFunction)
.setResultType(resultType)
.addParameterTypes(paramTypes)
.setDoc(doc)
.build();
}
/** Converts a {@link CelOverloadDecl} to a protobuf equivalent form {@link Overload} */
public static Overload celOverloadToOverload(CelOverloadDecl overload) {
return Overload.newBuilder()
.setIsInstanceFunction(overload.isInstanceFunction())
.setOverloadId(overload.overloadId())
.setResultType(CelTypes.celTypeToType(overload.resultType()))
.addAllParams(
overload.parameterTypes().stream()
.map(CelTypes::celTypeToType)
.collect(toImmutableList()))
.addAllTypeParams(overload.typeParameterNames())
.setDoc(overload.doc())
.build();
}
public static CelOverloadDecl overloadToCelOverload(Overload overload) {
return CelOverloadDecl.newBuilder()
.setIsInstanceFunction(overload.getIsInstanceFunction())
.setOverloadId(overload.getOverloadId())
.setResultType(CelTypes.typeToCelType(overload.getResultType()))
.setDoc(overload.getDoc())
.addParameterTypes(
overload.getParamsList().stream()
.map(CelTypes::typeToCelType)
.collect(toImmutableList()))
.build();
}
private static void collectParamNames(ImmutableSet.Builder typeParamNames, CelType type) {
if (type.kind().equals(CelKind.TYPE_PARAM)) {
typeParamNames.add(type.name());
}
for (CelType param : type.parameters()) {
collectParamNames(typeParamNames, param);
}
}
}
