Make a new {@code ConstraintsConverter} and fulfill it
using a default converter for each supported constraint.

@return a fulfilled converter.
349082
public static ConstraintsConverter newBundle() {
        //The default converters
        ConstraintsConverter c = new ConstraintsConverter();
        c.register(new AmongConverter());
        c.register(new BanConverter());
      c.register(new DeadlineConverter());
        c.register(new ResourceCapacityConverter());
        c.register(new RunningCapacityConverter());
        c.register(new FenceConverter());
        c.register(new GatherConverter());
        c.register(new KilledConverter());
        c.register(new LonelyConverter());
        c.register(new OfflineConverter());
        c.register(new OnlineConverter());
        c.register(new OverbookConverter());
        c.register(new PreserveConverter());
        c.register(new QuarantineConverter());
        c.register(new ReadyConverter());
        c.register(new RootConverter());
        c.register(new RunningConverter());
        c.register(new SeqConverter());
      c.register(new SerializeConverter());
        c.register(new SleepingConverter());
        c.register(new SplitAmongConverter());
        c.register(new SplitConverter());
        c.register(new SpreadConverter());
      c.register(new SyncConverter());
        c.register(new MaxOnlineConverter());
        c.register(new MinMTTRConverter());
        c.register(new MinMTTRMigConverter());
        c.register(new MinMigrationsConverter());
      c.register(new NoDelayConverter());
      c.register(new PrecedenceConverter());

        return c;
    }
1106819
public final SimpleDistanceConstraint invert() {
		SimpleDistanceConstraint newConstraint = new SimpleDistanceConstraint();
		newConstraint.setMinimum(-this.getMaximum());
		newConstraint.setMaximum(-this.getMinimum());
		newConstraint.setFrom(this.getTo());
		newConstraint.setTo(this.getFrom());
		return newConstraint;
	}
135254
public List<ConstraintDefinitionType<ConstraintMappingsType<T>>> getAllConstraintDefinition()
   {
      List<ConstraintDefinitionType<ConstraintMappingsType<T>>> list = new ArrayList<ConstraintDefinitionType<ConstraintMappingsType<T>>>();
      List<Node> nodeList = childNode.get("constraint-definition");
      for(Node node: nodeList)
      {
         ConstraintDefinitionType<ConstraintMappingsType<T>>  type = new ConstraintDefinitionTypeImpl<ConstraintMappingsType<T>>(this, "constraint-definition", childNode, node);
         list.add(type);
      }
      return list;
   }
53812
public static ConfigurationOptionBuilder<Collection<String>> stringsOption() {
		return new ConfigurationOptionBuilder<Collection<String>>(SetValueConverter.STRINGS_VALUE_CONVERTER, Collection.class)
				.defaultValue(Collections.<String>emptySet());
	}
221589
public JodaBeanSer withConverter(StringConvert converter) {
        JodaBeanUtils.notNull(converter, "converter");
        return new JodaBeanSer(indent, newLine, converter, iteratorFactory, shortTypes, deserializers, includeDerived);
    }
135054
public static <T> Mapping<List<T>> list(Mapping<T> base, Constraint... constraints) {
        String mname = "list of " + base.meta().name;
        return new FieldMapping<>(
                InputMode.MULTIPLE,
                ((name, data) -> {
                    logger.debug("list - converting {}", name);

                    return indexes(name, data).stream()
                            .map(i -> base.convert(name + "[" + i + "]", data))
                            .collect(Collectors.toList());
                }),
                ((name, data, messages, options) -> {
                    logger.debug("list - validating {}", name);

                    return indexes(name, data).stream()
                            .flatMap(i -> base.validate(name + "[" + i + "]", data, messages, options).stream())
                            .collect(Collectors.toList());
                }), new MappingMeta(mname, List.class, base)
            ).constraint(constraints);
        }
1225815
@Trivial
    public static <K> UserConverter<K> newInstance(Converter<K> converter) {
        return newInstance(getType(converter), converter);
    }
181282
public <T> Message build(MessageBodyConverter<T> converter) {
        if (StringUtils.isBlank(this.topic)) {
            throw new IllegalArgumentException("Blank topic");
        }
        if (this.body == null && this.payload == null) {
            throw new IllegalArgumentException("Empty payload");
        }
        byte[] payload = this.payload;
        if (payload == null && converter != null) {
            try {
                payload = converter.toByteArray((T) this.body);
            }
            catch (MetaClientException e) {
                throw new IllegalStateException("Convert message body failed.", e);
            }
        }

        if (payload == null) {
            throw new IllegalArgumentException("Empty payload");
        }
        return new Message(this.topic, payload, this.attribute);
    }
1269144
@SuppressWarnings("unchecked") public <R, W> Converter<R, W> getTypeConverter(Class<?> key) {
        return (Converter<R, W>) typeConverts.get(key);
    }
451931
@Override
    public List<String> getConstraintMapping() {
        List<String> result = new ArrayList<String>();

        for (String constraintMappingString : constraintMapping) {
            if (constraintMappingString != null) {
                constraintMappingString = constraintMappingString.trim();
            }
            result.add(constraintMappingString);
        }
        return result;
    }
993243
public static ISonarConverter getConverterInstance() {

        if (converterInstance == null) {

            synchronized (DefaultSonarConverter.class) {

                if (converterInstance == null)
                    converterInstance = new DefaultSonarConverter();
            }
        }

        return converterInstance;
    }
148564
public static <T> Converter<T> createConverter(
      Class<T> klass, InstantiatorModule... modules) {
    return createConverterForType(klass, modules);
  }
487612
public Converter getConverter() {

        if (this.converter != null) {
            return (this.converter);
        }
        return (Converter) getStateHelper().eval(PropertyKeys.converter);

    }
696027
public Converter<B, A> reverse() {
		Converter<B, A> result = reverse;
		return (result == null) ? reverse = new ReverseConverter<A, B>(this) : result;
	}
853342
public static IAggregatingConverter make(IConverter... converters) {
        checkNotNull(converters);
        return make(Arrays.asList(converters));
    }
800066
public List<Converter<EntityMappings<T>>> getAllConverter()
   {
      List<Converter<EntityMappings<T>>> list = new ArrayList<Converter<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("converter");
      for(Node node: nodeList)
      {
         Converter<EntityMappings<T>>  type = new ConverterImpl<EntityMappings<T>>(this, "converter", childNode, node);
         list.add(type);
      }
      return list;
   }
476558
@Override
  public <S, T> Convert<S, T> converter(Class<S> source, Class<T> target)
  {
    ConvertFrom<S> convertType = getOrCreate(source);
    
    return convertType.converter(target);
  }