Register the given Converter objects with the given target ConverterRegistry.
@param converters the converter objects: implementing {@link Converter},
{@link ConverterFactory}, or {@link GenericConverter}
@param registry the target registry
513676
public static void registerConverters(Set<?> converters, ConverterRegistry registry) {
		if (converters != null) {
			for (Object converter : converters) {
				if (converter instanceof GenericConverter) {
					registry.addConverter((GenericConverter) converter);
				}
				else if (converter instanceof Converter<?, ?>) {
					registry.addConverter((Converter<?, ?>) converter);
				}
				else if (converter instanceof ConverterFactory<?, ?>) {
					registry.addConverterFactory((ConverterFactory<?, ?>) converter);
				}
				else {
					throw new IllegalArgumentException("Each converter object must implement one of the " +
							"Converter, ConverterFactory, or GenericConverter interfaces");
				}
			}
		}
	}
528122
public void addConverter(ValueConverter<?, ?> converter) {

    getInitializationState().requireNotInitilized();
    if (this.converters == null) {
      this.converters = new ArrayList<>();
    }
    this.converters.add(converter);
  }
1329714
public void iterateAllRegisteredTypeConverters (@Nonnull final ITypeConverterCallback aCallback)
  {
    // Create a copy of the map
    final Map <Class <?>, Map <Class <?>, ITypeConverter <?, ?>>> aCopy = m_aRWLock.readLocked ( () -> new CommonsHashMap <> (m_aConverter));

    // And iterate the copy
    outer: for (final Map.Entry <Class <?>, Map <Class <?>, ITypeConverter <?, ?>>> aSrcEntry : aCopy.entrySet ())
    {
      final Class <?> aSrcClass = aSrcEntry.getKey ();
      for (final Map.Entry <Class <?>, ITypeConverter <?, ?>> aDstEntry : aSrcEntry.getValue ().entrySet ())
        if (aCallback.call (aSrcClass, aDstEntry.getKey (), aDstEntry.getValue ()).isBreak ())
          break outer;
    }
  }
1052576
protected void secondary(final String name, final AttributeConverter<? extends Object> converter) {
        secondaries.add(name);
        converters.put(name, converter);
    }
181813
public void init(Convert converter)
    {
        m_converter = converter;
        if (converter != null)
            this.setColumns(converter.getMaxLength());
    }
402037
public static IAggregatingConverter make(Collection<? extends IConverter> converters) {
        checkNotNull(converters);
        return builder().aggregates(converters).build();
    }
1280851
public void setConfigurationAggregators(java.util.Collection<ConfigurationAggregator> configurationAggregators) {
        if (configurationAggregators == null) {
            this.configurationAggregators = null;
            return;
        }

        this.configurationAggregators = new com.amazonaws.internal.SdkInternalList<ConfigurationAggregator>(configurationAggregators);
    }
1066715
public void setRegistry(BridgeHeadTypeRegistry registry) {
        this.registry.set(registry);
        for (FactoryAccessor<?> accessor : accessors) {
            registry.injectInto(accessor);
        }
    }
626544
private void register(String converterClassName) {

    Class<Converter> converterClass = ObjectUtils.loadClass(converterClassName);

    if (ObjectUtils.assignableTo(converterClass, Converter.class)) {
      try {
        Converter<?, ?> converter = (Converter<?, ?>) converterClass.newInstance();
        register(converter);
      }
      catch (Exception ignore) {
      }
    }
  }
135699
public <R, W> JSONer register(Converter<R, W> converter, Class<?>... types) {
        for (Class<?> type : checkNotNull(types)) {
            typeConverts.put(type, checkNotNull(converter));
        }
        return this;
    }
339346
private void registerConverterInstance(Class<?> valueType, Converter converter)
  {
    if(converters.put(valueType, converter) == null) {
      log.debug("Register converter |%s| for value type |%s|.", converter.getClass(), valueType);
    }
    else {
      log.warn("Override converter |%s| for value type |%s|.", converter.getClass(), valueType);
    }
  }
274872
public void initializeAll(InjectionManager injectionManager) {
        if (injectionManager != null) {
            for (Converter<?> converter : _converters) {
                Field[] fields = ReflectionUtils.getFields(converter.getClass(), Inject.class);
                for (Field field : fields) {
                    final Object value;
                    if (field.getType() == Converter.class) {
                        // Injected converters are used as callbacks. They
                        // should be assigned to the outer converter, which is
                        // this.
                        value = this;
                    } else {
                        InjectionPoint<Object> injectionPoint = new MemberInjectionPoint<Object>(field, converter);
                        value = injectionManager.getInstance(injectionPoint);
                    }
                    field.setAccessible(true);
                    try {
                        field.set(converter, value);
                    } catch (Exception e) {
                        throw new IllegalStateException("Could not initialize converter: " + converter, e);
                    }
                }
            }
        }
    }
404798
public static void setConverterFactoryClass(Configuration conf,
      Class<? extends ConverterFactory> converterFactoryClass) {
    conf.setClass(CONVERTER_FACTORY, converterFactoryClass, ConverterFactory.class);
    LOG.debug("Set input ConverterFactory class on conf: {}", converterFactoryClass);
  }
853342
public static IAggregatingConverter make(IConverter... converters) {
        checkNotNull(converters);
        return make(Arrays.asList(converters));
    }
827570
public static <U, V> Converter<U, V> wrapSingletonList(Converter<List<U>, V> converter) {
    Converter<U, List<U>> listConverter = new SingletonListConverter<U>().inverse();
    return listConverter.compose(converter);
  }
1130416
public static void register(CollectorRegistry registry) {
    new StandardExports().register(registry);
    new MemoryPoolsExports().register(registry);
    new MemoryAllocationExports().register(registry);
    new BufferPoolsExports().register(registry);
    new GarbageCollectorExports().register(registry);
    new ThreadExports().register(registry);
    new ClassLoadingExports().register(registry);
    new VersionInfoExports().register(registry);
  }
928291
public void addConverters(Converter converter, String... tags) {
        for (String tag : tags) {
            if (tag.startsWith("!")) {
                notConverters.put(tag.substring(1), converter);
            } else {
                converters.put(tag, converter);
            }
        }
    }