-----------------------------------------------------------------------------
 Type registration
435751
def register(type, plural = nil)
    type = type.to_sym

    if plural
      plural = plural.to_sym
    else
      plural = "#{type}s".to_sym
    end
    @plurals[plural] = type
    @types[type]     = Config.new
  end
196161
protected final <U extends GenericEvent> void bind(
      EventBus eventBus,
      List<HandlerRegistration> registrations,
      Class<U> type,
      GenericEventHandler handler) {
    registrations.add(eventBus.addHandler(GenericEventType.getTypeOf(type), handler));
  }
651238
public final <T> void registerType(Class<T> runtimeClass, TypeHandler<T> handler) {
        if (started) {
            // Can't add any more metrics anyway; harmless
            return;
        }
        typeHandlers.put(runtimeClass, handler);
    }
142175
public void register(String table, String column, Type<?> type) {
        javaTypeMapping.setType(table, column, type);
        hasTableColumnTypes = true;
    }
744978
public void register(CacheEntryListenerConfiguration<K, V> configuration) {
    if (configuration.getCacheEntryListenerFactory() == null) {
      return;
    }
    EventTypeAwareListener<K, V> listener = new EventTypeAwareListener<>(
        configuration.getCacheEntryListenerFactory().create());

    CacheEntryEventFilter<K, V> filter = event -> true;
    if (configuration.getCacheEntryEventFilterFactory() != null) {
      filter = new EventTypeFilter<>(listener,
          configuration.getCacheEntryEventFilterFactory().create());
    }

    Registration<K, V> registration = new Registration<>(configuration, filter, listener);
    dispatchQueues.putIfAbsent(registration, CompletableFuture.completedFuture(null));
  }
501763
public void registerCard(String type, Class<? extends Card> cardClz) {
        mDefaultCardResolver.register(type, cardClz);
    }
148842
public void registerView(final ServiceValidationViewTypes type, final Pair<View, View> view) {
        registerView(type.getType(), view);
    }
179986
public void register(EventDefinition eventDefinition, IEventListener listener) {
        if (eventDefinition.getType() == EventDefinition.TYPE_POST) {
            register(listenersPost, eventDefinition, listener, true);
        } else {
            register(listeners, eventDefinition, listener, false);
        }
    }
1282409
function register(metamodel) {
        var name, metaType;

        // Registering MetaTypes to global.meta
        for (name in metamodel) {
            if (metamodel.hasOwnProperty(name)) {
                metaType = metamodel[name];
                metaType.name = name;

                // Check duplicated MetaType
                if (_global.meta[name]) {
                    delete metamodel[name];
                    console.error("[MetaModelManager] MetaType '" + name + "' is already exists.");
                } else {
                    _global.meta[name] = metaType;
                }
            }
        }

        // Validate MetaTypes
        for (name in metamodel) {
            if (metamodel.hasOwnProperty(name)) {
                metaType = metamodel[name];
                try {
                    validateMetaType(name, metaType);
                } catch (err) {
                    console.error(err);
                }
            }
        }
    }
246460
public void register(T instance) {
		if(!isContained(instance)) {
			registry.add(instance);
			if(current == null) {
				current = instance;
			}
		}
	}
585138
public static void register(String typeName, Class<? extends PropertyEditorBase<?>> editorClass) {
        register(typeName, null, editorClass);
    }
1186207
public <T> JsonBuilder registerTypeAdapter(Class<T> clazz, TypeAdapter<T> typeAdapter) {
        typeAdapters.registerTypeAdapter(clazz, typeAdapter);
        return this;
    }
848625
protected function _registerFromConfigure()
    {
        $configure = Configure::read('PostTypes.Register');

        if (!is_array($configure)) {
            $configure = [];
        }

        foreach ($configure as $key => $item) {
            $this->register($key, $item);
        }
    }
826926
def register_as_type(self, locator, object_factory):
        
        if locator == None:
            raise Exception("Locator cannot be null")
        if object_factory == None:
            raise Exception("Factory cannot be null")

        def factory(locator):
            return object_factory()

        self._registrations.append(Registration(locator, factory))
432239
def register(self, provider):
        ''''''
        if isinstance(provider,type):
            provider = provider()
        self[provider.code] = provider
510130
private static Class registerTypeMapping(WSServer server, Class clazz) {
	java.lang.reflect.Method[] methods = clazz.getMethods();
	java.lang.reflect.Method method;
	Class[] params;
	for (int i = 0; i < methods.length; i++) {
	    method = methods[i];
	    if (method.getDeclaringClass() == clazz) {
		_registerTypeMapping(server, method.getReturnType());
		params = method.getParameterTypes();
		for (int y = 0; y < params.length; y++) {
		    _registerTypeMapping(server, params[y]);
		}
	    }
	}
	return clazz;
    }
1057323
protected void registerEditorsWithSubClasses(PropertyEditor editor, Class<? extends BioPAXElement> domain) {

        for (Class<? extends BioPAXElement> c : classToEditorMap.keySet())
        {
            if (domain.isAssignableFrom(c)) {
                //workaround for participants - can be replaced w/ a general
                // annotation based system. For the time being, I am just handling it
                //as a special case
                if ((editor.getProperty().equals("PARTICIPANTS") &&
                        (conversion.class.isAssignableFrom(c) || control.class.isAssignableFrom(c))) ||
                        (editor.getProperty().equals("participant") &&
                                (Conversion.class.isAssignableFrom(c) || Control.class.isAssignableFrom(c)))) {
                    if (log.isDebugEnabled()) {
                        log.debug("skipping restricted participant property");
                    }
                } else {
                    classToEditorMap.get(c).put(editor.getProperty(), editor);
                }
            }

        }

        if (editor instanceof ObjectPropertyEditor) {
            registerInverseEditors((ObjectPropertyEditor) editor);
        }
    }