<p>
Registers a function by a name other than its default name.
</p>
181211
static
	public void putFunction(String name, Function function){
		FunctionRegistry.functions.put(Objects.requireNonNull(name), function);
	}
1033686
public HalCuriAugmenter register(String name, String href) {
    Link link = new Link(href).setName(name);
    return register(link);
  }
1108607
public void registerDataSource(String name, DataSource dataSource) {
        if (dataSource == null) {
            throw new NullPointerException("dataSource");
        }
        if (StringUtils.isBlank(name)) {
            throw new IllegalArgumentException("blank name");
        }
        if (name.equals("*")) {
            defaultDataSource = new DataSourceHolder(dataSource);
        } else {
            dataSources.putIfAbsent(name, new DataSourceHolder(dataSource));
        }
    }
559893
protected boolean isReserved( String name ) {
        if( functions.isFunctionName(name))
            return true;

        for (int i = 0; i < name.length(); i++) {
            if( !isLetter(name.charAt(i)) )
                return true;
        }
        return false;
    }
1262597
public void register(Collector m) {
    List<String> names = collectorNames(m);
    synchronized (collectorsToNames) {
      for (String name : names) {
        if (namesToCollectors.containsKey(name)) {
          throw new IllegalArgumentException("Collector already registered that provides name: " + name);
        }
      }
      for (String name : names) {
        namesToCollectors.put(name, m);
      }
      collectorsToNames.put(m, names);
    }
  }
384828
private void registerInternal(final Object receiver, final Method method, final Class<? extends T> eventClass) {

		List<ReceiverDescriptor> receivers = this.receiverMap.get(eventClass);
		if (receivers == null) {
			receivers = new LinkedList<ReceiverDescriptor>();
			this.receiverMap.put(eventClass, receivers);
		}

		final ReceiverDescriptor rd = new ReceiverDescriptor();
		rd.receiverReference = new SoftReference<Object>(receiver);
		rd.method = method;

		receivers.add(rd);
	}
1341318
protected ExecutableMethod<Object, Object> resolveFunction(LocalFunctionRegistry localFunctionRegistry, String functionName) {
        Optional<? extends ExecutableMethod<Object, Object>> registeredMethod;
        if (functionName == null) {
            registeredMethod = localFunctionRegistry.findFirst();
        } else {
            registeredMethod = localFunctionRegistry.find(functionName);
        }
        return registeredMethod
            .orElseThrow(() -> new IllegalStateException("No function found for name: " + functionName));
    }
35353
public Method createFunction(String ns, String name)
    {
        return containsNamespace(ns) ? _functions.get(name) : null;
    }
532178
static
	public void putFunction(String name, Class<? extends Function> functionClazz){
		FunctionRegistry.functionClazzes.put(Objects.requireNonNull(name), checkClass(functionClazz));
	}
1265535
public <T extends ContextAwareMetric> T register(T metric) throws IllegalArgumentException {
    return register(metric.getName(), metric);
  }
1164338
def register(self, function):
        
        function = inspect.isclass(function) and function() or function
        name = function.name
        self[name] = function
1183507
private void addPossibleSignature(String name, Node node, NodeTraversal t) {
    if (node.isFunction()) {
      // The node we're looking at is a function, so we can add it directly
      addSignature(name, node, t.getSourceName());
    } else {
      nonMethodProperties.add(name);
    }
  }
616271
@NonNull
  public static CreateFunctionStart createFunction(
      @Nullable CqlIdentifier keyspace, @NonNull CqlIdentifier functionName) {
    return new DefaultCreateFunction(keyspace, functionName);
  }
107105
public static void register(final Map<String, Taglet> tagletMap) {
        ManualTaglet t = new ManualTaglet();
        tagletMap.put(t.getName(), t);
    }
315486
def register(self, func, singleton=False, threadlocal=False, name=None):
        
        func._giveme_singleton = singleton
        func._giveme_threadlocal = threadlocal

        if name is None:
            name = func.__name__
        self._registered[name] = func
        return func
689316
def _register_handler(event, fun, external=False):
    """"""
    registry = core.HANDLER_REGISTRY
    if external:
        registry = core.EXTERNAL_HANDLER_REGISTRY

    if not isinstance(event, basestring):
        # If not basestring, it is a BaseEvent subclass.
        # This occurs when class methods are registered as handlers
        event = core.parse_event_to_name(event)

    if event in registry:
        registry[event].append(fun)
    else:
        registry[event] = [fun]
    return fun
388603
def register(self, f, *args, **kwargs):
        
        self._functions.append(lambda: f(*args, **kwargs))