Java MutableObject.setValue方法代码示例

import org.apache.commons.lang3.mutable.MutableObject; //导入方法依赖的package包/类
@Test
public void shouldAllowSameMethodRegistrationFromDifferentThreads() throws Exception {

    final MutableObject<StateMachineDefinition> definitionOne = new MutableObject<>(null);
    final MutableObject<StateMachineDefinition> definitionTwo = new MutableObject<>(null);

    final Thread thread1 = new Thread(() -> {
        localContext.registerNew("fooBar", 1, "someDescription","someContext");
        definitionOne.setValue(tlStateMachineDef.get());
    });
    final Thread thread2 = new Thread(() -> {
        localContext.registerNew("fooBar", 1, "someDescription","someContext");
        definitionTwo.setValue(tlStateMachineDef.get());
    });
    thread1.start();
    thread2.start();

    thread1.join();
    thread2.join();

    assertThat(definitionOne.getValue()).isNotNull().isEqualTo(definitionTwo.getValue()).isEqualTo(new StateMachineDefinition("someDescription", "fooBar", 1l, new HashSet<>(), new HashSet<>(), "someContext"));
}
 

import org.apache.commons.lang3.mutable.MutableObject; //导入方法依赖的package包/类
/**
 * Request a remote synchronization. This call blocks until the operation is complete,
 * or the thread is interrupted.
 * 
 * @throws InterruptedException
 */
public SynchronizeResult blockingSynchronize() throws InterruptedException
{
	log.info("Queuing a blocking sync request");
	final MutableObject<SynchronizeResult> result = new MutableObject<SynchronizeResult>();
	final CountDownLatch cdl = new CountDownLatch(1);
	Consumer<SynchronizeResult> callback = new Consumer<SynchronizeResult>()
	{
		@Override
		public void accept(SynchronizeResult t)
		{
			result.setValue(t);
			cdl.countDown();
		}
	};

	synchronize(callback);
	cdl.await();
	return result.getValue();
}
 

import org.apache.commons.lang3.mutable.MutableObject; //导入方法依赖的package包/类
private Callable<Object> createServer(final MutableObject<String> actualRequest) {
    return new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            LOGGER.info("SERVER: receiving request");
            UDPTransport transport = new UDPTransport(SERVER_PORT);
            String request = transport.receive();
            actualRequest.setValue(request);

            LOGGER.info("SERVER: sending answer");
            transport.send(ANSWER);

            LOGGER.info("SERVER: finished");
            return null;
        }
    };
}
 

import org.apache.commons.lang3.mutable.MutableObject; //导入方法依赖的package包/类
private Callable<Object> createClient(final MutableObject<String> actualAnswer) {
    return new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            LOGGER.info("CLIENT: sending request");
            UDPTransport transport = new UDPTransport(InetAddress.getLocalHost(), SERVER_PORT, TIMEOUT);
            transport.send(REQUEST);

            LOGGER.info("CLIENT: receiving answer");
            String answer = transport.receive();
            actualAnswer.setValue(answer);

            LOGGER.info("CLIENT: finished");
            return null;
        }
    };
}
 

import org.apache.commons.lang3.mutable.MutableObject; //导入方法依赖的package包/类
private void evaluate(WebDriver driver, WebElementSelector locator, BiFunction<WebDriver, WebElementSelector, String> callback, boolean disableValueCheck, MutableObject<String> resultHolder) {
	String result = StringUtils.stripToEmpty(callback.apply(driver, locator));
	resultHolder.setValue(result);
	String expectedValue = locator.getExpectedValue();
	if (disableValueCheck || StringUtils.isBlank(expectedValue) || this.fitnesseMarkup.compare(expectedValue, result)) {
		return;
	}
	throw new NoSuchElementException(MessageFormat.format("Element with unexpected value [Expected: {0}, Obtained: {1}]", expectedValue, result));
}
 

import org.apache.commons.lang3.mutable.MutableObject; //导入方法依赖的package包/类
private String getString(String name)
{
	int functionId = this.getNewId();
	this.sendString(String.format("GET %s %i\r\n\r\n", name, functionId));
	String pattern = String.format("RESP %i (.*)\r\n\r\n", functionId);
	MutableObject<String> result = new MutableObject<>(null);
	Consumer<String> callback = (input) ->
	{
		result.setValue(Pattern.compile(pattern).matcher(input).group(1));
	};
	this.awaitMessage("", callback);
	while(result.getValue() == null)
		this.getNextMessage();
	return result.getValue();
}
 

import org.apache.commons.lang3.mutable.MutableObject; //导入方法依赖的package包/类
@Override
@SuppressWarnings( "unchecked" )
public MutableObject deserialize( JsonParser p,
                                  DeserializationContext ctxt ) throws IOException {

    try {
        final MutableObject vc = ( MutableObject ) _valueClass.newInstance();

        vc.setValue( ctxt.readValue( p, refType ) );

        return vc;
    } catch( InstantiationException | IllegalAccessException e ) {
        throw ctxt.instantiationException( _valueClass, e );
    }
}
 

