Register all standard PEPPOL validation execution sets to the provided
registry.

@param aRegistry
The registry to add the artefacts. May not be <code>null</code>.
546206
@SuppressWarnings ("deprecation")
  public static void initStandard (@Nonnull final ValidationExecutorSetRegistry aRegistry)
  {
    // For better error messages
    LocationBeautifierSPI.addMappings (UBL21NamespaceContext.getInstance ());

    PeppolValidation350.init (aRegistry);
    PeppolValidation360.init (aRegistry);
    PeppolValidation370.init (aRegistry);
  }
356091
protected void registerMultifactorFlowDefinitionIntoLoginFlowRegistry(final FlowDefinitionRegistry sourceRegistry) {
        val flowIds = sourceRegistry.getFlowDefinitionIds();
        for (val flowId : flowIds) {
            val definition = sourceRegistry.getFlowDefinition(flowId);
            if (definition != null) {
                LOGGER.trace("Registering flow definition [{}]", flowId);
                this.loginFlowDefinitionRegistry.registerFlowDefinition(definition);
            }
        }
    }
361305
def register(linter):
    '''
    
    '''
    linter.register_checker(ResourceLeakageChecker(linter))
    linter.register_checker(BlacklistedImportsChecker(linter))
    linter.register_checker(MovedTestCaseClassChecker(linter))
    linter.register_checker(BlacklistedLoaderModulesUsageChecker(linter))
    linter.register_checker(BlacklistedFunctionsChecker(linter))
1137915
@Autowired
    public void setRegistry(BridgeHeadTypeRegistry registry) {
        this.registry = registry;
        registry.register(this);
        Method[] methods = offerArray(Object.class.getMethods(), nearType.getMethods());
        for (Method method : methods) {
            if (logger.isTraceEnabled()) {
                logger.trace("Method: " + display(method) + ": in: " + display(nearType));
            }
            Binding binding = getBinding(method.getReturnType(), method.getName(), method.getParameterTypes());
            if (binding == null) {
                String message = "No binding found: " + display(nearType) + ": " + display(method);
                logger.warn(message);
                throw new UnsupportedOperationException(message);
            }
            if (logger.isTraceEnabled()) {
                logger.trace("Binding: " + display(binding));
            }
            methodMap.put(method, binding);
        }
    }
494896
public static void initializeDomainRegistry(final TransformerRegistry registry) {

        //The chains for transforming will be as follows
        //For JBoss EAP: 8.0.0 -> 5.0.0 -> 4.0.0 -> 1.8.0 -> 1.7.0 -> 1.6.0 -> 1.5.0

        registerRootTransformers(registry);
        registerChainedManagementTransformers(registry);
        registerChainedServerGroupTransformers(registry);
        registerProfileTransformers(registry);
        registerSocketBindingGroupTransformers(registry);
        registerDeploymentTransformers(registry);
    }
359542
public void setRegisters(InputRegister[] registers) {
        byteCount = registers.length * 2;
        setDataLength(byteCount + 1);

        this.registers = Arrays.copyOf(registers, registers.length);
    }
468918
private static void loadRegistry() {
		// Load audit filters to runtime configurations.
		for (AuditEventFilter filter : PreConfigurationContext.getPrefilters()) {
			configContext.addFilter(filter);
		}
		// Load audit annotation filters to runtime configurations.
		for (AuditAnnotationFilter annotationFilter : PreConfigurationContext.getPreannotationfilters()) {
			configContext.addAnnotationFilter(annotationFilter);
		}
	}
43387
private void registerOperations() {
    Class<?> type = getClass();
    for (Method method : type.getMethods()) {
      if (isOperationMethod(method)) {
        registerMethod(method);
      }
    }
  }
623941
public void setRegisters(Register[] registers) {
        writeCount = registers != null ? registers.length : 0;
        this.registers = registers != null ? Arrays.copyOf(registers, registers.length) : null;
    }
1266767
public static void addApplicationFormatters(FormatterRegistry registry) {
		registry.addFormatter(new CharArrayFormatter());
		registry.addFormatter(new InetAddressFormatter());
		registry.addFormatter(new IsoOffsetFormatter());
	}
