source: java/main/src/main/java/com/framsticks/util/dispatching/Dispatching.java @ 88

package com.framsticks.util.dispatching;

import org.apache.log4j.Logger;

import com.framsticks.util.StateFunctor;

/**
 * @author Piotr Sniegowski
 */
public abstract class Dispatching {
        private static final Logger log = Logger.getLogger(Dispatching.class);

        public static boolean isThreadSafe() {
                return true;
        }

        public static <C> void invokeLaterOrNow(Dispatcher<C> dispatcher, RunAt<? extends C> runnable) {
                if (dispatcher.isActive()) {
                        runnable.run();
                        return;
                }
                dispatcher.invokeLater(runnable);
        }

        //TODO RunAt StateFunctor
        public static <C> void dispatchOk(Dispatcher<C> dispatcher, final StateFunctor stateFunctor) {
                dispatcher.invokeLater(new RunAt<C>() {
                        @Override
                        public void run() {
                                stateFunctor.call(null);
                        }
                });
        }

        // public static boolean assertInvokeLater(Dispatcher dispatcher, RunAt runnable) {
        //      dispatcher.invokeLater(runnable);
        //      return true;
        // }

        public static <P, C> void invokeDispatch(Dispatcher<P> dispatcher, final Dispatcher<C> finalDispatcher, final RunAt<C> runnable) {
                dispatcher.invokeLater(new RunAt<P>() {
                        @Override
                        public void run() {
                                finalDispatcher.invokeLater(runnable);
                        }
                });
        }

        public static void sleep(int milliseconds) {
                try {
                        java.lang.Thread.sleep(milliseconds, 0);
                } catch (InterruptedException e) {

                }
        }

        @SuppressWarnings("unchecked")
        public static void dispatcherGuardedInvoke(Joinable joinable, RunAt<?> runnable) {
                if (joinable instanceof Dispatcher) {
                        invokeLaterOrNow(Dispatcher.class.cast(joinable), runnable);
                        return;
                }
                runnable.run();
        }

        public static void use(final Joinable joinable, final JoinableParent owner) {
                log.debug("using " + joinable + " by " + owner);
                if (joinable.use(owner)) {
                        log.debug("started " + joinable);
                } else {
                        log.debug("start of " + joinable + " already happened");
                }
        }


        public static void drop(final Joinable joinable, final JoinableParent owner) {
                log.debug("droping " + joinable + " by " + owner);
                if (joinable.drop(owner)) {
                        log.debug("stoped " + joinable);
                } else {
                        log.debug("stop of " + joinable + " deferred");
                }
        }

        public static void join(Joinable joinable) throws InterruptedException {
                log.debug("joining " + joinable);
                try {
                        joinable.join();
                } catch (InterruptedException e) {
                        log.debug("failed to join " + joinable);
                        throw e;
                }
                log.debug("joined " + joinable);
        }

        public static void childChangedState(final JoinableParent parent, final Joinable joinable, final JoinableState state) {
                dispatcherGuardedInvoke(joinable, new RunAt<Object>() {
                        @Override
                        public void run() {
                                log.debug("joinable " + joinable + " is notifying parent " + parent + " about change to " + state);
                                parent.childChangedState(joinable, state);
                        }
                });
        }

        public static void wait(Object object, long millis) {
                try {
                        object.wait(millis);
                } catch (InterruptedException e) {
                }
        }

        public static void joinAbsolutely(Joinable joinable) {
                log.info("joining absolutely " + joinable);
                while (true) {
                        try {
                                Dispatching.join(joinable);
                                return;
                        } catch (InterruptedException e) {
                                // throw new FramsticksException().msg("failed to join").arg("dispatcher", dispatcher).cause(e);
                        }
                        log.info("waiting for " + joinable);
                        sleep(500);
                }
        }




}