de.ruedigermoeller.kontraktor

Class Actors

java.lang.Object

de.ruedigermoeller.kontraktor.Actors

public class Actors
extends Object

Copyright (c) 2012, Ruediger Moeller. All rights reserved. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Date: 04.01.14 Time: 19:50 To change this template use File | Settings | File Templates.

Field Summary

Fields

Modifier and Type	Field and Description
protected Timer	delayedCalls
protected ExecutorService	exec
protected ActorProxyFactory	factory

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	Actors()

Method Summary

Methods

Modifier and Type	Method and Description
static <T extends Actor> T	$$(Class<T> clz)
static <T extends Actor> T	AsActor(Class<? extends Actor> actorClazz) create an new actor.
static <T extends Actor> T	AsActor(Class<? extends Actor> actorClazz, DispatcherThread disp) create an new actor dispatched in the given DispatcherThread
static <T extends Actor> T	AsActor(Class<? extends Actor> actorClazz, int qSize) create an new actor.
static <T> Future<T>	Async(Callable<T> toCall) execute a callable asynchronously (in a different thread) and return a future of the result (delivered in caller thread)
static <T> void	Delayed(int millis, Runnable toRun) schedule an action or call delayed.
protected <T> void	delayedCall(int millis, Runnable toRun)
protected ActorProxyFactory	getFactory()
static <T> T	InThread(T callback) Creates a wrapper on the given object enqueuing all calls to INTERFACE methods of the given object to the calling actors's queue.
protected DispatcherThread	newDispatcher(int qSize) return a new dispatcher backed by a new thread.
protected Actor	newProxy(Class<? extends Actor> clz, DispatcherThread disp)
protected Actor	newProxy(Class<? extends Actor> clz, int qsize)
protected <T> void	runBlockingCall(Callable<T> toCall, Callback<T> resultHandler)
static void	SetDefaultQueueSize(int siz)
static <T extends Actor> T	SpawnActor(Class<? extends Actor> actorClazz) create a new actor with a newly created DispatcherThread
static <T extends Actor> T	SpawnActor(Class<? extends Actor> actorClazz, int qSiz) create a new actor with a newly created DispatcherThread
static Future<Future[]>	Yield(Future... futures) wait for all futures to complete and return an array of fulfilled futures e.g.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

exec

protected ExecutorService exec

delayedCalls

protected Timer delayedCalls

factory

protected ActorProxyFactory factory

Constructor Detail

Actors

protected Actors()

Method Detail

SetDefaultQueueSize

public static void SetDefaultQueueSize(int siz)

AsActor

public static <T extends Actor> T AsActor(Class<? extends Actor> actorClazz)

create an new actor. If this is called outside an actor, a new DispatcherThread will be scheduled. If called from inside actor code, the new actor will share the thread+queue with the caller.

Type Parameters:

T -

Parameters:

actorClazz -

Returns:

AsActor

public static <T extends Actor> T AsActor(Class<? extends Actor> actorClazz,
                          int qSize)

create an new actor. If this is called outside an actor, a new DispatcherThread will be scheduled. If called from inside actor code, the new actor will share the thread+queue with the caller.

Type Parameters:

T -

Parameters:

actorClazz -

Returns:

InThread

public static <T> T InThread(T callback)

Creates a wrapper on the given object enqueuing all calls to INTERFACE methods of the given object to the calling actors's queue. This is used to enable processing of resulting callback's in the callers thread. see also @InThread annotation.

Type Parameters:

T -

Parameters:

callback -

Returns:

AsActor

public static <T extends Actor> T AsActor(Class<? extends Actor> actorClazz,
                          DispatcherThread disp)

create an new actor dispatched in the given DispatcherThread

Type Parameters:

T -

Parameters:

actorClazz -

Returns:

SpawnActor

public static <T extends Actor> T SpawnActor(Class<? extends Actor> actorClazz)

create a new actor with a newly created DispatcherThread

Type Parameters:

T -

Parameters:

actorClazz -

Returns:

$$

public static <T extends Actor> T $$(Class<T> clz)

SpawnActor

public static <T extends Actor> T SpawnActor(Class<? extends Actor> actorClazz,
                             int qSiz)

create a new actor with a newly created DispatcherThread

Type Parameters:

T -

Parameters:

actorClazz -

qSiz - - size of mailbox queue

Returns:

Async

public static <T> Future<T> Async(Callable<T> toCall)

execute a callable asynchronously (in a different thread) and return a future of the result (delivered in caller thread)

Type Parameters:

T -

Parameters:

toCall -

Returns:

Delayed

public static <T> void Delayed(int millis,
               Runnable toRun)

schedule an action or call delayed. typical use case: Actors.Delayed( 100, () -> { self().doAction( x, y, ); } );

Type Parameters:

T -

Yield

public static Future<Future[]> Yield(Future... futures)

wait for all futures to complete and return an array of fulfilled futures e.g. Yield( f1, f2 ).then( (f,e) -> System.out.println( f[0].getResult() + f[1].getResult() ) );

Parameters:

futures -

Returns:

getFactory

protected ActorProxyFactory getFactory()

delayedCall

protected <T> void delayedCall(int millis,
                   Runnable toRun)

runBlockingCall

protected <T> void runBlockingCall(Callable<T> toCall,
                       Callback<T> resultHandler)

newProxy

protected Actor newProxy(Class<? extends Actor> clz,
             DispatcherThread disp)

newProxy

protected Actor newProxy(Class<? extends Actor> clz,
             int qsize)

newDispatcher

protected DispatcherThread newDispatcher(int qSize)

return a new dispatcher backed by a new thread. Overriding classes should *not* return existing dispatchers here, as this can be used to isolate blocking code from the actor flow. if qSiz lesser or equal 0 use default size

Returns: