下面列出了io.reactivex.functions.Function3#com.github.davidmoten.guavamini.Preconditions 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
* Transforms the results using the given function.
*
* @param mapper
* maps the query results to an object
* @return the results of the query as an Observable
*/
@Override
public <T> Flowable<Tx<T>> get(@Nonnull ResultSetMapper<? extends T> mapper) {
Preconditions.checkNotNull(mapper, "mapper cannot be null");
return Flowable.defer(() -> {
AtomicReference<Connection> connection = new AtomicReference<Connection>();
Flowable<T> o = Update.<T>createReturnGeneratedKeys( //
update.updateBuilder.connections //
.map(c -> Util.toTransactedConnection(connection, c)),
update.parameterGroupsToFlowable(), update.updateBuilder.sql, mapper, false);
return o.materialize() //
.flatMap(n -> Tx.toTx(n, connection.get(), db)) //
.doOnNext(tx -> {
if (tx.isComplete()) {
((TxImpl<T>) tx).connection().commit();
}
});
});
}
public static <T> FlowableTransformer<T, T> rebatchRequests(final int minRequest, final long maxRequest,
final boolean constrainFirstRequestMin) {
Preconditions.checkArgument(minRequest <= maxRequest, "minRequest cannot be greater than maxRequest");
return new FlowableTransformer<T, T>() {
@Override
public Publisher<T> apply(Flowable<T> source) {
if (minRequest == maxRequest && constrainFirstRequestMin) {
return source.rebatchRequests(minRequest);
} else {
return source
.compose(Transformers.<T>minRequest(constrainFirstRequestMin ? minRequest : 1, minRequest))
.compose(Transformers.<T>maxRequest(maxRequest));
}
}
};
}
public static <T1, T2, T3, T4> ResultSetMapper<Tuple4<T1, T2, T3, T4>> tuple(
final Class<T1> cls1, final Class<T2> cls2, final Class<T3> cls3,
final Class<T4> cls4) {
Preconditions.checkNotNull(cls1, "cls1 cannot be null");
Preconditions.checkNotNull(cls2, "cls2 cannot be null");
Preconditions.checkNotNull(cls3, "cls3 cannot be null");
Preconditions.checkNotNull(cls4, "cls4 cannot be null");
return new ResultSetMapper<Tuple4<T1, T2, T3, T4>>() {
@Override
public Tuple4<T1, T2, T3, T4> apply(ResultSet rs) {
return new Tuple4<T1, T2, T3, T4>(mapObject(rs, cls1, 1),
mapObject(rs, cls2, 2), mapObject(rs, cls3, 3),
mapObject(rs, cls4, 4));
}
};
}
public static <T1, T2, T3, T4, T5> ResultSetMapper<Tuple5<T1, T2, T3, T4, T5>> tuple(
final Class<T1> cls1, final Class<T2> cls2, final Class<T3> cls3, final Class<T4> cls4,
final Class<T5> cls5) {
Preconditions.checkNotNull(cls1, "cls1 cannot be null");
Preconditions.checkNotNull(cls2, "cls2 cannot be null");
Preconditions.checkNotNull(cls3, "cls3 cannot be null");
Preconditions.checkNotNull(cls4, "cls4 cannot be null");
Preconditions.checkNotNull(cls5, "cls5 cannot be null");
return new ResultSetMapper<Tuple5<T1, T2, T3, T4, T5>>() {
@Override
public Tuple5<T1, T2, T3, T4, T5> apply(ResultSet rs) {
return new Tuple5<T1, T2, T3, T4, T5>(mapObject(rs, cls1, 1),
mapObject(rs, cls2, 2), mapObject(rs, cls3, 3),
mapObject(rs, cls4, 4), mapObject(rs, cls5, 5));
}
};
}
public static <T1, T2, T3, T4, T5, T6> ResultSetMapper<Tuple6<T1, T2, T3, T4, T5, T6>> tuple(
final Class<T1> cls1, final Class<T2> cls2, final Class<T3> cls3, final Class<T4> cls4,
final Class<T5> cls5, final Class<T6> cls6) {
Preconditions.checkNotNull(cls1, "cls1 cannot be null");
Preconditions.checkNotNull(cls2, "cls2 cannot be null");
Preconditions.checkNotNull(cls3, "cls3 cannot be null");
Preconditions.checkNotNull(cls4, "cls4 cannot be null");
Preconditions.checkNotNull(cls5, "cls5 cannot be null");
Preconditions.checkNotNull(cls6, "cls6 cannot be null");
return new ResultSetMapper<Tuple6<T1, T2, T3, T4, T5, T6>>() {
@Override
public Tuple6<T1, T2, T3, T4, T5, T6> apply(ResultSet rs) {
return new Tuple6<T1, T2, T3, T4, T5, T6>(mapObject(rs, cls1, 1),
mapObject(rs, cls2, 2), mapObject(rs, cls3, 3),
mapObject(rs, cls4, 4), mapObject(rs, cls5, 5),
mapObject(rs, cls6, 6));
}
};
}
public static <T1, T2, T3, T4, T5, T6, T7> ResultSetMapper<Tuple7<T1, T2, T3, T4, T5, T6, T7>> tuple(
final Class<T1> cls1, final Class<T2> cls2, final Class<T3> cls3, final Class<T4> cls4,
final Class<T5> cls5, final Class<T6> cls6, final Class<T7> cls7) {
Preconditions.checkNotNull(cls1, "cls1 cannot be null");
Preconditions.checkNotNull(cls2, "cls2 cannot be null");
Preconditions.checkNotNull(cls3, "cls3 cannot be null");
Preconditions.checkNotNull(cls4, "cls4 cannot be null");
Preconditions.checkNotNull(cls5, "cls5 cannot be null");
Preconditions.checkNotNull(cls6, "cls6 cannot be null");
Preconditions.checkNotNull(cls7, "cls7 cannot be null");
return new ResultSetMapper<Tuple7<T1, T2, T3, T4, T5, T6, T7>>() {
@Override
public Tuple7<T1, T2, T3, T4, T5, T6, T7> apply(ResultSet rs) {
return new Tuple7<T1, T2, T3, T4, T5, T6, T7>(mapObject(rs, cls1, 1),
mapObject(rs, cls2, 2), mapObject(rs, cls3, 3),
mapObject(rs, cls4, 4), mapObject(rs, cls5, 5),
mapObject(rs, cls6, 6), mapObject(rs, cls7, 7));
}
};
}
@SuppressWarnings("unchecked")
private final T parameterList(Object[] values) {
Preconditions.checkNotNull(values);
if (values.length == 0) {
// no effect
return (T) this;
}
Preconditions.checkArgument(sqlInfo.numParameters() == 0 || values.length % sqlInfo.numParameters() == 0,
"number of values should be a multiple of number of parameters in sql: " + sqlInfo.sql());
Preconditions.checkArgument(Arrays.stream(values)
.allMatch(o -> sqlInfo.names().isEmpty() || (o instanceof Parameter && ((Parameter) o).hasName())));
for (Object val : values) {
if (val == null) {
parameterBuffer.add(Parameter.NULL);
} else {
parameterBuffer.add(val);
}
}
return (T) this;
}
static ConnectionProvider from(@Nonnull String url) {
Preconditions.checkNotNull(url, "url cannot be null");
return new ConnectionProvider() {
@Override
public Connection get() {
try {
return DriverManager.getConnection(url);
} catch (SQLException e) {
throw new SQLRuntimeException(e);
}
}
@Override
public void close() {
// do nothing as closure will be handle by pool
}
};
}
static ConnectionProvider from(@Nonnull String url, String username, String password) {
Preconditions.checkNotNull(url, "url cannot be null");
return new ConnectionProvider() {
@Override
public Connection get() {
try {
return DriverManager.getConnection(url, username, password);
} catch (SQLException e) {
throw new SQLRuntimeException(e);
}
}
@Override
public void close() {
// do nothing as closure will be handle by pool
}
};
}
static ConnectionProvider from(@Nonnull String url, Properties properties) {
Preconditions.checkNotNull(url, "url cannot be null");
Preconditions.checkNotNull(properties, "properties cannot be null");
return new ConnectionProvider() {
@Override
public Connection get() {
try {
return DriverManager.getConnection(url, properties);
} catch (SQLException e) {
throw new SQLRuntimeException(e);
}
}
@Override
public void close() {
// do nothing as closure will be handle by pool
}
};
}
public FlowableStateMachine(Flowable<In> source, //
Callable<? extends State> initialState, //
Function3<? super State, ? super In, ? super Emitter<Out>, ? extends State> transition, //
BiConsumer<? super State, ? super Emitter<Out>> completionAction, //
Consumer3<? super State, ? super Throwable, ? super Emitter<Out>> errorAction, //
BackpressureStrategy backpressureStrategy, //
int requestBatchSize) {
Preconditions.checkNotNull(initialState);
Preconditions.checkNotNull(transition);
Preconditions.checkNotNull(backpressureStrategy);
Preconditions.checkArgument(requestBatchSize > 0,
"initialRequest must be greater than zero");
this.source = source;
this.initialState = initialState;
this.transition = transition;
this.completionAction = completionAction;
this.errorAction = errorAction;
this.backpressureStrategy = backpressureStrategy;
this.requestBatchSize = requestBatchSize;
}
@SuppressWarnings("unchecked")
MemberSingle(NonBlockingPool<T> pool) {
Preconditions.checkNotNull(pool);
this.initializedAvailable = new MpscLinkedQueue<DecoratingMember<T>>();
this.notInitialized = new MpscLinkedQueue<DecoratingMember<T>>();
this.toBeReleased = new MpscLinkedQueue<DecoratingMember<T>>();
this.toBeChecked = new MpscLinkedQueue<DecoratingMember<T>>();
this.members = createMembersArray(pool.maxSize, pool.checkinDecorator);
for (DecoratingMember<T> m : members) {
notInitialized.offer(m);
}
this.scheduler = pool.scheduler;
this.createRetryIntervalMs = pool.createRetryIntervalMs;
this.observers = new AtomicReference<>(EMPTY);
this.pool = pool;
}
NonBlockingPool(Callable<? extends T> factory, Predicate<? super T> healthCheck, Consumer<? super T> disposer,
int maxSize, long idleTimeBeforeHealthCheckMs, long maxIdleTimeMs, long createRetryIntervalMs,
BiFunction<? super T, ? super Checkin, ? extends T> checkinDecorator, Scheduler scheduler,
Action closeAction) {
Preconditions.checkNotNull(factory);
Preconditions.checkNotNull(healthCheck);
Preconditions.checkNotNull(disposer);
Preconditions.checkArgument(maxSize > 0);
Preconditions.checkNotNull(checkinDecorator);
Preconditions.checkNotNull(scheduler);
Preconditions.checkArgument(createRetryIntervalMs >= 0, "createRetryIntervalMs must be >=0");
Preconditions.checkNotNull(closeAction);
Preconditions.checkArgument(maxIdleTimeMs >= 0, "maxIdleTime must be >=0");
this.factory = factory;
this.healthCheck = healthCheck;
this.disposer = disposer;
this.maxSize = maxSize;
this.idleTimeBeforeHealthCheckMs = idleTimeBeforeHealthCheckMs;
this.maxIdleTimeMs = maxIdleTimeMs;
this.createRetryIntervalMs = createRetryIntervalMs;
this.checkinDecorator = checkinDecorator;
this.scheduler = scheduler;// schedules retries
this.closeAction = closeAction;
}
private void write(byte[] bytes, int offset, int length, int padding, final MessageType messageType,
int totalLength) {
Preconditions.checkArgument(length != 0);
pages.markForRewriteAndAdvance4Bytes();// messageSize left as 0
// storeFence not required at this point like Aeron uses.
// UnsafeAccess.unsafe().storeFence();
// TODO optimize for BigEndian as well
if (padding == 2 && isLittleEndian) {
pages.putInt(((messageType.value() & 0xFF) << 0) | (((byte) padding)) << 8);
} else {
pages.putByte(messageType.value()); // message type
pages.putByte((byte) padding);
if (padding > 0) {
pages.moveWritePosition(padding);
}
}
if (messageType == MessageType.FRAGMENT && offset == 0) {
// first fragment only of a sequence of fragments
pages.putInt(totalLength);
}
pages.put(bytes, offset, length);
// now that the message bytes are written we can set the length field in
// the header to indicate that the message is ready to be read
pages.putIntOrderedAtRewriteMark(length);
}
@Override
public Connection con() {
if (hasConnection.compareAndSet(false, true)) {
// blocking
Connection c = connectionProvider.get();
Preconditions.checkNotNull(c, "connectionProvider should not return null");
connection = new PooledConnection(c, this);
}
return connection;
}
/**
* Sets the provider of {@link Connection} objects to be used by the pool.
*
* @param cp
* connection provider
* @return this
*/
public Builder<T> connectionProvider(ConnectionProvider cp) {
Preconditions.checkArgument(!(cp instanceof SingletonConnectionProvider), //
"connection provider should not return a singleton connection because " //
+ "a pool needs control over the creation and closing of connections. " //
+ "Use ConnectionProvider.from(url,...) instead.");
this.cp = cp;
return this;
}
public static <T1, T2> ResultSetMapper<Tuple2<T1, T2>> tuple(final Class<T1> cls1,
final Class<T2> cls2) {
Preconditions.checkNotNull(cls1, "cls1 cannot be null");
Preconditions.checkNotNull(cls2, "cls2 cannot be null");
return new ResultSetMapper<Tuple2<T1, T2>>() {
@Override
public Tuple2<T1, T2> apply(ResultSet rs) {
return new Tuple2<T1, T2>(mapObject(rs, cls1, 1), mapObject(rs, cls2, 2));
}
};
}
public static <T1, T2, T3> ResultSetMapper<Tuple3<T1, T2, T3>> tuple(final Class<T1> cls1,
final Class<T2> cls2, final Class<T3> cls3) {
Preconditions.checkNotNull(cls1, "cls1 cannot be null");
Preconditions.checkNotNull(cls2, "cls2 cannot be null");
Preconditions.checkNotNull(cls3, "cls3 cannot be null");
return new ResultSetMapper<Tuple3<T1, T2, T3>>() {
@Override
public Tuple3<T1, T2, T3> apply(ResultSet rs) {
return new Tuple3<T1, T2, T3>(mapObject(rs, cls1, 1),
mapObject(rs, cls2, 2), mapObject(rs, cls3, 3));
}
};
}
public static <T> ResultSetMapper<TupleN<T>> tupleN(final Class<T> cls) {
Preconditions.checkNotNull(cls, "cls cannot be null");
return new ResultSetMapper<TupleN<T>>() {
@Override
public TupleN<T> apply(ResultSet rs) {
return toTupleN(cls, rs);
}
};
}
@SuppressWarnings("unchecked")
public final T parameterStream(@Nonnull Flowable<?> values) {
Preconditions.checkNotNull(values);
if (sqlInfo.numParameters() == 0) {
parameterListStream(values.map(x -> Collections.emptyList()));
} else {
parameterListStream((Flowable<List<?>>) (Flowable<?>) values.buffer(sqlInfo.numParameters()));
}
return (T) this;
}
@SuppressWarnings("unchecked")
public final T parameterListStream(@Nonnull Flowable<List<?>> valueLists) {
Preconditions.checkNotNull(valueLists, "valueLists cannot be null");
useAndCloseParameterBuffer();
parameterGroups.add((Flowable<List<Object>>) (Flowable<?>) valueLists);
return (T) this;
}
public <R extends Event<? super T>> State<T, R> createState(String name, Class<R> eventClass) {
Preconditions.checkArgument(!eventClass.isAnnotationPresent(GenerateImmutable.class),
"cannot base a state on an event that is annotated with @GenerateImmutable, use the generated immutable class instead");
Preconditions.checkNotNull(name);
if (name.equals("Initial")) {
name = name.concat("_1");
}
State<T, R> state = new State<T, R>(this, name, eventClass);
states.add(state);
return state;
}
@JsonCreator
public EntityWithId(@JsonProperty("entity") T entity, @JsonProperty("id") String id) {
Preconditions.checkNotNull(entity);
Preconditions.checkNotNull(id);
this.entity = entity;
this.id = id;
this.className = entity.getClass().getName();
}
public static Database from(@Nonnull String url, int maxPoolSize) {
Preconditions.checkNotNull(url, "url cannot be null");
Preconditions.checkArgument(maxPoolSize > 0, "maxPoolSize must be greater than 0");
NonBlockingConnectionPool pool = Pools.nonBlocking() //
.url(url) //
.maxPoolSize(maxPoolSize) //
.build();
return Database.from( //
pool, //
() -> {
pool.close();
});
}
public static Database test(int maxPoolSize) {
Preconditions.checkArgument(maxPoolSize > 0, "maxPoolSize must be greater than 0");
return Database.from( //
Pools.nonBlocking() //
.connectionProvider(testConnectionProvider()) //
.maxPoolSize(maxPoolSize) //
.build());
}
private Processor(Function<Class<?>, EntityBehaviour<?, Id>> behaviourFactory,
Scheduler processingScheduler, Scheduler signalScheduler,
Flowable<Signal<?, Id>> signals,
Function<GroupedFlowable<ClassId<?, Id>, EntityStateMachine<?, Id>>, Flowable<EntityStateMachine<?, Id>>> entityTransform,
FlowableTransformer<Signal<?, Id>, Signal<?, Id>> preGroupBy,
Function<Consumer<Object>, Map<ClassId<?, Id>, Object>> mapFactory,
Action3<? super EntityStateMachine<?, Id>, ? super Event<?>, ? super EntityState<?>> preTransitionAction,
Consumer<? super EntityStateMachine<?, Id>> postTransitionAction) {
Preconditions.checkNotNull(behaviourFactory);
Preconditions.checkNotNull(signalScheduler);
Preconditions.checkNotNull(signals);
Preconditions.checkNotNull(entityTransform);
Preconditions.checkNotNull(preGroupBy);
Preconditions.checkNotNull(preTransitionAction);
Preconditions.checkNotNull(postTransitionAction);
// mapFactory is nullable
this.behaviourFactory = behaviourFactory;
this.signalScheduler = signalScheduler;
this.processingScheduler = processingScheduler;
this.subject = PublishSubject.create();
this.signals = signals;
this.entityTransform = entityTransform;
this.preGroupBy = preGroupBy;
this.mapFactory = mapFactory;
this.signallerClock = Clock.from(signalScheduler);
this.preTransitionAction = preTransitionAction;
this.postTransitionAction = postTransitionAction;
}
SelectBuilder(String sql, Single<Connection> connection, Database db) {
super(sql);
Preconditions.checkNotNull(sql);
Preconditions.checkNotNull(connection);
this.sql = sql;
this.connection = connection;
this.db = db;
}
@Override
public <T> Flowable<T> get(@Nonnull ResultSetMapper<? extends T> mapper) {
Preconditions.checkNotNull(mapper, "mapper cannot be null");
Flowable<List<Object>> pg = super.parameterGroupsToFlowable();
Flowable<T> f = Select.<T>create(connection, pg, sql, fetchSize, mapper, true, queryTimeoutSec);
if (dependsOn != null) {
return dependsOn.ignoreElements().andThen(f);
} else {
return f;
}
}
public static Flowable<String> fromClasspath(final Class<?> cls, final String resource, final Charset charset) {
Preconditions.checkNotNull(resource);
Preconditions.checkNotNull(charset);
Callable<Reader> resourceFactory = new Callable<Reader>() {
@Override
public Reader call() {
return new InputStreamReader(cls.getResourceAsStream(resource), charset);
}
};
return from(resourceFactory);
}
Observers(MemberSingleObserver<T>[] observers, boolean[] active, int activeCount, int index, int requested) {
Preconditions.checkArgument(observers.length > 0 || index == 0, "index must be -1 for zero length array");
Preconditions.checkArgument(observers.length == active.length);
this.observers = observers;
this.index = index;
this.active = active;
this.activeCount = activeCount;
this.requested = requested;
}