Register this component's ID in its naming context.
354511
void registerInContext() {
		if (!ConfigurationProperties.getCheckDuplicateIds()) {
			return;
		}

		// Register Component if it has an ID name set
		if (getIdName() != null) {
			// Find parent context
			NamingContextable context = WebUtilities.getParentNamingContext(this);

			if (context == null) {
				// If this is the top context, then register itself
				if (WebUtilities.isActiveNamingContext(this)) {
					this.registerId(this);
				} else {
					LOG.warn("Component with id name [" + getIdName()
							+ "] is not in a naming context and cannot be verified for duplicate id.");
				}
				return;
			}
			// Assume context is AbstractWComponent
			((AbstractWComponent) context).registerId(this);
		}
	}
100838
function registerComponent(Vue, name, definition) {
        Vue._shards_vue_components_ = Vue._shards_vue_components_ || {};
        var loaded = Vue._shards_vue_components_[name];

        if (!loaded && definition && name) {
            Vue._shards_vue_components_[name] = true;
            Vue.component(name, definition);
        }

        return loaded
    }
1291624
@Override
    public void initialize(ExtensionContext context) {
        SubsystemRegistration registration = context.registerSubsystem(SUBSYSTEM_NAME, JGroupsModel.CURRENT.getVersion());

        registration.registerSubsystemModel(new JGroupsSubsystemResourceDefinition(context.isRuntimeOnlyRegistrationValid()));
        registration.registerXMLElementWriter(new JGroupsSubsystemXMLWriter());
    }
883894
def set_register(self, register, value):
        
        context = self.get_context()
        context[register] = value
        self.set_context(context)
886943
def register(self, id):
        
        assert isinstance(id, basestring)
        if id in self.used_:
            #FIXME
            errors.error("common: the configuration '$(id)' is in use")

        if id not in self.all_:
            self.all_.add(id)

            # Indicate that a new configuration has been added.
            return True
        else:
            return False
616488
public void init(ServletContext context) {
        if (profiles != null) {
            for (IDiagramProfile profile : profiles) {
                profile.init(context);
                _registry.put(profile.getName(),
                              profile);
            }
        }
    }
1044798
def _register_name(self, name):
        
        if name not in self._var_name_mappers:
            self._var_name_mappers[name] = VariableNamer(name)
881608
protected static void registerNs(String prefix, String url) {
        Environment.getInstance().registerNamespace(prefix, url);
    }
828908
public static void register(@NonNull String name, @NonNull Lexicon lexicon) {
      lexiconCache.put(name.toLowerCase(), lexicon);
   }
699975
@Override
	public synchronized void register(final String key, final WComponent ui) {
		if (isRegistered(key)) {
			throw new SystemException("Cannot re-register a component. Key = " + key);
		}

		registry.put(key, ui);
	}
328374
public synchronized void registerJmxIfRequired() {
        referenceCount++;
        if(isRegistered == false) {
            String domain = JmxUtils.getPackageName(this.getClass());
            this.jmxObjectName = JmxUtils.createObjectName(domain, this.name);
            JmxUtils.registerMbean(this, this.jmxObjectName);
            isRegistered = true;
        }
    }
310114
private void registerCoreTypes() {

        idType = new IdType();
        coreTypes.put(idType.getStructType().getName(), idType.getStructType());
    }
22536
protected void registerIfNamed(Class<?> from, Serializer<?> serializer)
	{
		if(from.isAnnotationPresent(Named.class))
		{
			Named named = from.getAnnotation(Named.class);
			QualifiedName key = new QualifiedName(named.namespace(), named.name());
			nameToSerializer.put(key, serializer);
			serializerToName.put(serializer, key);
		}
	}
37050
public static void register(Context context, int id) {
        register(context, context.getResources().getResourceName(id));
    }
962445
private void init() {
        if (placeholder == null) {
            IdentificationManager.getInstance().registerIdentification(this);
            Optional<Identification> identification = IdentificationManager.getInstance().getIdentification(this);
            if (!identification.isPresent()) {
                throw new IllegalStateException("Unable to obtain Identification");
            } else {
                placeholder = identification.get();
            }
        }
    }
530900
def register(self, name, *slots):
        
        # setdefault initializes the object even if it exists. This is more efficient
        if name not in self:
            self[name] = Signal()

        for slot in slots:
            self[name].connect(slot)
1155833
public static void register(Context context, String name) {
        final Resources res = context.getResources();
        int androidId = res.getIdentifier(name, "layout", "android");
        int appId = res.getIdentifier(name, "layout", context.getPackageName());
        if (androidId != 0 && appId != 0) {
            register(androidId, appId);
        } else {
            HoloEverywhere.warn("Failed to register layout remapping:\n" +
                    "  Android ID: 0x%8x\n" +
                    "  Application ID: 0x%8x",
                    androidId, appId);
        }
    }