Creates a {@link Mapper} that only ever uses the single supplied {@link Binder}.
320800
@NonNull
    public static <T> Mapper<T> singletonMapper(@NonNull Binder<T, ?> binder) {
        //noinspection unchecked
        return new SingletonMapper<>((Binder<T, View>) checkNotNull(binder, "binder"));
    }
449307
public static <E, M extends BinderMapper<E>> M mapperFor(ParameterizedType type) throws NoSuchMapperException {
		@SuppressWarnings("unchecked")
		M mapper = AbstractContext.getMapper((Class<E>) type.getActualTypeArguments()[0]);
		if (mapper == null) {
			throw new NoSuchMapperException(type.getRawType());
		} else {
			return mapper;
		}
	}
62601
public static <K, V> Mapper<K, V> from(Map<K, V> map) {
		return new Mapper<K, V>(map);
	}
658615
protected MapBinder<String, MessageOutput.Factory<? extends MessageOutput>> outputsMapBinder() {
        return MapBinder.newMapBinder(binder(),
                TypeLiteral.get(String.class),
                new TypeLiteral<MessageOutput.Factory<? extends MessageOutput>>() {
                });
    }
946192
public Mapper<K, V> uniqueKey() {
		return addConstraint(new Restraint<K, V>() {
			
			@Override
			public void checkKeyValue(K key, V value) {
				checkArgument(!delegate.get().containsKey(key), "The key: %s is already exist.", key);
			}
		});
	}
346557
public static <K,V> Storage<K,V> createHashtableStorage(){
		return new Storage<K,V>(new MapStorageWrapper<K, V>(new HashMap<K, V>()));
	}
160031
public Binder convert(Class<?> returnType, Class<?>... argTypes) {
        return new Binder(this, new Convert(type()), MethodType.methodType(returnType, argTypes));
    }
258919
public <U> CoreRemoteMongoIterable<U> map(final Function<ResultT, U> mapper) {
    return new CoreRemoteMappingIterable<>(this, mapper);
  }
892612
@SuppressWarnings("unchecked")
    @Override
    public <U> U chain(Function<? super S, U> mapper) {
        return mapper.apply((S)this);
    }
1191610
public static Map makeMap(Mapper mapper, Iterator i) {
        return makeMap(mapper, i, false);
    }
216938
public static <K, V> MapBuilder<K, V> map(Map<K, V> instance) {
		return new MapBuilder<>(instance);
	}
439875
public static LinkedBindingBuilder<HandlerWrapper> bindSecurityHandler(final Binder binder)
    {
        return binder.bind(HandlerWrapper.class).annotatedWith(SECURITY_NAMED);
    }
1017201
public static Map makeMap(Mapper mapper, Enumeration en) {
        return makeMap(mapper, en, false);
    }
314268
public static <T, R> Publisher<R> map(Publisher<T> publisher, Function<T, R> mapper) {
        return actual -> publisher.subscribe(new CompletionAwareSubscriber<T>() {
            @Override
            protected void doOnSubscribe(Subscription subscription) {
                actual.onSubscribe(subscription);
            }

            @Override
            protected void doOnNext(T message) {
                try {
                    R result = Objects.requireNonNull(mapper.apply(message),
                        "The mapper returned a null value.");
                    actual.onNext(result);
                } catch (Throwable e) {
                    onError(e);
                }

            }

            @Override
            protected void doOnError(Throwable t) {
                actual.onError(t);
            }

            @Override
            protected void doOnComplete() {
                actual.onComplete();
            }
        });
    }
983093
public static <T> GinMultibinder<T> newSetBinder(GinBinder binder, TypeLiteral<T> type) {
    return newSetBinder(binder, type, Key.get(providerOf(type)));
  }
830557
public static <T> SerializerBinderBuilder<T> builderOf(Binder binder, final Class<T> type) {
        return new SerializerBinderBuilderImpl<T> (binder, new TypeReference<T>() {
            @Override
            public Type getType() {
                return type;
            }
        });
    }
1173584
public static Map<String, IDLProxyObject> create(Reader reader) throws IOException {
        return create(reader, false);
    }