Registers the {@link ConstraintProcessor}s.
542255
private void registerProcessors() {

    ConstraintProcessorMandatory mandatory = new ConstraintProcessorMandatory();
    registerProcessor("org.hibernate.validator.constraints.NotEmpty", mandatory);
    registerProcessor(NotNull.class, mandatory);
    registerProcessor(Mandatory.class, mandatory);
  }
278526
public void addConstraint( final FieldConstraint constraint ) {
        if ( this.constraints == null ) {
            this.constraints = new FieldConstraint[ 1 ];
            this.constraints[ 0 ] = constraint;
        } else {
            final FieldConstraint[] newList = new FieldConstraint[ this.constraints.length + 1 ];
            for ( int i = 0; i < this.constraints.length; i++ ) {
                newList[ i ] = this.constraints[ i ];
            }
            newList[ this.constraints.length ] = constraint;
            this.constraints = newList;
        }
    }
1300940
public void register(ConstraintConverter<? extends Constraint> c) {
        java2json.put(c.getSupportedConstraint(), c);
        json2java.put(c.getJSONId(), c);

    }
911245
private Set<ConstraintViolation<Object>> addViolations(
            Set<ConstraintViolation<Object>> source,
            Set<ConstraintViolation<Object>> target) {
        if (supportsConstraintComposition) {
            target.addAll(source);
            return target;
        }

        for (final Iterator<ConstraintViolation<Object>> iter = source
                .iterator(); iter.hasNext(); ) {
            final ConstraintViolation<Object> violation = iter.next();
            final Iterator<Node> nodeIter = violation.getPropertyPath()
                    .iterator();

			/*
			 * Only include violations that have no property path or just one
			 * node
			 */
            if (!nodeIter.hasNext()
                    || (nodeIter.next() != null && !nodeIter.hasNext())) {
                target.add(violation);
            }
        }

        return target;
    }
1192348
private void initJdkBindings() {
        
        registerBinding(AtomicBoolean.class, String.class, new AtomicBooleanStringBinding());
        registerBinding(AtomicInteger.class, String.class, new AtomicIntegerStringBinding());
        registerBinding(AtomicLong.class, String.class, new AtomicLongStringBinding());
        registerBinding(BigDecimal.class, String.class, new BigDecimalStringBinding());
        registerBinding(BigInteger.class, String.class, new BigIntegerStringBinding());
        registerBinding(Boolean.class, String.class, new BooleanStringBinding());
        registerBinding(Byte.class, String.class, new ByteStringBinding());
        registerBinding(Calendar.class, String.class, new CalendarStringBinding());
        registerBinding(Character.class, String.class, new CharacterStringBinding());
        registerBinding(CharSequence.class, String.class, new CharSequenceStringBinding());
        registerBinding(Class.class, String.class, new ClassStringBinding());
        registerBinding(Currency.class, String.class, new CurrencyStringBinding());
        registerBinding(Date.class, String.class, new DateStringBinding());
        registerBinding(Double.class, String.class, new DoubleStringBinding());
        registerBinding(File.class, String.class, new FileStringBinding());
        registerBinding(Float.class, String.class, new FloatStringBinding());
        registerBinding(InetAddress.class, String.class, new InetAddressStringBinding());
        registerBinding(Integer.class, String.class, new IntegerStringBinding());
        registerBinding(Locale.class, String.class, new LocaleStringBinding());
        registerBinding(Long.class, String.class, new LongStringBinding());
        registerBinding(Package.class, String.class, new PackageStringBinding());
        registerBinding(Short.class, String.class, new ShortStringBinding());
        registerBinding(StringBuffer.class, String.class, new StringBufferStringBinding());
        registerBinding(StringBuilder.class, String.class, new StringBuilderStringBinding());
        registerBinding(String.class, String.class, new StringStringBinding());
        registerBinding(TimeZone.class, String.class, new TimeZoneStringBinding());
        registerBinding(URI.class, String.class, new URIStringBinding());
        registerBinding(URL.class, String.class, new URLStringBinding());
        registerBinding(UUID.class, String.class, new UUIDStringBinding());
    }
