A list of Lambda functions in this function definition version.

@param functions
A list of Lambda functions in this function definition version.
358625
public void setFunctions(java.util.Collection<Function> functions) {
        if (functions == null) {
            this.functions = null;
            return;
        }

        this.functions = new java.util.ArrayList<Function>(functions);
    }
176280
@SafeVarargs
    public static <T extends Model, R> Select select(TypeFunction<T, R>... functions) {
        return select(
                Arrays.stream(functions)
                        .map(AnimaUtils::getLambdaColumnName)
                        .collect(joining(", ")));
    }
1252602
public void setTypes(List<String> types) {

        if (types == null) {
            m_types = new ArrayList<String>();
        } else {
            m_types = types;
        }
    }
269633
public void addFunctions(final FunctionSet functions) {
    checkNotNull(functions);
    log.debug("Adding functions: {}", functions);

    Object target = functions.target();
    for (String name : functions.names()) {
      addCommand(null, target, name);
    }
  }
831950
public List<FunctionWrapper> compileFunctions(
      ImportStack importStack, Context context, Object object
  ) {
    Class<?> functionClass = object.getClass();
    Method[] methods = functionClass.getDeclaredMethods();
    List<FunctionDeclaration> declarations = new LinkedList<>();

    for (Method method : methods) {
      int modifiers = method.getModifiers();

      if (!Modifier.isPublic(modifiers)) {
        continue;
      }

      FunctionDeclaration declaration = createDeclaration(importStack, context, object, method);
      declarations.add(declaration);
    }

    return declarations.stream().map(FunctionWrapper::new).collect(Collectors.toList());
  }
153955
public <T extends Function> T addFunction(T function) {
		addItem(function, functions, "functions");
		return function;
	}
880072
public void setOperations(java.util.Collection<BatchWriteOperation> operations) {
        if (operations == null) {
            this.operations = null;
            return;
        }

        this.operations = new java.util.ArrayList<BatchWriteOperation>(operations);
    }
208943
public void setVersions(java.util.Collection<String> versions) {
        if (versions == null) {
            this.versions = null;
            return;
        }

        this.versions = new com.amazonaws.internal.SdkInternalList<String>(versions);
    }
1013685
public void setFunction(FunctionLibFunction function) {
	function.setFunctionLib(this);
	functions.put(function.getName(), function);
    }
183141
function functs(...f) {
    /**
     * execute all included functions
     * @param {...*} [args] - arguments passed to all included functions
     * @returns {*[]}
     */
    function functs(...args) {
        return functs.run(this, args);
    }

    if(Array.isArray(f[0])) {
        f = f[0];
    }
    
    functs._f = f.filter((f) => {
        return typeof f === 'function';
    });
    functs.add = add.bind(functs);
    functs.remove = remove.bind(functs);
    functs.run = run.bind(functs);
    return functs;
}
1359572
public static <T, F> Function<F, T> bind(final Function<F, T> function) {
        return new Function<F, T>() {
            @Override
            public T apply(F arg) {
                return function.apply(arg);
            }
        };
    }
733804
public void setEvents(java.util.Collection<String> events) {
        if (events == null) {
            this.events = null;
            return;
        }

        this.events = new java.util.ArrayList<String>(events);
    }
504778
public void setFunctions(java.util.Collection<FunctionConfiguration> functions) {
        if (functions == null) {
            this.functions = null;
            return;
        }

        this.functions = new java.util.ArrayList<FunctionConfiguration>(functions);
    }
195406
function functions(node) {
  if (!Node.Type.isFunction(node)) {
    return Node.Status.noChange(node);
  }

  for (let i = 0; i < FUNCTIONS.length; i++) {
    const nodeStatus = FUNCTIONS[i](node);
    if (nodeStatus.hasChanged()) {
      return nodeStatus;
    }
  }
  return Node.Status.noChange(node);
}
1322291
private static void copyFunctions(FunctionLib extFL, FunctionLib newFL) {
	Iterator<Entry<String, FunctionLibFunction>> it = extFL.getFunctions().entrySet().iterator();
	FunctionLibFunction flf;
	while (it.hasNext()) {
	    flf = it.next().getValue(); // TODO function must be duplicated because it gets a new FunctionLib assigned
	    newFL.setFunction(flf);
	}
    }
154263
public void setKeyTypes(java.util.Collection<String> keyTypes) {
        if (keyTypes == null) {
            this.keyTypes = null;
            return;
        }

        this.keyTypes = new java.util.ArrayList<String>(keyTypes);
    }
41761
public List<FunctionDescriptor> buildListing() {
        List<FunctionDescriptor> listing = new ArrayList<>();

        for (Map.Entry<String, Method> entry : m_functions.entrySet()) {
            FunctionDescriptor descriptor = new FunctionDescriptor(entry.getKey().toUpperCase());
            listing.add(descriptor);
        }

        Collections.sort(listing, new Comparator<FunctionDescriptor>() {
            @Override
            public int compare(FunctionDescriptor f1, FunctionDescriptor f2) {
                return f1.m_name.compareTo(f2.m_name);
            }
        });

        return listing;
    }