import org.apache.commons.lang3.mutable.MutableObject; //导入方法依赖的package包/类
private void parseParameter(String parameter,
		MutableObject<String> whereClause,
		MutableObject<String[]> whereParameter) {
	// get whereClause and whereParameter
	Pattern p = Pattern.compile("^\\[([^,]+),([^,]+)\\]$");
	Matcher m = p.matcher(parameter);
	if (m.find()) {
		whereClause.setValue("between ? and ?");
		whereParameter.setValue(new String[] { m.group(1), m.group(2) });
		return;
	}

	whereClause.setValue("=?");
	whereParameter.setValue(new String[] { parameter });
}
 

import org.apache.commons.lang3.mutable.MutableObject; //导入方法依赖的package包/类
public static Iterable<Class<?>> hierarchy(final Class<?> type, final Interfaces interfacesBehavior) {
    final Iterable<Class<?>> classes = new Iterable<Class<?>>() {

        @Override
        public Iterator<Class<?>> iterator() {
            final MutableObject<Class<?>> next = new MutableObject<Class<?>>(type);
            return new Iterator<Class<?>>() {

                @Override
                public boolean hasNext() {
                    return next.getValue() != null;
                }

                @Override
                public Class<?> next() {
                    final Class<?> result = next.getValue();
                    next.setValue(result.getSuperclass());
                    return result;
                }

                @Override
                public void remove() {
                    throw new UnsupportedOperationException();
                }

            };
        }

    };
    if (interfacesBehavior != Interfaces.INCLUDE) {
        return classes;
    }
    return new Iterable<Class<?>>() {

        @Override
        public Iterator<Class<?>> iterator() {
            final Set<Class<?>> seenInterfaces = new HashSet<Class<?>>();
            final Iterator<Class<?>> wrapped = classes.iterator();

            return new Iterator<Class<?>>() {
                Iterator<Class<?>> interfaces = Collections.<Class<?>> emptySet().iterator();

                @Override
                public boolean hasNext() {
                    return interfaces.hasNext() || wrapped.hasNext();
                }

                @Override
                public Class<?> next() {
                    if (interfaces.hasNext()) {
                        final Class<?> nextInterface = interfaces.next();
                        seenInterfaces.add(nextInterface);
                        return nextInterface;
                    }
                    final Class<?> nextSuperclass = wrapped.next();
                    final Set<Class<?>> currentInterfaces = new LinkedHashSet<Class<?>>();
                    walkInterfaces(currentInterfaces, nextSuperclass);
                    interfaces = currentInterfaces.iterator();
                    return nextSuperclass;
                }

                private void walkInterfaces(final Set<Class<?>> addTo, final Class<?> c) {
                    for (final Class<?> iface : c.getInterfaces()) {
                        if (!seenInterfaces.contains(iface)) {
                            addTo.add(iface);
                        }
                        walkInterfaces(addTo, iface);
                    }
                }

                @Override
                public void remove() {
                    throw new UnsupportedOperationException();
                }

            };
        }
    };
}
 

import org.apache.commons.lang3.mutable.MutableObject; //导入方法依赖的package包/类
@Test
public void testReceive_ErrorMessage() throws Exception {
    // prepare
    final String expectedErrorMessage = "errorMessage";
    thrown.expect(TransportException.class);
    thrown.expect(new BaseMatcher<Throwable>() {
        private final String exceptionMessage = "Received Error : " + expectedErrorMessage;

        @Override
        public void describeTo(Description description) {
            description.appendText("a TransportException with ErrorMessage(" + exceptionMessage + ")");
        }

        @Override
        public boolean matches(Object item) {
            if (!(item instanceof TransportException)) {
                return false;
            }

            TransportException exception = (TransportException) item;
            if (!equalTo(exceptionMessage).matches(exception.getMessage())) {
                return false;
            }
            ErrorMessage errorMessage = exception.getErrorMessage();
            return (errorMessage != null) && equalTo(expectedErrorMessage).matches(errorMessage.getMessage());
        }
    });

    final MutableObject<Message> messageWrapper = new MutableObject<Message>();
    Transport transport = mock(Transport.class);
    when(transport.receive()).thenReturn(ErrorMessage.class.getName(), expectedErrorMessage);
    TransportHelper helper = new TransportHelper() {
        @Override
        Message createMessage(Class<? extends Message> clazz)
            throws InstantiationException, IllegalAccessException {
            Message message = spy(super.createMessage(clazz));
            messageWrapper.setValue(message);
            return message;
        }
    };

    // test
    helper.receive(transport);
}