Java MutableObject.getValue方法代码示例

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包/类
@Override
public Object onEvent(T stateful, String event, Object... parms) throws TooBusyException {
	ArrayList<Object> parmList = new ArrayList<Object>(Arrays.asList(parms));
	
	// Create a Mutable Object and add it to the Parameter List - it will be used
	// to return the returned value from the Controller as the FSM returns the State
	//
	MutableObject<T> returnValue = new MutableObject<T>();
	ArrayList<Object> invokeParmlist = new ArrayList<Object>(parms.length + 1);
	invokeParmlist.add(returnValue);
	invokeParmlist.addAll(parmList);
	
	// Call the FSM
	// 
	fsm.onEvent(stateful, event, invokeParmlist.toArray());
	return returnValue.getValue();
}
 

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包/类
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();
                }

            };
        }
    };
}