<p>
A list of <code>Function</code> objects.
</p>

@param functions
A list of <code>Function</code> objects.
504778
public void setFunctions(java.util.Collection<FunctionConfiguration> functions) {
        if (functions == null) {
            this.functions = null;
            return;
        }

        this.functions = new java.util.ArrayList<FunctionConfiguration>(functions);
    }
369509
public static void add(Map<String, Class<? extends ICustomFunction>> moreCustomFunctions) {
        fs.putAll(moreCustomFunctions);
        poifs = loadPoiCustomFunctions(fs);
    }
18902
@Override
    public void init(DifferentiableBatchFunction function) {
        gradSumSquares = new double[function.getNumDimensions()];
        Arrays.fill(gradSumSquares, prm.initialSumSquares);
    }
923933
@Override
	protected List<OUT> executeOnCollections(List<IN> inputData, RuntimeContext ctx, ExecutionConfig executionConfig) throws Exception {
		MapFunction<IN, OUT> function = this.userFunction.getUserCodeObject();
		
		FunctionUtils.setFunctionRuntimeContext(function, ctx);
		FunctionUtils.openFunction(function, this.parameters);
		
		ArrayList<OUT> result = new ArrayList<OUT>(inputData.size());

		TypeSerializer<IN> inSerializer = getOperatorInfo().getInputType().createSerializer(executionConfig);
		TypeSerializer<OUT> outSerializer = getOperatorInfo().getOutputType().createSerializer(executionConfig);

		for (IN element : inputData) {
			IN inCopy = inSerializer.copy(element);
			OUT out = function.map(inCopy);
			result.add(outSerializer.copy(out));
		}

		FunctionUtils.closeFunction(function);
		
		return result;
	}
531189
public static Builder newBuilder(String query, List<UserDefinedFunction> functions) {
    return newBuilder(query).setUserDefinedFunctions(functions);
  }
1318499
public void sync(List<Dml> dmls, Function<Dml, Boolean> function) {
        try {
            boolean toExecute = false;
            for (Dml dml : dmls) {
                if (!toExecute) {
                    toExecute = function.apply(dml);
                } else {
                    function.apply(dml);
                }
            }
            if (toExecute) {
                List<Future<Boolean>> futures = new ArrayList<>();
                for (int i = 0; i < threads; i++) {
                    int j = i;
                    futures.add(executorThreads[i].submit(() -> {
                        try {
                            dmlsPartition[j].forEach(syncItem -> sync(batchExecutors[j],
                                syncItem.config,
                                syncItem.singleDml));
                            dmlsPartition[j].clear();
                            batchExecutors[j].commit();
                            return true;
                        } catch (Throwable e) {
                            batchExecutors[j].rollback();
                            throw new RuntimeException(e);
                        }
                    }));
                }

                futures.forEach(future -> {
                    try {
                        future.get();
                    } catch (ExecutionException | InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                });
            }
        } finally {
            for (BatchExecutor batchExecutor : batchExecutors) {
                if (batchExecutor != null) {
                    batchExecutor.close();
                }
            }
        }
    }
988551
function bindFunctions(functions) {
	var _this = this;

	functions.forEach(function (f) {
		return _this[f] = _this[f].bind(_this);
	});
}
450618
public void setFunction(String prefix, String localName, Method method) {
		if (functions == null) {
			functions = new Functions();
		}
		functions.setFunction(prefix, localName, method);
	}
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);
	}
    }
65051
private Set<String> findCalledFunctions(Node node) {
    Set<String> changed = new HashSet<>();
    findCalledFunctions(NodeUtil.getFunctionBody(node), changed);
    return changed;
  }
1013685
public void setFunction(FunctionLibFunction function) {
	function.setFunctionLib(this);
	functions.put(function.getName(), function);
    }
185570
public <R> AnimaQuery<T> exclude(TypeFunction<T, R>... functions) {
        String[] columnNames = Arrays.stream(functions)
                .map(AnimaUtils::getLambdaColumnName)
                .collect(toList())
                .toArray(new String[functions.length]);
        return this.exclude(columnNames);
    }
503591
public void setEvents(java.util.Collection<Event> events) {
        if (events == null) {
            this.events = null;
            return;
        }

        this.events = new java.util.ArrayList<Event>(events);
    }
1284584
public Set<String> availableFunctions() {
        Set<String> functions = new HashSet<String>(this.getObjects().keySet());
        Iterator<String> it = functions.iterator();
        while (it.hasNext()) {
            String key = it.next();
            if (!getObject(key).isFunction()) {
                it.remove();
            }
        }
        return functions;
    }
1168847
public void addObjects(List[] objects)
  {
    if (tc.isEntryEnabled())
      tc.entry(this,cclass, "addObjects", "objects: " + objects);

    if (delegate != null)
      delegate.addObjects(objects);

    if (tc.isEntryEnabled())
      tc.exit(this,cclass, "addObjects");
  }
295983
public SystemInputDefBuilder functions( Stream<FunctionInputDef> functions)
    {
    functions.forEach( function -> systemInputDef_.addFunctionInputDef( function));
    return this;
    }
530002
@Override
	public void createFunction(ObjectPath functionPath, CatalogFunction function, boolean ignoreIfExists)
			throws FunctionAlreadyExistException, DatabaseNotExistException, CatalogException {
		throw new UnsupportedOperationException();
	}