Constructs a {@link ConfigurationOptionBuilder} whose value is of type {@link Map}&lt;{@link Pattern}, {@link
String}&gt;

@return a {@link ConfigurationOptionBuilder} whose value is of type {@link Map}&lt;{@link Pattern}, {@link
String}&gt;
18478
public static ConfigurationOptionBuilder<Map<Pattern, String>> regexMapOption() {
		return new ConfigurationOptionBuilder<Map<Pattern, String>>(MapValueConverter.REGEX_MAP_VALUE_CONVERTER, Map.class)
				.defaultValue(Collections.<Pattern, String>emptyMap());
	}
882903
@CanIgnoreReturnValue
  public static SslContextBuilder configure(SslContextBuilder builder, Provider jdkProvider) {
    ApplicationProtocolConfig apc;
    if (SUN_PROVIDER_NAME.equals(jdkProvider.getName())) {
      // Jetty ALPN/NPN only supports one of NPN or ALPN
      if (JettyTlsUtil.isJettyAlpnConfigured()) {
        apc = ALPN;
      } else if (JettyTlsUtil.isJettyNpnConfigured()) {
        apc = NPN;
      } else if (JettyTlsUtil.isJava9AlpnAvailable()) {
        apc = ALPN;
      } else {
        throw new IllegalArgumentException(
            SUN_PROVIDER_NAME + " selected, but Jetty NPN/ALPN unavailable");
      }
    } else if (isConscrypt(jdkProvider)) {
      apc = ALPN;
    } else {
      throw new IllegalArgumentException("Unknown provider; can't configure: " + jdkProvider);
    }
    return builder
        .sslProvider(SslProvider.JDK)
        .ciphers(Http2SecurityUtil.CIPHERS, SupportedCipherSuiteFilter.INSTANCE)
        .applicationProtocolConfig(apc)
        .sslContextProvider(jdkProvider);
  }
1297438
public Map<String, Object> build() {
        final ImmutableMap.Builder<String, Object> builder = ImmutableMap.builder();
        final int keyCode = ofNullable(this.keyCode)
                .orElseThrow(() -> new IllegalStateException("The key code must be set"));
        builder.put("keycode", keyCode);
        ofNullable(this.metaState).ifPresent(x -> builder.put("metastate", x));
        ofNullable(this.flags).ifPresent(x -> builder.put("flags", x));
        return builder.build();
    }
664038
@Override
    protected ImmutableMap<Class<? extends QueryOptimizationProposal>, Class<? extends ProposalExecutor>>
    generateOptimizationConfigurationMap() {
        return Stream.concat(
                    super.generateOptimizationConfigurationMap().entrySet().stream(),
                    systemConfiguration.generateOptimizationConfigurationMap().entrySet().stream())
                .distinct()
                .collect(ImmutableCollectors.toMap());
    }
1022622
public FacesConfigMapEntryType<FacesConfigMapEntriesType<T>> getOrCreateMapEntry()
   {
      List<Node> nodeList = childNode.get("map-entry");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigMapEntryTypeImpl<FacesConfigMapEntriesType<T>>(this, "map-entry", childNode, nodeList.get(0));
      }
      return createMapEntry();
   }
123455
public BuildableType.Builder partialToBuilder(PartialToBuilderMethod partialToBuilder) {
    this.partialToBuilder = Objects.requireNonNull(partialToBuilder);
    _unsetProperties.remove(Property.PARTIAL_TO_BUILDER);
    return (BuildableType.Builder) this;
  }
135623
public static <T extends Annotation> AnnotationValueBuilder<T> builder(Class<T> annotation) {
        return new AnnotationValueBuilder<>(annotation);
    }
998178
public static <T extends Enum<T>> Pattern createValidationPatternFromEnumType(Class<T> enumType) {

        String regEx = Stream.of(enumType.getEnumConstants())
                .map(Enum::name)
                .collect(Collectors.joining("|", "(?i)", ""));

        //Enum constants may contain $ which needs to be escaped
        regEx = regEx.replace("$", "\\$");
        return Pattern.compile(regEx);
    }
796703
@SuppressWarnings("unchecked") public <V> Mapper<String, V> mapper() {
		if (!isChanged && nameValMap.isPresent()) {
			return (Mapper<String, V>) nameValMap.get();
		}
		
		Map<String, Object> fm = Maps.newHashMap();
		if (fieldHolder.isPresent()) {
			fieldLoop(new TransformFields2Map<Object>(fm, this.trace));
		}
		nameValMap = Optional.of(Mapper.from(fm));
		
		this.isChanged = false;
		return (Mapper<String, V>) nameValMap.get();
	}
1035672
public <U extends T, A> InitialMatching1<T, U, A> when(
      DecomposableMatchBuilder1<U, A> decomposableMatchBuilder) {
    return new InitialMatching1<>(decomposableMatchBuilder.build(), value);
  }
1182694
private MethodSpec buildConstructor( JClassType mappedTypeClass ) {
        Optional<JsonRootName> jsonRootName
                = findFirstEncounteredAnnotationsOnAllHierarchy( configuration, mappedTypeClass, JsonRootName.class );
        String rootName;
        if ( !jsonRootName.isPresent() || Strings.isNullOrEmpty( jsonRootName.get().value() ) ) {
            rootName = mappedTypeClass.getSimpleSourceName();
        } else {
            rootName = jsonRootName.get().value();
        }

        return MethodSpec.constructorBuilder()
                .addModifiers( Modifier.PUBLIC )
                .addStatement( "super($S)", rootName )
                .build();
    }
