Try to find function in library by name.

@param functionName function name.
@return the function instance.
@throws NoSuchFunctionException
544167
public Function getFunction(String functionName) throws NoSuchFunctionException {
        if (!members.containsKey(functionName)) {
            throw new NoSuchFunctionException("Can not find function " + functionName + " in library " + name + " (" + prefix + ")");
        }

        return members.get(functionName);
    }
478108
public static Method findMethod(String name, Class<?> cls) {
    
    for(Method method : cls.getDeclaredMethods()) {
      if(method.getName().equals(name)) {
        return method;
      }
    }
    
    throw new ExecutionException("invalid auto-function: no '" + name + "' method declared", null);
  }
35353
public Method createFunction(String ns, String name)
    {
        return containsNamespace(ns) ? _functions.get(name) : null;
    }
791798
function getFunctionName (fn) {
  var name = fn.toString();
  name = name.substr('function '.length);
  name = name.substr(0, name.indexOf('('));
  return name;
}
914244
public boolean knowsFunction(String functionName) {
        String functionPrefix = functionName.substring(0, functionName.indexOf(':') + 1);

        if (!functionPrefix.equals(prefix)) {
            return false;
        }

        return members.containsKey(functionName.substring(functionName.indexOf(':') + 1, functionName.indexOf('(')));
    }
31722
public boolean containsFunction(String ns, String name)
    {
        for (int i = 0; i < this.libraries.length; i++)
        {
            if (this.libraries[i].containsFunction(ns, name))
            {
                return true;
            }
        }
        return false;
    }
111914
public Method findMethod (String methodName, Object[] args)
        throws NoSuchMethodException
    {
        return findMethod(methodName, ClassUtil.getParameterTypesFrom(args));
    }
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);
            }
        };
    }
158223
@NonNull
  public static CreateFunctionStart createFunction(
      @Nullable String keyspace, @NonNull String functionName) {
    return new DefaultCreateFunction(
        keyspace == null ? null : CqlIdentifier.fromCql(keyspace),
        CqlIdentifier.fromCql(functionName));
  }
1067771
public Method resolveFunction(String prefix, String localName) {
        FunctionMapperSpi functionMapperSpi = findFunctionMapperSpi(prefix);
        return functionMapperSpi.resolveFunction(localName);
    }
542186
protected Method findMethod(Object obj,int functionId)
	{
		Method method=null;
		if(callTarget!=null)
		{
			Method[] methods=callTarget.getClass().getDeclaredMethods();
			for(Method m:methods)
			{
				CallBackFunction function=m.getAnnotation(CallBackFunction.class);
				if(function!=null && function.id()==functionId)
				{
					method=m;
					break;
				}
			}
		}
		return method;
	}
1108322
public SystemInputDef removeFunctionInputDef( String name)
    {
    int i = findFunctionInputDef( name);
    if( i >= 0)
      {
      functionInputDefs_.remove(i);
      }

    return this;
    }
749862
function assertFn(fn: any, name: string) {
  return fn ? assert(_.isFunction(fn), `${name} must be a function`) : false;
}
964131
public void setFunctionName(String functionName) {

		String oldFunctionName = functionName;
		this.functionName = functionName;
		firePropertyChange("FunctionName", oldFunctionName, functionName);
	}
1223978
public static Method getFunction(String functionName) {
    Method method = FUNCTION_MAP.get(functionName);
    if (method != null) {
      return method;
    }
    String nameLower = functionName.toLowerCase(Locale.US);
    if (nameLower == functionName) {
      // Input name was in lower case, the function is not there
      return null;
    }
    method = FUNCTION_MAP.get(nameLower);
    if (method != null && FUNCTION_MAP.size() < 1000) {
      // Avoid OutOfMemoryError in case input function names are randomized
      // The number of methods is finite, however the number of upper-lower case combinations
      // is quite a few (e.g. substr, Substr, sUbstr, SUbstr, etc).
      FUNCTION_MAP.putIfAbsent(functionName, method);
    }
    return method;
  }
389490
public Object invokeFunction(String name, Object... args)
    throws ScriptException, NoSuchMethodException {
        return invoke(null, name, args);
    }
156761
@Override
  public OperationHandle getFunctions(SessionHandle sessionHandle,
      String catalogName, String schemaName, String functionName)
          throws HiveSQLException {
    return cliService.getFunctions(sessionHandle, catalogName, schemaName, functionName);
  }