1270359
public static void register() {
        try {
            Class<? extends List<Object>> listObjectClass;
            listObjectClass = (Class<List<Object>>) NumberedListConverter.class
                                .getMethod("getString", List.class).getParameterTypes()[0];
            NumberedListConverter converter = new NumberedListConverter();
            ConverterRegistry.addConverter(listObjectClass, converter);
            ConverterRegistry.addConverter(ArrayList.class, new NumberedArrayListConverter(converter));
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
274798
@Nonnull
  public void setRegistry (@Nonnull final IAjaxRegistry aRegistry)
  {
    ValueEnforcer.notNull (aRegistry, "Registry");
    if (m_aRWLock.readLocked ( () -> m_aRegistry.getAllRegisteredFunctions ().isNotEmpty ()))
      throw new IllegalStateException ("Cannot change the registry after a function was already registered!");

    m_aRWLock.writeLocked ( () -> m_aRegistry = aRegistry);
  }
1232081
protected void registerServant()
    {
        if (ivRemoteObjectWrapper != null)
        {
            // synchronized on the remote Wrapper to set the isRemoteRegistered flag
            synchronized (ivRemoteObjectWrapper)
            {
                if (!isRemoteRegistered)
                {

                    try
                    {
                        if (!isZOS) // LIDB2775-23.9
                        {

                            // Servant registration must be performed with the application classloader
                            // in force.  This is especially needed for JITDeploy since
                            // the JIT pluggin will be on the application classloader.
                            // Without the JIT pluggin the classloader will not trigger
                            // JITDeploy to create the stub.  //d521388
                            Object originalLoader = ThreadContextAccessor.UNCHANGED;
                            try
                            {
                                if (ivBMD != null) // EJBFactories have no BMD d529446
                                {
                                    originalLoader = EJBThreadData.svThreadContextAccessor.pushContextClassLoaderForUnprivileged(ivBMD.classLoader); //PK83186

                                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                                    {
                                        if (originalLoader != ThreadContextAccessor.UNCHANGED)
                                        {
                                            Tr.debug(tc, "registerServant : old ClassLoader = " + originalLoader);
                                            Tr.debug(tc, "registerServant : new ClassLoader = " + ivBMD.classLoader);
                                        }
                                        else
                                        {
                                            Tr.debug(tc, "registerServant : current ClassLoader = " + ivBMD.classLoader);
                                        }
                                    }
                                }
                                ivRemoteObjectWrapper.container.getEJBRuntime().registerServant(ivRemoteObjectWrapper.beanId.getByteArray(), ivRemoteObjectWrapper);
                            } finally
                            {
                                EJBThreadData.svThreadContextAccessor.popContextClassLoaderForUnprivileged(originalLoader);
                            } // finally

                        } // if( !isZOS )

                        isRemoteRegistered = true;
                    } catch (Exception ex)
                    {
                        FFDCFilter.processException(ex, CLASS_NAME +
                                                        ".registerServant",
                                                    "184", this);
                        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                        {
                            Tr.event(tc, "Failed to register wrapper instance",
                                     new Object[] { ivRemoteObjectWrapper, ex });
                        }
                    }

                } // if ( !isRemoteRegistered )

            } // synchronized( ivRemoteObject )

        } // if ( ivRemoteObject != null )

    }
828940
protected void registerWampEndpoints(WampEndpointRegistry registry) {
		if (this.configurers.isEmpty()) {
			registry.addEndpoint("/wamp");
		}
		else {
			for (WampConfigurer wc : this.configurers) {
				wc.registerWampEndpoints(registry);
			}
		}
	}
1047962
public synchronized void registerSessionManager(Object key, IGenericSessionManager sessionMgr) {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.entering(methodClassName, methodNames[REGISTER_SESSION_MANAGER], "registryKey= " + key + " sessionMgr:" + sessionMgr);
        }
        _genericSessionManagers.put(key, sessionMgr);
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[REGISTER_SESSION_MANAGER]);
        }
    }
1232585
public void registerProviders(Collection<?> theProviders) {
		Validate.noNullElements(theProviders, "theProviders must not contain any null elements");

		myProviderRegistrationMutex.lock();
		try {
			if (!myStarted) {
				for (Object provider : theProviders) {
					ourLog.info("Registration of provider [" + provider.getClass().getName() + "] will be delayed until FHIR server startup");
					if (provider instanceof IResourceProvider) {
						myResourceProviders.add((IResourceProvider) provider);
					} else {
						myPlainProviders.add(provider);
					}
				}
				return;
			}
		} finally {
			myProviderRegistrationMutex.unlock();
		}
		registerProviders(theProviders, false);
	}
5127
def register(cls):
    
    registry_entry = RegistryEntry(category = cls.category, namespace = cls.namespace, name = cls.name, cls=cls)
    if registry_entry not in registry and not exists_in_registry(cls.category, cls.namespace, cls.name):
        registry.append(registry_entry)
    else:
        log.warn("Class {0} already in registry".format(cls))