public static <T> T newProxyInstance(Class<T> interfaceClass, T delegate, long sleep) { return SerializingProxy.newProxyInstance(interfaceClass, InterruptibleProxy.newProxyInstance(interfaceClass, DelayProxy.newProxyInstance(interfaceClass, delegate, sleep), CancelDelegate.CANCEL)); }
public static <T> T newProxyInstance(Class<T> interfaceClass, T delegate, long sleepTimeMs) { return newProxyInstance(interfaceClass, delegate, Suppliers.ofInstance(sleepTimeMs)); }
public static <T> T newProxyInstance(Class<T> interfaceClass, T delegate, CancelDelegate cancel) { return newProxyInstance(interfaceClass, delegate, cancel, defaultExecutor.get()); }
private static void changeHandlerThread(InvocationHandler handler, Thread oldThread, Thread newThread) { if (handler instanceof ThreadConfinedProxy) { ((ThreadConfinedProxy) handler).changeThread(oldThread, newThread); } if (handler instanceof DelegatingInvocationHandler) { changeThread(((DelegatingInvocationHandler) handler).getDelegate(), oldThread, newThread); } }
public static <T> T newProxyInstance(Class<T> interfaceClass, T delegate) { return newProxyInstance(interfaceClass, delegate, (is, codebase) -> new ObjectInputStream(is)); }
public static <T> T newProxyInstance(Class<T> interfaceClass, T mainDelegate, T... delegatesToCall) { return newProxyInstance(interfaceClass, mainDelegate, Arrays.asList(delegatesToCall)); }
public static RequestBatchingTimestampService create(TimestampService untimedDelegate) { TimestampService delegate = TimingProxy.newProxyInstance(TimestampService.class, untimedDelegate, timer); DisruptorAutobatcher<Integer, TimestampRange> autobatcher = DisruptorAutobatcher.create(consumer(delegate)); return new RequestBatchingTimestampService(delegate, autobatcher); }
public static <T> T copy(T orig) { return copy(orig, (is, codebase) -> new ObjectInputStream(is)); }
@SuppressWarnings("unchecked") public static <T> T newProxyInstance(Class<T> interfaceClass, T delegate, OperationTimer timer) { return (T)Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[] {interfaceClass}, new TimingProxy(delegate, timer)); }
@SuppressWarnings("unchecked") public static <T> T newProxyInstance(Class<T> interfaceClass, T delegate) { return (T)Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[] {interfaceClass}, new SingleCallProxy(delegate)); }
@SuppressWarnings("unchecked") public static <T> T newProxyInstance(Class<T> interfaceClass, T delegate, CancelDelegate cancel, ExecutorService executor) { return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[] {interfaceClass}, new InterruptibleProxy(delegate, cancel, executor)); }
@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { return method.invoke(getDelegate(), args); } catch (InvocationTargetException e) { throw e.getCause(); } } }
@SuppressWarnings("unchecked") public static <T> T newProxyInstance(Class<T> interfaceClass, T delegate, Supplier<Long> sleepTimeMsSupplier) { return (T)Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[] {interfaceClass}, new DelayProxy(delegate, sleepTimeMsSupplier)); }
@SuppressWarnings("unchecked") public static <T> T newProxyInstance(Class<T> interfaceClass, T delegate, ObjectInputStreamFactory factory) { return (T)Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[] {interfaceClass}, new SerializingProxy(delegate, factory)); }
/** * For each method invoked on the returned object, {@link Supplier#get()} will be called * and iterated over. */ @SuppressWarnings("unchecked") public static <T> T newProxyInstance(Class<T> interfaceClass, T mainDelegate, Supplier<? extends Iterable<? extends T>> dynamicDelegatesToCall) { return (T)Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[] {interfaceClass}, new MultiDelegateProxy<T>(mainDelegate, dynamicDelegatesToCall)); }
/** * This creates a one time use visitable. The only proper use of the returned class is to call * accept on it directly and never reference it again. */ @SuppressWarnings("unchecked") public static <T> BatchingVisitable<T> create(final Iterator<? extends T> iterator) { return SingleCallProxy.newProxyInstance(BatchingVisitable.class, create((Iterable<T>) () -> IteratorUtils.wrap(iterator)) ); }
public static <T> T newProxyInstance(Class<T> interfaceClass, T delegate, long sleep, AtomicBoolean throwException) { return SimulatingServerProxy.newProxyInstance( interfaceClass, ToggleableExceptionProxy.newProxyInstance(interfaceClass, delegate, throwException, new RuntimeException()), sleep); }
@Test public void learnerRecovery() { for (int i = 0; i < NUM_POTENTIAL_LEADERS * 3; i++) { state.gainLeadership(i % NUM_POTENTIAL_LEADERS); } PaxosLearnerImpl learner = (PaxosLearnerImpl) ((DelegatingInvocationHandler) Proxy.getInvocationHandler(state.learner(0))).getDelegate(); PaxosStateLog<PaxosValue> log = learner.log; SortedMap<Long, PaxosValue> cache = learner.state; log.truncate(log.getGreatestLogEntry()); cache.clear(); state.gainLeadership(0); } }
@Override protected LockService getLockService() { return SerializingProxy.newProxyInstance(LockService.class, LockServiceImpl.create( LockServerOptions.builder() .isStandaloneServer(false) .lockStateLoggerDir(LockServiceTestUtils.TEST_LOG_STATE_DIR) .build())); } }
/** * This will copy off all the objects in delegatesToCall. */ public static <T> T newProxyInstance(Class<T> interfaceClass, T mainDelegate, Iterable<? extends T> delegatesToCall) { return newProxyInstance(interfaceClass, mainDelegate, Suppliers.ofInstance(ImmutableList.copyOf(delegatesToCall))); }