260285
public org.inferred.freebuilder.processor.property.Property.Builder mergeFrom(
      org.inferred.freebuilder.processor.property.Property value) {
    Property_Builder defaults = new org.inferred.freebuilder.processor.property.Property.Builder();
    if (defaults._unsetProperties.contains(Property.TYPE)
        || !Objects.equals(value.getType(), defaults.getType())) {
      setType(value.getType());
    }
    value.getBoxedType().ifPresent(this::setBoxedType);
    if (defaults._unsetProperties.contains(Property.NAME)
        || !Objects.equals(value.getName(), defaults.getName())) {
      setName(value.getName());
    }
    if (defaults._unsetProperties.contains(Property.CAPITALIZED_NAME)
        || !Objects.equals(value.getCapitalizedName(), defaults.getCapitalizedName())) {
      setCapitalizedName(value.getCapitalizedName());
    }
    if (defaults._unsetProperties.contains(Property.ALL_CAPS_NAME)
        || !Objects.equals(value.getAllCapsName(), defaults.getAllCapsName())) {
      setAllCapsName(value.getAllCapsName());
    }
    if (defaults._unsetProperties.contains(Property.USING_BEAN_CONVENTION)
        || value.isUsingBeanConvention() != defaults.isUsingBeanConvention()) {
      setUsingBeanConvention(value.isUsingBeanConvention());
    }
    if (defaults._unsetProperties.contains(Property.GETTER_NAME)
        || !Objects.equals(value.getGetterName(), defaults.getGetterName())) {
      setGetterName(value.getGetterName());
    }
    if (defaults._unsetProperties.contains(Property.FULLY_CHECKED_CAST)
        || value.isFullyCheckedCast() != defaults.isFullyCheckedCast()) {
      setFullyCheckedCast(value.isFullyCheckedCast());
    }
    if (value instanceof Value && accessorAnnotations == ImmutableList.<Excerpt>of()) {
      accessorAnnotations = ImmutableList.copyOf(value.getAccessorAnnotations());
    } else {
      addAllAccessorAnnotations(value.getAccessorAnnotations());
    }
    return (org.inferred.freebuilder.processor.property.Property.Builder) this;
  }
455649
public static <K, V> MapBuilder<K, V> create(Map<K, V> map) {
		return new MapBuilder<>(map);
	}
25218
public SelectBuilder format(final String _pattern)
    {
        addPoint();
        this.bldr.append("format[").append(_pattern).append("]");
        return this;
    }
1305017
private static ConfigurationBuilder getConfigurationBuilder(final Optional<Configuration> configuration) {
    if (configuration.isPresent()) {
      return Tang.Factory.getTang().newConfigurationBuilder(configuration.get());
    } else {
      return Tang.Factory.getTang().newConfigurationBuilder();
    }
  }
144470
public static Builder newParserConfigBuilder() {
        return new Builder() {
            boolean used = false;
            CollectionBuilder.Factory listFactory = DEFAULT_LIST_FACTORY;
            CollectionBuilder.Factory vectorFactory = DEFAULT_VECTOR_FACTORY;
            CollectionBuilder.Factory setFactory = DEFAULT_SET_FACTORY;
            CollectionBuilder.Factory mapFactory = DEFAULT_MAP_FACTORY;
            Map<Tag, TagHandler> tagHandlers = defaultTagHandlers();

            public Builder setListFactory(CollectionBuilder.Factory listFactory) {
                checkState();
                this.listFactory = listFactory;
                return this;
            }

            public Builder setVectorFactory(CollectionBuilder.Factory vectorFactory) {
                checkState();
                this.vectorFactory = vectorFactory;
                return this;
            }

            public Builder setSetFactory(CollectionBuilder.Factory setFactory) {
                checkState();
                this.setFactory = setFactory;
                return this;
            }

            public Builder setMapFactory(CollectionBuilder.Factory mapFactory) {
                checkState();
                this.mapFactory = mapFactory;
                return this;
            }

            public Builder putTagHandler(Tag tag, TagHandler handler) {
                checkState();
                this.tagHandlers.put(tag, handler);
                return this;
            }

            public Config build() {
                checkState();
                used = true;
                return new Config() {
                    public Factory getListFactory() {
                        return listFactory;
                    }

                    public Factory getVectorFactory() {
                        return vectorFactory;
                    }

                    public Factory getSetFactory() {
                        return setFactory;
                    }

                    public Factory getMapFactory() {
                        return mapFactory;
                    }

                    public TagHandler getTagHandler(Tag tag) {
                        return tagHandlers.get(tag);
                    }
                };
            }

            private void checkState() {
                if (used) {
                    throw new IllegalStateException(
                            "Builder is single-use. Not usable after build()");
                }
            }
        };
    }
121285
public <U extends T, A, B, C> InitialMatching3<T, U, A, B, C> when(
      DecomposableMatchBuilder3<U, A, B, C> decomposableMatchBuilder) {
    return new InitialMatching3<>(decomposableMatchBuilder.build(), value);
  }