1238206
@Override
  public void register(TaskExecutor taskExecutor) {
	lock.lock();
	try {
	  Iterator<TaskExecutor> it = taskExecutors.iterator();
	  while (it.hasNext()) {
		TaskExecutor e = it.next();
		if (e.isShutdown() && e.hasTask() == false) {
		  it.remove();
		}
	  }

	  if (taskExecutors.contains(taskExecutor) == false) {
		taskExecutors.add(taskExecutor);
	  }
	} finally {
	  lock.unlock();
	}
  }
43387
private void registerOperations() {
    Class<?> type = getClass();
    for (Method method : type.getMethods()) {
      if (isOperationMethod(method)) {
        registerMethod(method);
      }
    }
  }
1182152
private void processConstraintData() throws IOException
   {
      ConstraintFactory factory = new ConstraintFactory();
      factory.process(m_projectDir, m_file, m_inputStreamFactory);
   }
151158
private void registerTypeMappings(
      TypeMapping registryTypeMapping, List<TypeMapping> typeMappings) {
    Preconditions.checkNotNull(registryTypeMapping, "Null registry type mapping");
    Preconditions.checkNotNull(typeMappings, "Null type mappings");
    Preconditions.checkArgument(!typeMappings.isEmpty(), "Empty type mappings");
    for (TypeMapping typeMapping : typeMappings) {
      for (Class<?> mappingClass : typeMapping.getAllClasses()) {
        QName classQName = typeMapping.getTypeQName(mappingClass);
        DeserializerFactory deserializer = typeMapping.getDeserializer(mappingClass, classQName);
        if (deserializer != null && !registryTypeMapping.isRegistered(mappingClass, classQName)) {
          registryTypeMapping.register(
              mappingClass, classQName, (SerializerFactory) null, deserializer);
        }
      }
    }
  }
1293073
public function registerConfiguredProviders()
    {
        foreach ([
                     CacheProvider::class,
                     PartProvider::class,
                     SchedulingProvider::class,
                     ViewProvider::class,
                     EventProvider::class,
                     DatabaseProvider::class,
                     LogProvider::class,
                     HttpProvider::class,
                     SocketProvider::class,

                     ExtendProvider::class,
                 ] as $provider) {
            $this->register($provider);
        }
    }
150754
public <A extends Annotation> void register(final Class<A> anno, final ConversionProcessorFactory<A> factory) {
        factoryMap.put(anno, factory);
    }
184899
public static void register(BeanDefinitionRegistry registry, String... packageNames) {
		Assert.notNull(registry, "Registry must not be null");
		Assert.notNull(packageNames, "PackageNames must not be null");
		register(registry, Arrays.asList(packageNames));
	}
247503
public boolean register(ConstraintSplitter<? extends Constraint> ccb) {
        return builders.put(ccb.getKey(), ccb) == null;
    }
877583
protected void registerBindingConfigurationEntries(Iterable<BindingConfigurationEntry> bindings) {

        for (BindingConfigurationEntry nextBinding : bindings) {
        	try {
        		registerBindingConfigurationEntry(nextBinding);
        	} catch (IllegalStateException e) {
        		// Ignore this - it can happen when introspecting class mappings
        	}
        }
    }
755490
protected <T> RegistrationAnnotatedBindingBuilder<T> register(Class<T> type) {
        return registryBinderImpl.register(type);
    }
869947
private void applyPredicatesForRegisteredItems(final List<PredicateHandler> predicates) {
        ImmutableList.builder()
                .addAll(getEnabledModules())
                .addAll(getEnabledBundles())
                .addAll(getEnabledExtensions())
                .addAll(getEnabledInstallers())
                .build()
                .stream()
                .<ItemInfo>map(this::getInfo)
                .forEach(item -> applyDisablePredicates(predicates, item));
    }
896726
public synchronized void setRegisters(InputRegister[] regs) {
        if (regs == null) {
            registers = null;
            count = 0;
            return;
        }

        registers = Arrays.copyOf(regs, regs.length);
        if (regs.length > 31) {
            throw new IllegalArgumentException();
        }

        count = regs.length;
    }