org.objectweb.proactive.ProActive

org.objectweb.proactive.ProActive Class Reference

Provides static methods to manipulate or use Active Objects(creation, exception handling, migration,. More...

Collaboration diagram for org.objectweb.proactive.ProActive:

Collaboration graph
[legend]
List of all members.

Public Member Functions

void enableExitOnEmpty ()
 After this call, when the JVM has no more active objects it will be killed.

Static Public Member Functions

static void newMain (String classname, String[] mainParameters, Node node) throws ClassNotFoundException, NoSuchMethodException, ProActiveException
 Launches the main method of the main class through the node node.
static void newRemote (String classname, Node node) throws ClassNotFoundException, ProActiveException
 Creates an instance of the remote class.
static Object newActive (String classname, Object[] constructorParameters) throws ActiveObjectCreationException, NodeException
 Creates a new ActiveObject based on classname attached to a default node in the local JVM.
static Object newActive (String classname, Object[] constructorParameters, String nodeURL) throws ActiveObjectCreationException, NodeException
 Creates a new ActiveObject based on classname attached to the node of the given URL.
static Object newActive (String classname, Object[] constructorParameters, Node node) throws ActiveObjectCreationException, NodeException
 Creates a new ActiveObject based on classname attached to the given node or on a default node in the local JVM if the given node is null.
static Object[] newActiveInParallel (String className, Object[][] constructorParameters, Node[] nodes) throws ClassNotFoundException
static Object[] newActiveInParallel (String className, Object[] constructorParameters, VirtualNode virtualNode) throws NodeException, ClassNotFoundException
static Object newActiveAsGroup (String classname, Object[] constructorParameters, VirtualNode virtualnode) throws ActiveObjectCreationException, NodeException
 Creates a new group of Active Objects.
static Object newActiveAsGroup (String className, Object[] constructorParameters, VirtualNode virtualNode, Active activity, MetaObjectFactory factory) throws ActiveObjectCreationException, NodeException
 Creates a new group of Active Objects.
static Component newActiveComponent (String className, Object[] constructorParameters, Node node, Active activity, MetaObjectFactory factory, ComponentParameters componentParameters) throws ActiveObjectCreationException, NodeException
 Creates a new ProActive component over the specified base class, according to the given component parameters, and returns a reference on the component of type Component.
static Component newActiveComponent (String className, Object[] constructorParameters, VirtualNode vn, ComponentParameters componentParameters) throws ActiveObjectCreationException, NodeException
 Creates a new ProActive component over the specified base class, according to the given component parameters, and returns a reference on the component of type Component.
static Object turnActive (Object target) throws ActiveObjectCreationException, NodeException
 Turns the target object into an ActiveObject attached to a default node in the local JVM.
static Object turnActive (Object target, String nodeURL) throws ActiveObjectCreationException, NodeException
 Turns the target object into an Active Object and send it to the Node identified by the given url.
static Object turnActive (Object target, Node node) throws ActiveObjectCreationException, NodeException
 Turns the target object into an Active Object and send it to the given Node or to a default node in the local JVM if the given node is null.
static Object turnActive (Object target, Node node, Active activity, MetaObjectFactory factory) throws ActiveObjectCreationException, NodeException
 Turns the target object into an Active Object and send it to the given Node or to a default node in the local JVM if the given node is null.
static Object turnActive (Object target, String nameOfTargetType, Node node) throws ActiveObjectCreationException, NodeException
 Turns a Java object into an Active Object and send it to a remote Node or to a local node if the given node is null.
static Object turnActive (Object target, String nameOfTargetType, Node node, Active activity, MetaObjectFactory factory) throws ActiveObjectCreationException, NodeException
 Turns a Java object into an Active Object and send it to a remote Node or to a local node if the given node is null.
static Object turnActiveAsGroup (Object target, String nameOfTargetType, VirtualNode virtualnode) throws ActiveObjectCreationException, NodeException
 Turns a Java object into a group of Active Objects and sends the elements of the group to remote Nodes mapped to the given virtualnode in the XML deployment descriptor.
static Object newActive (String classname, Class[] genericParameters, Object[] constructorParameters) throws ActiveObjectCreationException, NodeException
 Creates a new ActiveObject based on classname attached to a default node in the local JVM.
static Object newActive (String classname, Class[] genericParameters, Object[] constructorParameters, String nodeURL) throws ActiveObjectCreationException, NodeException
 Creates a new ActiveObject based on classname attached to the node of the given URL.
static Object newActive (String classname, Class[] genericParameters, Object[] constructorParameters, Node node) throws ActiveObjectCreationException, NodeException
 Creates a new ActiveObject based on classname attached to the given node or on a default node in the local JVM if the given node is null.
static Object newActive (String classname, Class[] genericParameters, Object[] constructorParameters, Node node, Active activity, MetaObjectFactory factory) throws ActiveObjectCreationException, NodeException
 Creates a new ActiveObject based on classname attached to the given node or on a default node in the local JVM if the given node is null.
static Object[] newActiveInParallel (String className, Class[] genericParameters, Object[][] constructorParameters, Node[] nodes) throws ClassNotFoundException
static Object[] newActiveInParallel (String className, Class[] genericParameters, Object[] constructorParameters, VirtualNode virtualNode) throws NodeException, ClassNotFoundException
static Object newActiveAsGroup (String classname, Class[] genericParameters, Object[] constructorParameters, VirtualNode virtualnode) throws ActiveObjectCreationException, NodeException
 Creates a new group of Active Objects.
static Object newActiveAsGroup (String classname, Class[] genericParameters, Object[] constructorParameters, VirtualNode virtualnode, Active activity, MetaObjectFactory factory) throws ActiveObjectCreationException, NodeException
 Creates a new group of Active Objects.
static Object turnActive (Object target, String nameOfTargetType, Class[] genericParameters, Node node, Active activity, MetaObjectFactory factory) throws ActiveObjectCreationException, NodeException
 Turns a Java object into an Active Object and send it to a remote Node or to a local node if the given node is null.
static Component newActiveComponent (String classname, Class[] genericParameters, Object[] constructorParameters, Node node, Active activity, MetaObjectFactory factory, ComponentParameters componentParameters) throws ActiveObjectCreationException, NodeException
 Creates a new ProActive component over the specified base class, according to the given component parameters, and returns a reference on the component of type Component.
static Component newActiveComponent (String className, Class[] genericParameters, Object[] constructorParameters, VirtualNode vn, ComponentParameters componentParameters) throws ActiveObjectCreationException, NodeException
 Creates a new ProActive component over the specified base class, according to the given component parameters, and returns a reference on the component of type Component.
static Object turnActive (Object target, Class[] genericParameters) throws ActiveObjectCreationException, NodeException
 Turns the target object into an ActiveObject attached to a default node in the local JVM.
static Object turnActive (Object target, Class[] genericParameters, String nodeURL) throws ActiveObjectCreationException, NodeException
 Turns the target object into an Active Object and send it to the Node identified by the given url.
static Object turnActive (Object target, Class[] genericParameters, Node node) throws ActiveObjectCreationException, NodeException
 Turns the target object into an Active Object and send it to the given Node or to a default node in the local JVM if the given node is null.
static Object turnActive (Object target, Class[] genericParameters, Node node, Active activity, MetaObjectFactory factory) throws ActiveObjectCreationException, NodeException
 Turns the target object into an Active Object and send it to the given Node or to a default node in the local JVM if the given node is null.
static Object turnActive (Object target, Class[] genericParameters, String nameOfTargetType, Node node) throws ActiveObjectCreationException, NodeException
 Turns a Java object into an Active Object and send it to a remote Node or to a local node if the given node is null.
static Object turnActive (Object target, Class[] genericParameters, String nameOfTargetType, Node node, Active activity, MetaObjectFactory factory) throws ActiveObjectCreationException, NodeException
 Turns a Java object into an Active Object and send it to a remote Node or to a local node if the given node is null.
static Object turnActiveAsGroup (Object target, Class[] genericParameters, String nameOfTargetType, VirtualNode virtualnode) throws ActiveObjectCreationException, NodeException
 Turns a Java object into a group of Active Objects and sends the elements of the group to remote Nodes mapped to the given virtualnode in the XML deployment descriptor.
static void register (Object obj, String url) throws java.io.IOException
 Registers an active object into a registry(RMI or IBIS or HTTP, default is RMI).
static void unregister (String url) throws java.io.IOException
 Unregisters an active object previously registered into a registry.
static Object lookupActive (String classname, String url) throws ActiveObjectCreationException, java.io.IOException
 Looks-up an active object previously registered in a registry(RMI, IBIS, HTTP).
static String[] listActive (String url) throws java.io.IOException
 Looks-up all Active Objects registered on a host, using a registry(RMI or JINI or HTTP or IBIS) The registry where to look for is fully determined with the protocol included in the url.
static String getActiveObjectNodeUrl (Object activeObject)
 Return the URL of the remote activeObject.
static boolean isException (Object future)
 Find out if the object contains an exception that should be thrown.
static void waitFor (Object future)
 Blocks the calling thread until the object future is available.
static void waitFor (Object future, long timeout) throws ProActiveException
 Blocks the calling thread until the object future is available or until the timeout expires.
static ProActiveDescriptor getProactiveDescriptor () throws ProActiveException, IOException
 Returns a ProActiveDescriptor that gives an object representation of the XML document located at the url given by proactive.pad system's property.
static ProActiveDescriptor getProactiveDescriptor (String xmlDescriptorUrl) throws ProActiveException
 Returns a ProActiveDescriptor that gives an object representation of the XML document located at the given url.
static ProActiveDescriptor getProactiveDescriptor (String xmlDescriptorUrl, VariableContract variableContract) throws ProActiveException
 Returns a ProActiveDescriptor that gives an object representation of the XML document located at the given url, and uses the given Variable Contract.
static void registerVirtualNode (VirtualNode virtualNode, String registrationProtocol, boolean replacePreviousBinding) throws ProActiveException, AlreadyBoundException
 Registers locally the given VirtualNode in a registry such RMIRegistry or JINI Lookup Service or HTTP registry.
static VirtualNode lookupVirtualNode (String url) throws ProActiveException
 Looks-up a VirtualNode previously registered in a registry(RMI or JINI or HTTP or IBIS) The registry where to look for is fully determined with the protocol included in the url.
static void unregisterVirtualNode (VirtualNode virtualNode) throws ProActiveException
 Unregisters the virtualNode previoulsy registered in a registry such as JINI or RMI.
static Body getBodyOnThis ()
 When an active object is created, it is associated with a Body that takes care of all non fonctionnal properties.
static StubObject getStubOnThis ()
 Returns a Stub-Proxy couple pointing to the local body associated to the active object whose active thread is calling this method.
static void migrateTo (Object activeObject) throws MigrationException
 Migrates the active object whose active thread is calling this method to the same location as the active object given in parameter.
static void migrateTo (String nodeURL) throws MigrationException
 Migrates the active object whose active thread is calling this method to the node caracterized by the given url.
static void migrateTo (Node node) throws MigrationException
 Migrates the active object whose active thread is calling this method to the given node.
static void migrateTo (Body bodyToMigrate, Object activeObject, boolean isNFRequest) throws MigrationException
 Migrates the given body to the same location as the active object given in parameter.
static void migrateTo (Body bodyToMigrate, String nodeURL, boolean isNFRequest) throws MigrationException
 Migrates the given body to the node caracterized by the given url.
static void migrateTo (Body bodyToMigrate, Node node, boolean isNFRequest) throws MigrationException
 Migrates the body bodyToMigrate to the given node.
static void migrateTo (Body bodyToMigrate, Node node, boolean isNFRequest, int priority) throws MigrationException
 Migrates the body bodyToMigrate to the given node.
static int waitForAny (java.util.Vector futures)
 Blocks the calling thread until one of the futures in the vector is available.
static int waitForAny (java.util.Vector futures, long timeout) throws ProActiveException
 Blocks the calling thread until one of the futures in the vector is available or until the timeout expires.
static void waitForAll (java.util.Vector futures)
 Blocks the calling thread until all futures in the vector are available.
static void waitForAll (java.util.Vector futures, long timeout) throws ProActiveException
 Blocks the calling thread until all futures in the vector are available or until the timeout expires.
static void waitForTheNth (java.util.Vector futures, int n)
 Blocks the calling thread until the N-th of the futures in the vector is available.
static void waitForTheNth (java.util.Vector futures, int n, long timeout) throws ProActiveException
 Blocks the calling thread until the N-th of the futures in the vector is available.
static boolean allAwaited (java.util.Vector futures)
 Return false if one object of futures is available.
static boolean isAwaited (Object future)
 Return false if the object future is available.
static Object getFutureValue (Object future)
 Return the object contains by the future (ie its target).
static void enableAC (Object obj) throws java.io.IOException
 Enable the automatic continuation mechanism for this active object.
static void disableAC (Object obj) throws java.io.IOException
 Disable the automatic continuation mechanism for this active object.
static void terminateActiveObject (Object ao, boolean immediate)
 Kill an Active Object while calling terminate() method on its body.
static void setImmediateService (Object obj, String methodName) throws java.io.IOException
 Set an immediate execution for the target active object obj of the method String, ie request of name methodName will be executed right away upon arrival at the target AO context.
static void setImmediateService (Object obj, String methodName, Class[] parametersTypes) throws IOException
 Set an immediate execution for the target active object obj of the method String, ie request of name methodName will be executed right away upon arrival at the target AO context.
static void removeImmediateService (Object obj, String methodName, Class[] parametersTypes) throws IOException
 Removes an immmediate execution for the active object obj, i.e.
static String getJobId ()
 
Returns:
the jobId associated with the object calling this method

static void exposeAsWebService (Object o, String url, String urn, String[] methods)
 Expose an active object as a web service.
static void unExposeAsWebService (String urn, String url)
 Delete the service on a web server.
static void exposeComponentAsWebService (Component component, String url, String componentName)
 Deploy a component as a webservice.
static void unExposeComponentAsWebService (String componentName, String url, Component component)
 Undeploy component interfaces on a web server.
static Object createStubObject (String className, UniversalBody body) throws MOPException
static void tryWithCatch (Class c)
 This has to be called just before a try block for a single exception.
static void tryWithCatch (Class[] c)
 This has to be called just before a try block for many exceptions.
static void endTryWithCatch ()
 This has to be called at the end of the try block.
static void removeTryWithCatch ()
 This has to be called at the beginning of the finally block, so it requires one.
static void throwArrivedException ()
 This can be used to query a potential returned exception, and throw it if it exists.
static void waitForPotentialException ()
 This is used to wait for the return of every call, so that we know the execution can continue safely with no pending exception.
static void addNFEListenerOnJVM (NFEListener listener)
 Add a listener for NFE reaching the local JVM.
static void removeNFEListenerOnJVM (NFEListener listener)
 Remove a listener for NFE reaching the local JVM.
static void addNFEListenerOnAO (Object ao, NFEListener listener)
 Add a listener for NFE reaching a given active object.
static void removeNFEListenerOnAO (Object ao, NFEListener listener)
 Remove a listener for NFE reaching a given active object.
static void addNFEListenerOnProxy (Object ao, NFEListener listener)
 Add a listener for NFE reaching the client side of a given active object.
static void removeNFEListenerOnProxy (Object ao, NFEListener listener)
 Remove a listener for NFE reaching the client side of a given active object.
static void addNFEListenerOnGroup (Object group, NFEListener listener)
 Add a listener for NFE regarding a group.
static void removeNFEListenerOnGroup (Object group, NFEListener listener)
 Remove a listener for NFE regarding a group.
static Collection getAllExceptions ()
 Get the exceptions that have been caught in the current ProActive.tryWithCatch()/ProActive.removeTryWithCatch() block.
static Node getNode () throws NodeException
 
Returns:
The node of the current active object.

static void exitSuccess ()
 Call this method at the end of the application if it completed successfully, for the launcher to be aware of it.
static void exitFailure ()
 Call this method at the end of the application if it did not complete successfully, for the launcher to be aware of it.
static String getProActiveVersion ()
 Returns the number of this version.

Static Public Attributes

static final Logger loggerGroup = ProActiveLogger.getLogger(Loggers.GROUPS)

Static Protected Attributes

static final Logger logger = ProActiveLogger.getLogger(Loggers.CORE)

Static Package Functions

 [static initializer]

Detailed Description

Provides static methods to manipulate or use Active Objects(creation, exception handling, migration,.

..), futures, deployment descritpors, components, groups. This class is the central point of the library.

Active Object Creation 

 newActive(...)
 turnActive(...)

Active Object Manipulation 

 getBodyOnThis()
 getActiveObjectNodeUrl(Object)
 getStubOnThis()
 migrateTo(...)
 lookupActive(String, String)
 register(Object, String)
 setImmediateService(...)

Synchronization, Futures 

 isAwaited(Object)
 waitFor(Object)
 waitForAll(Vector)
 waitForAny(Vector)
 waitForPotentialException()
 waitForTheNth(Vector, int)
 Previous methods provide also the ability to pass a timeout value

 allAwaited(Vector)
 getFutureValue(Object)
 isException(Object)

Groups Creation 

 newActiveAsGroup(...)

Components 

 newActiveComponent(...)

XML Descritpors 

 getProactiveDescriptor(String)

Non Functionnal Exceptions 

 addNFEListenerOnAO(Object, NFEListener)
 addNFEListenerOnJVM(NFEListener)
 addNFEListenerOnProxy(Object, NFEListener)
 removeNFEListenerOnAO(Object, NFEListener)
 removeNFEListenerOnJVM(NFEListener)
 removeNFEListenerOnProxy(Object, NFEListener)

Functionnal Exceptions 

 tryWithCatch(Class)
 removeTryWithCatch()
 endTryWithCatch()
 throwArrivedException()

Automatic Continuations 

 enableAC(Object)
 disableAC(Object)

Web Services 

 exposeAsWebService(Object, String, String, String[])
 exposeComponentAsWebService(Component, String, String)

Author:
ProActive Team
Since:
ProActive 0.7
See also:
ProActiveDescriptor

ProActiveGroup

Definition at line 201 of file ProActive.java.

Member Function Documentation

static void org.objectweb.proactive.ProActive.newMain ( String  classname,
String[]  mainParameters,
Node  node 
) throws ClassNotFoundException, NoSuchMethodException, ProActiveException [static]

Launches the main method of the main class through the node node.

Parameters:
classname classname of the main method to launch
mainParameters parameters
node node in which launch the main method
Exceptions:
ClassNotFoundException 
NoSuchMethodException 
ProActiveException 

Definition at line 235 of file ProActive.java.

References org.objectweb.proactive.core.runtime.ProActiveRuntime.launchMain().

static void org.objectweb.proactive.ProActive.newRemote ( String  classname,
Node  node 
) throws ClassNotFoundException, ProActiveException [static]

Creates an instance of the remote class.

This instance is created with the default constructor

Parameters:
classname 
node 
Exceptions:
ClassNotFoundException 
ProActiveException 

Definition at line 250 of file ProActive.java.

References org.objectweb.proactive.core.runtime.ProActiveRuntime.newRemote().

static Object org.objectweb.proactive.ProActive.newActive ( String  classname,
Object[]  constructorParameters 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new ActiveObject based on classname attached to a default node in the local JVM.

Parameters:
classname the name of the class to instanciate as active
constructorParameters the parameters of the constructor.
Returns:
a reference (possibly remote) on a Stub of the newly created active object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the DefaultNode cannot be created

Definition at line 264 of file ProActive.java.

Referenced by org.objectweb.proactive.ProActive.newActive(), and org.objectweb.proactive.ProActive.newActiveAsGroup().

static Object org.objectweb.proactive.ProActive.newActive ( String  classname,
Object[]  constructorParameters,
String  nodeURL 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new ActiveObject based on classname attached to the node of the given URL.

Parameters:
classname the name of the class to instanciate as active
constructorParameters the parameters of the constructor.
nodeURL the URL of the node where to create the active object. If null, the active object is created localy on a default node
Returns:
a reference (possibly remote) on a Stub of the newly created active object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node URL cannot be resolved as an existing Node

Definition at line 281 of file ProActive.java.

References org.objectweb.proactive.ProActive.newActive().

static Object org.objectweb.proactive.ProActive.newActive ( String  classname,
Object[]  constructorParameters,
Node  node 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new ActiveObject based on classname attached to the given node or on a default node in the local JVM if the given node is null.

Parameters:
classname the name of the class to instanciate as active
constructorParameters the parameters of the constructor.
node the possibly null node where to create the active object.
Returns:
a reference (possibly remote) on a Stub of the newly created active object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 303 of file ProActive.java.

References org.objectweb.proactive.ProActive.newActive().

static Object [] org.objectweb.proactive.ProActive.newActiveInParallel ( String  className,
Object  constructorParameters[][],
Node[]  nodes 
) throws ClassNotFoundException [static]

Create a set of active objects with given construtor parameters. The object activation is optimized by a thread pool.

The total of active objects created is equal to the number of nodes and to the total of constructor paramaters also.

The condition to use this method is that: constructorParameters.length == nodes.length

Parameters:
className the name of the class to instanciate as active.
constructorParameters the array that contains the parameters used to build the active objects. All active objects have the same constructor parameters.
nodes the array of nodes where the active objects are created.
Returns:
an array of references (possibly remote) on Stubs of the newly created active objects.
Exceptions:
ClassNotFoundException in the case of className is not a class.

Definition at line 327 of file ProActive.java.

Referenced by org.objectweb.proactive.ProActive.newActiveInParallel().

static Object [] org.objectweb.proactive.ProActive.newActiveInParallel ( String  className,
Object[]  constructorParameters,
VirtualNode  virtualNode 
) throws NodeException, ClassNotFoundException [static]

Create a set of identical active objects on a given virtual node. The object activation is optimized by a thread pool.

When the given virtual node is not previously activated, this method employ the node creation event producer/listerner mechanism joined to the thread pool. That aims to create an active object just after the node deploying.

Parameters:
className the name of the class to instanciate as active.
constructorParameters the array that contains the parameters used to build the active objects. All active objects have the same constructor parameters.
virtualNode the virtual node where the active objects are created.
Returns:
an array of references (possibly remote) on Stubs of the newly created active objects.
Exceptions:
NodeException happens when the given virtualNode is already activated and throws an exception.
ClassNotFoundException in the case of className is not a class.

Definition at line 352 of file ProActive.java.

References org.objectweb.proactive.ProActive.newActiveInParallel().

static Object org.objectweb.proactive.ProActive.newActiveAsGroup ( String  classname,
Object[]  constructorParameters,
VirtualNode  virtualnode 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new group of Active Objects.

The type of the group and the type of the active objects it contains correspond to the classname parameter. This group will contain one active object per node mapped onto the virtual node given as a parameter.

Parameters:
classname classname the name of the class to instanciate as active
constructorParameters constructorParameters the parameters of the constructor.
virtualnode The virtualnode where to create active objects. Active objects will be created on each node mapped to the given virtualnode in XML deployment descriptor.
Returns:
Object a Group of references (possibly remote) on Stub of newly created active objects
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the virtualnode was null

Definition at line 372 of file ProActive.java.

Referenced by org.objectweb.proactive.ProActive.newActiveAsGroup().

static Object org.objectweb.proactive.ProActive.newActiveAsGroup ( String  className,
Object[]  constructorParameters,
VirtualNode  virtualNode,
Active  activity,
MetaObjectFactory  factory 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new group of Active Objects.

The type of the group and the type of the active objects it contains correspond to the classname parameter. This group will contain one active object per node mapped onto the virtual node given as a parameter.

Parameters:
className classname the name of the class to instanciate as active
constructorParameters constructorParameters the parameters of the constructor.
virtualNode The virtualnode where to create active objects. Active objects will be created on each node mapped to the given virtualnode in XML deployment descriptor.
activity the possibly null activity object defining the different step in the activity of the object. see the definition of the activity in the javadoc of this classe for more information.
factory the possibly null meta factory giving all factories for creating the meta-objects part of the body associated to the reified object. If null the default ProActive MataObject factory is used.
Returns:
Object a Group of references (possibly remote) on Stubs of newly created active objects
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the virtualnode was null

Definition at line 397 of file ProActive.java.

References org.objectweb.proactive.ProActive.newActiveAsGroup().

static Component org.objectweb.proactive.ProActive.newActiveComponent ( String  className,
Object[]  constructorParameters,
Node  node,
Active  activity,
MetaObjectFactory  factory,
ComponentParameters  componentParameters 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new ProActive component over the specified base class, according to the given component parameters, and returns a reference on the component of type Component.

A reference on the active object base class can be retreived through the component parameters controller's method "getStubOnReifiedObject".

Parameters:
className the name of the base class. "Composite" if the component is a composite, "ParallelComposite" if the component is a parallel composite component
constructorParameters the parameters of the constructor of the object to instantiate as active. If some parameters are primitive types, the wrapper class types should be given here. null can be used to specify that no parameter are passed to the constructor.
node the possibly null node where to create the active object. If null, the active object is created localy on a default node
activity the possibly null activity object defining the different step in the activity of the object. see the definition of the activity in the javadoc of this classe for more information.
factory should be null for components (automatically created)
componentParameters the parameters of the component
Returns:
a component representative of type Component
Exceptions:
ActiveObjectCreationException if a problem occurs while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 427 of file ProActive.java.

Referenced by org.objectweb.proactive.ProActive.newActiveComponent().

static Component org.objectweb.proactive.ProActive.newActiveComponent ( String  className,
Object[]  constructorParameters,
VirtualNode  vn,
ComponentParameters  componentParameters 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new ProActive component over the specified base class, according to the given component parameters, and returns a reference on the component of type Component.

This method allows automatic of primitive components on Virtual Nodes. In that case, the appendix -cyclicInstanceNumber-number is added to the name of each of these components. If the component is not a primitive, only one instance of the component is created, on the first node retreived from the specified virtual node.

A reference on the active object base class can be retreived through the component parameters controller's method "getStubOnReifiedObject".

Parameters:
className the name of the base class. "Composite" if the component is a composite, "ParallelComposite" if the component is a parallel composite component
constructorParameters the parameters of the constructor of the object to instantiate as active. If some parameters are primitive types, the wrapper class types should be given here. null can be used to specify that no parameter are passed to the constructor.
vn the possibly null node where to create the active object. If null, the active object is created localy on a default node
componentParameters the parameters of the component
Returns:
a typed group of component representative elements, of type Component
Exceptions:
ActiveObjectCreationException if a problem occurs while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 460 of file ProActive.java.

References org.objectweb.proactive.ProActive.newActiveComponent().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target  )  throws ActiveObjectCreationException, NodeException [static]

Turns the target object into an ActiveObject attached to a default node in the local JVM.

The type of the stub is is the type of the existing object.

Parameters:
target The object to turn active
Returns:
a reference (possibly remote) on a Stub of the existing object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the DefaultNode cannot be created

Definition at line 476 of file ProActive.java.

Referenced by org.objectweb.proactive.ProActive.turnActive(), and org.objectweb.proactive.ProActive.turnActiveAsGroup().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target,
String  nodeURL 
) throws ActiveObjectCreationException, NodeException [static]

Turns the target object into an Active Object and send it to the Node identified by the given url.

The type of the stub is is the type of the existing object.

Parameters:
target The object to turn active
nodeURL the URL of the node where to create the active object on. If null, the active object is created localy on a default node
Returns:
a reference (possibly remote) on a Stub of the existing object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 492 of file ProActive.java.

References org.objectweb.proactive.ProActive.turnActive().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target,
Node  node 
) throws ActiveObjectCreationException, NodeException [static]

Turns the target object into an Active Object and send it to the given Node or to a default node in the local JVM if the given node is null.

The type of the stub is is the type of the target object.

Parameters:
target The object to turn active
node The Node the object should be sent to or null to create the active object in the local JVM
Returns:
a reference (possibly remote) on a Stub of the target object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 514 of file ProActive.java.

References org.objectweb.proactive.ProActive.turnActive().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target,
Node  node,
Active  activity,
MetaObjectFactory  factory 
) throws ActiveObjectCreationException, NodeException [static]

Turns the target object into an Active Object and send it to the given Node or to a default node in the local JVM if the given node is null.

The type of the stub is is the type of the target object.

Parameters:
target The object to turn active
node The Node the object should be sent to or null to create the active object in the local JVM
activity the possibly null activity object defining the different step in the activity of the object. see the definition of the activity in the javadoc of this classe for more information.
factory the possibly null meta factory giving all factories for creating the meta-objects part of the body associated to the reified object. If null the default ProActive MataObject factory is used.
Returns:
a reference (possibly remote) on a Stub of the target object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 535 of file ProActive.java.

References org.objectweb.proactive.ProActive.turnActive().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target,
String  nameOfTargetType,
Node  node 
) throws ActiveObjectCreationException, NodeException [static]

Turns a Java object into an Active Object and send it to a remote Node or to a local node if the given node is null.

The type of the stub is given by the parameter nameOfTargetType.

Parameters:
target The object to turn active
nameOfTargetType the fully qualified name of the type the stub class should inherit from. That type can be less specific than the type of the target object.
node The Node the object should be sent to or null to create the active object in the local JVM
Returns:
a reference (possibly remote) on a Stub of the target object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 555 of file ProActive.java.

References org.objectweb.proactive.ProActive.turnActive().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target,
String  nameOfTargetType,
Node  node,
Active  activity,
MetaObjectFactory  factory 
) throws ActiveObjectCreationException, NodeException [static]

Turns a Java object into an Active Object and send it to a remote Node or to a local node if the given node is null.

The type of the stub is given by the parameter nameOfTargetType. A Stub is dynamically generated for the existing object. The result of the call will be an instance of the Stub class pointing to the proxy object pointing to the body object pointing to the existing object. The body can be remote or local depending if the existing is sent remotely or not.

Parameters:
target The object to turn active
nameOfTargetType the fully qualified name of the type the stub class should inherit from. That type can be less specific than the type of the target object.
node The Node the object should be sent to or null to create the active object in the local JVM
activity the possibly null activity object defining the different step in the activity of the object. see the definition of the activity in the javadoc of this classe for more information.
factory the possibly null meta factory giving all factories for creating the meta-objects part of the body associated to the reified object. If null the default ProActive MataObject factory is used.
Returns:
a reference (possibly remote) on a Stub of the target object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 581 of file ProActive.java.

References org.objectweb.proactive.ProActive.turnActive().

static Object org.objectweb.proactive.ProActive.turnActiveAsGroup ( Object  target,
String  nameOfTargetType,
VirtualNode  virtualnode 
) throws ActiveObjectCreationException, NodeException [static]

Turns a Java object into a group of Active Objects and sends the elements of the group to remote Nodes mapped to the given virtualnode in the XML deployment descriptor.

The type of the stub is given by the parameter nameOfTargetType.

Parameters:
target The object to turn active
nameOfTargetType the fully qualified name of the type the stub class should inherit from. That type can be less specific than the type of the target object.
virtualnode The VirtualNode where the target object will be turn into an Active Object Target object will be turned into an Active Object on each node mapped to the given virtualnode in XML deployment descriptor.
Returns:
an array of references (possibly remote) on a Stub of the target object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 601 of file ProActive.java.

static Object org.objectweb.proactive.ProActive.newActive ( String  classname,
Class[]  genericParameters,
Object[]  constructorParameters 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new ActiveObject based on classname attached to a default node in the local JVM.

Parameters:
classname the name of the class to instanciate as active
genericParameters parameterizing types (of class
classname) 
constructorParameters the parameters of the constructor.
Returns:
a reference (possibly remote) on a Stub of the newly created active object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the DefaultNode cannot be created

Definition at line 619 of file ProActive.java.

References org.objectweb.proactive.ProActive.newActive().

static Object org.objectweb.proactive.ProActive.newActive ( String  classname,
Class[]  genericParameters,
Object[]  constructorParameters,
String  nodeURL 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new ActiveObject based on classname attached to the node of the given URL.

Parameters:
classname the name of the class to instanciate as active
genericParameters parameterizing types (of class
classname) 
constructorParameters the parameters of the constructor.
nodeURL the URL of the node where to create the active object. If null, the active object is created localy on a default node
Returns:
a reference (possibly remote) on a Stub of the newly created active object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node URL cannot be resolved as an existing Node

Definition at line 639 of file ProActive.java.

References org.objectweb.proactive.ProActive.newActive().

static Object org.objectweb.proactive.ProActive.newActive ( String  classname,
Class[]  genericParameters,
Object[]  constructorParameters,
Node  node 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new ActiveObject based on classname attached to the given node or on a default node in the local JVM if the given node is null.

Parameters:
classname the name of the class to instanciate as active
genericParameters parameterizing types (of class
classname) 
constructorParameters the parameters of the constructor.
node the possibly null node where to create the active object.
Returns:
a reference (possibly remote) on a Stub of the newly created active object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 664 of file ProActive.java.

References org.objectweb.proactive.ProActive.newActive().

static Object org.objectweb.proactive.ProActive.newActive ( String  classname,
Class[]  genericParameters,
Object[]  constructorParameters,
Node  node,
Active  activity,
MetaObjectFactory  factory 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new ActiveObject based on classname attached to the given node or on a default node in the local JVM if the given node is null.

The object returned is a stub class that extends the target class and that is automatically generated on the fly. The Stub class reference a the proxy object that reference the body of the active object. The body referenced by the proxy can either be local of remote, depending or the respective location of the object calling the newActive and the active object itself.

Parameters:
classname the name of the class to instanciate as active
genericParameters parameterizing types (of class
classname) 
constructorParameters the parameters of the constructor of the object to instantiate as active. If some parameters are primitive types, the wrapper class types should be given here. null can be used to specify that no parameter are passed to the constructor.
node the possibly null node where to create the active object. If null, the active object is created localy on a default node
activity the possibly null activity object defining the different step in the activity of the object. see the definition of the activity in the javadoc of this classe for more information.
factory the possibly null meta factory giving all factories for creating the meta-objects part of the body associated to the reified object. If null the default ProActive MetaObject factory is used.
Returns:
a reference (possibly remote) on a Stub of the newly created active object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 695 of file ProActive.java.

References org.objectweb.proactive.core.body.MetaObjectFactory.clone(), org.objectweb.proactive.ProActive.createStubObject(), org.objectweb.proactive.ext.security.ProActiveSecurityManager.generateSiblingCertificate(), org.objectweb.proactive.core.body.MetaObjectFactory.getProActiveSecurityManager(), org.objectweb.proactive.core.mop.MOPException.getTargetException(), org.objectweb.proactive.core.body.MetaObjectFactory.setProActiveSecurityManager(), org.objectweb.proactive.core.util.timer.CompositeAverageMicroTimer.setTimer(), org.objectweb.proactive.core.util.timer.CompositeAverageMicroTimer.start(), and org.objectweb.proactive.core.util.timer.CompositeAverageMicroTimer.stop().

static Object [] org.objectweb.proactive.ProActive.newActiveInParallel ( String  className,
Class[]  genericParameters,
Object  constructorParameters[][],
Node[]  nodes 
) throws ClassNotFoundException [static]

Create a set of active objects with given construtor parameters. The object activation is optimized by a thread pool.

The total of active objects created is equal to the number of nodes and to the total of constructor paramaters also.

The condition to use this method is that: constructorParameters.length == nodes.length

Parameters:
className the name of the class to instanciate as active.
genericParameters genericParameters parameterizing types
constructorParameters the array that contains the parameters used to build the active objects. All active objects have the same constructor parameters.
nodes the array of nodes where the active objects are created.
Returns:
an array of references (possibly remote) on Stubs of the newly created active objects.
Exceptions:
ClassNotFoundException in the case of className is not a class.

Definition at line 770 of file ProActive.java.

static Object [] org.objectweb.proactive.ProActive.newActiveInParallel ( String  className,
Class[]  genericParameters,
Object[]  constructorParameters,
VirtualNode  virtualNode 
) throws NodeException, ClassNotFoundException [static]

Create a set of identical active objects on a given virtual node. The object activation is optimized by a thread pool.

Parameters:
className the name of the class to instanciate as active.
genericParameters genericParameters parameterizing types
constructorParameters the array that contains the parameters used to build the active objects. All active objects have the same constructor parameters.
virtualNode the virtual node where the active objects are created.
Returns:
an array of references (possibly remote) on Stubs of the newly created active objects.
Exceptions:
NodeException happens when the given virtualNode is already activated and throws an exception.
ClassNotFoundException in the case of className is not a class.

Definition at line 821 of file ProActive.java.

static Object org.objectweb.proactive.ProActive.newActiveAsGroup ( String  classname,
Class[]  genericParameters,
Object[]  constructorParameters,
VirtualNode  virtualnode 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new group of Active Objects.

The type of the group and the type of the active objects it contains correspond to the classname parameter. This group will contain one active object per node mapped onto the virtual node given as a parameter.

Parameters:
classname classname the name of the class to instanciate as active
genericParameters genericParameters parameterizing types
constructorParameters constructorParameters the parameters of the constructor.
virtualnode The virtualnode where to create active objects. Active objects will be created on each node mapped to the given virtualnode in XML deployment descriptor.
Returns:
Object a Group of references (possibly remote) on Stub of newly created active objects
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the virtualnode was null

Definition at line 871 of file ProActive.java.

static Object org.objectweb.proactive.ProActive.newActiveAsGroup ( String  classname,
Class[]  genericParameters,
Object[]  constructorParameters,
VirtualNode  virtualnode,
Active  activity,
MetaObjectFactory  factory 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new group of Active Objects.

The type of the group and the type of the active objects it contains correspond to the classname parameter. This group will contain one active object per node mapped onto the virtual node given as a parameter.

Parameters:
classname classname the name of the class to instanciate as active
genericParameters genericParameters parameterizing types
constructorParameters constructorParameters the parameters of the constructor.
virtualnode The virtualnode where to create active objects. Active objects will be created on each node mapped to the given virtualnode in XML deployment descriptor.
activity the possibly null activity object defining the different step in the activity of the object. see the definition of the activity in the javadoc of this classe for more information.
factory the possibly null meta factory giving all factories for creating the meta-objects part of the body associated to the reified object. If null the default ProActive MataObject factory is used.
Returns:
Object a Group of references (possibly remote) on Stubs of newly created active objects
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the virtualnode was null

Definition at line 898 of file ProActive.java.

References org.objectweb.proactive.ProActive.newActive().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target,
String  nameOfTargetType,
Class[]  genericParameters,
Node  node,
Active  activity,
MetaObjectFactory  factory 
) throws ActiveObjectCreationException, NodeException [static]

Turns a Java object into an Active Object and send it to a remote Node or to a local node if the given node is null.

The type of the stub is given by the parameter nameOfTargetType. A Stub is dynamically generated for the existing object. The result of the call will be an instance of the Stub class pointing to the proxy object pointing to the body object pointing to the existing object. The body can be remote or local depending if the existing is sent remotely or not.

Parameters:
target The object to turn active
genericParameters parameterizing types (of class
classname) 
nameOfTargetType the fully qualified name of the type the stub class should inherit from. That type can be less specific than the type of the target object.
node The Node the object should be sent to or null to create the active object in the local JVM
activity the possibly null activity object defining the different step in the activity of the object. see the definition of the activity in the javadoc of this classe for more information.
factory the possibly null meta factory giving all factories for creating the meta-objects part of the body associated to the reified object. If null the default ProActive MataObject factory is used.
Returns:
a reference (possibly remote) on a Stub of the target object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 953 of file ProActive.java.

References org.objectweb.proactive.core.body.MetaObjectFactory.clone(), org.objectweb.proactive.ProActive.createStubObject(), org.objectweb.proactive.core.mop.MOPException.getTargetException(), and org.objectweb.proactive.core.body.MetaObjectFactory.setProActiveSecurityManager().

static Component org.objectweb.proactive.ProActive.newActiveComponent ( String  classname,
Class[]  genericParameters,
Object[]  constructorParameters,
Node  node,
Active  activity,
MetaObjectFactory  factory,
ComponentParameters  componentParameters 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new ProActive component over the specified base class, according to the given component parameters, and returns a reference on the component of type Component.

A reference on the active object base class can be retreived through the component parameters controller's method "getStubOnReifiedObject".

Parameters:
classname the name of the base class. "Composite" if the component is a composite, "ParallelComposite" if the component is a parallel composite component
genericParameters genericParameters parameterizing types
constructorParameters the parameters of the constructor of the object to instantiate as active. If some parameters are primitive types, the wrapper class types should be given here. null can be used to specify that no parameter are passed to the constructor.
node the possibly null node where to create the active object. If null, the active object is created localy on a default node
activity the possibly null activity object defining the different step in the activity of the object. see the definition of the activity in the javadoc of this classe for more information.
factory should be null for components (automatically created)
componentParameters the parameters of the component
Returns:
a component representative of type Component
Exceptions:
ActiveObjectCreationException if a problem occurs while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 1021 of file ProActive.java.

static Component org.objectweb.proactive.ProActive.newActiveComponent ( String  className,
Class[]  genericParameters,
Object[]  constructorParameters,
VirtualNode  vn,
ComponentParameters  componentParameters 
) throws ActiveObjectCreationException, NodeException [static]

Creates a new ProActive component over the specified base class, according to the given component parameters, and returns a reference on the component of type Component.

This method allows automatic of primitive components on Virtual Nodes. In that case, the appendix -cyclicInstanceNumber-number is added to the name of each of these components. If the component is not a primitive, only one instance of the component is created, on the first node retreived from the specified virtual node.

A reference on the active object base class can be retreived through the component parameters controller's method "getStubOnReifiedObject".

Parameters:
className the name of the base class. "Composite" if the component is a composite, "ParallelComposite" if the component is a parallel composite component
genericParameters genericParameters parameterizing types
constructorParameters the parameters of the constructor of the object to instantiate as active. If some parameters are primitive types, the wrapper class types should be given here. null can be used to specify that no parameter are passed to the constructor.
vn the possibly null node where to create the active object. If null, the active object is created localy on a default node
componentParameters the parameters of the component
Returns:
a typed group of component representative elements, of type Component
Exceptions:
ActiveObjectCreationException if a problem occurs while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 1071 of file ProActive.java.

References org.objectweb.proactive.core.component.factory.ProActiveGenericFactory.newFcInstance().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target,
Class[]  genericParameters 
) throws ActiveObjectCreationException, NodeException [static]

Turns the target object into an ActiveObject attached to a default node in the local JVM.

The type of the stub is is the type of the existing object.

Parameters:
target The object to turn active
genericParameters genericParameters parameterizing types
Returns:
a reference (possibly remote) on a Stub of the existing object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the DefaultNode cannot be created

Definition at line 1102 of file ProActive.java.

References org.objectweb.proactive.ProActive.turnActive().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target,
Class[]  genericParameters,
String  nodeURL 
) throws ActiveObjectCreationException, NodeException [static]

Turns the target object into an Active Object and send it to the Node identified by the given url.

The type of the stub is is the type of the existing object.

Parameters:
target The object to turn active
genericParameters genericParameters parameterizing types
nodeURL the URL of the node where to create the active object on. If null, the active object is created localy on a default node
Returns:
a reference (possibly remote) on a Stub of the existing object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 1120 of file ProActive.java.

References org.objectweb.proactive.ProActive.turnActive().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target,
Class[]  genericParameters,
Node  node 
) throws ActiveObjectCreationException, NodeException [static]

Turns the target object into an Active Object and send it to the given Node or to a default node in the local JVM if the given node is null.

The type of the stub is is the type of the target object.

Parameters:
target The object to turn active
genericParameters genericParameters parameterizing types
node The Node the object should be sent to or null to create the active object in the local JVM
Returns:
a reference (possibly remote) on a Stub of the target object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 1144 of file ProActive.java.

References org.objectweb.proactive.ProActive.turnActive().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target,
Class[]  genericParameters,
Node  node,
Active  activity,
MetaObjectFactory  factory 
) throws ActiveObjectCreationException, NodeException [static]

Turns the target object into an Active Object and send it to the given Node or to a default node in the local JVM if the given node is null.

The type of the stub is is the type of the target object.

Parameters:
target The object to turn active
genericParameters genericParameters parameterizing types
node The Node the object should be sent to or null to create the active object in the local JVM
activity the possibly null activity object defining the different step in the activity of the object. see the definition of the activity in the javadoc of this classe for more information.
factory the possibly null meta factory giving all factories for creating the meta-objects part of the body associated to the reified object. If null the default ProActive MataObject factory is used.
Returns:
a reference (possibly remote) on a Stub of the target object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 1166 of file ProActive.java.

References org.objectweb.proactive.ProActive.turnActive().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target,
Class[]  genericParameters,
String  nameOfTargetType,
Node  node 
) throws ActiveObjectCreationException, NodeException [static]

Turns a Java object into an Active Object and send it to a remote Node or to a local node if the given node is null.

The type of the stub is given by the parameter nameOfTargetType.

Parameters:
target The object to turn active
genericParameters genericParameters parameterizing types
nameOfTargetType the fully qualified name of the type the stub class should inherit from. That type can be less specific than the type of the target object.
node The Node the object should be sent to or null to create the active object in the local JVM
Returns:
a reference (possibly remote) on a Stub of the target object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 1187 of file ProActive.java.

References org.objectweb.proactive.ProActive.turnActive().

static Object org.objectweb.proactive.ProActive.turnActive ( Object  target,
Class[]  genericParameters,
String  nameOfTargetType,
Node  node,
Active  activity,
MetaObjectFactory  factory 
) throws ActiveObjectCreationException, NodeException [static]

Turns a Java object into an Active Object and send it to a remote Node or to a local node if the given node is null.

The type of the stub is given by the parameter nameOfTargetType. A Stub is dynamically generated for the existing object. The result of the call will be an instance of the Stub class pointing to the proxy object pointing to the body object pointing to the existing object. The body can be remote or local depending if the existing is sent remotely or not.

Parameters:
target The object to turn active
genericParameters genericParameters parameterizing types
nameOfTargetType the fully qualified name of the type the stub class should inherit from. That type can be less specific than the type of the target object.
node The Node the object should be sent to or null to create the active object in the local JVM
activity the possibly null activity object defining the different step in the activity of the object. see the definition of the activity in the javadoc of this classe for more information.
factory the possibly null meta factory giving all factories for creating the meta-objects part of the body associated to the reified object. If null the default ProActive MataObject factory is used.
Returns:
a reference (possibly remote) on a Stub of the target object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 1216 of file ProActive.java.

References org.objectweb.proactive.core.body.MetaObjectFactory.clone(), org.objectweb.proactive.ProActive.createStubObject(), org.objectweb.proactive.core.mop.MOPException.getTargetException(), and org.objectweb.proactive.core.body.MetaObjectFactory.setProActiveSecurityManager().

static Object org.objectweb.proactive.ProActive.turnActiveAsGroup ( Object  target,
Class[]  genericParameters,
String  nameOfTargetType,
VirtualNode  virtualnode 
) throws ActiveObjectCreationException, NodeException [static]

Turns a Java object into a group of Active Objects and sends the elements of the group to remote Nodes mapped to the given virtualnode in the XML deployment descriptor.

The type of the stub is given by the parameter nameOfTargetType.

Parameters:
target The object to turn active
genericParameters parameterizing types (of class
classname) 
nameOfTargetType the fully qualified name of the type the stub class should inherit from. That type can be less specific than the type of the target object.
virtualnode The VirtualNode where the target object will be turn into an Active Object Target object will be turned into an Active Object on each node mapped to the given virtualnode in XML deployment descriptor.
Returns:
an array of references (possibly remote) on a Stub of the target object
Exceptions:
ActiveObjectCreationException if a problem occur while creating the stub or the body
NodeException if the node was null and that the DefaultNode cannot be created

Definition at line 1275 of file ProActive.java.

References org.objectweb.proactive.ProActive.turnActive().

static void org.objectweb.proactive.ProActive.register ( Object  obj,
String  url 
) throws java.io.IOException [static]

Registers an active object into a registry(RMI or IBIS or HTTP, default is RMI).

In fact it is the remote version of the body of the active object that is registered into the registry under the given URL. According to the type of the associated body(default is Rmi), the registry in which to register is automatically found.

Parameters:
obj the active object to register.
url the url under which the remote body is registered. The url must point to the localhost since registering is always a local action. The url can take the form:protocol://localhost:port/nam or //localhost:port/name if protocol is RMI or //localhost/name if port is 1099 or only the name. The registered object will be reachable with the following url: protocol://machine_name:port/name using lookupActive method. Protocol and port can be removed if default
Exceptions:
java.io.IOException if the remote body cannot be registered

Definition at line 1319 of file ProActive.java.

References org.objectweb.proactive.ProActive.logger.

static void org.objectweb.proactive.ProActive.unregister ( String  url  )  throws java.io.IOException [static]

Unregisters an active object previously registered into a registry.

Parameters:
url the url under which the active object is registered.
Exceptions:
java.io.IOException if the remote object cannot be removed from the registry

Definition at line 1333 of file ProActive.java.

static Object org.objectweb.proactive.ProActive.lookupActive ( String  classname,
String  url 
) throws ActiveObjectCreationException, java.io.IOException [static]

Looks-up an active object previously registered in a registry(RMI, IBIS, HTTP).

In fact it is the remote version of the body of an active object that can be registered into the Registry under a given URL. If the lookup is successful, the method reconstructs a Stub-Proxy couple and point it to the RmiRemoteBody found. The registry where to look for is fully determined with the protocol included in the url

Parameters:
classname the fully qualified name of the class the stub should inherit from.
url the url under which the remote body is registered. The url takes the following form: protocol://machine_name:port/name. Protocol and port can be ommited if respectively RMI and 1099: //machine_name/name
Returns:
a remote reference on a Stub of type classname pointing to the remote body found
Exceptions:
java.io.IOException if the remote body cannot be found under the given url or if the object found is not of type RmiRemoteBody
ActiveObjectCreationException if the stub-proxy couple cannot be created

Definition at line 1369 of file ProActive.java.

References org.objectweb.proactive.core.mop.MOPException.getTargetException().

static String [] org.objectweb.proactive.ProActive.listActive ( String  url  )  throws java.io.IOException [static]

Looks-up all Active Objects registered on a host, using a registry(RMI or JINI or HTTP or IBIS) The registry where to look for is fully determined with the protocol included in the url.

Parameters:
url The url where to perform the lookup. The url takes the following form: protocol://machine_name:port. Protocol and port can be ommited if respectively RMI and 1099: //machine_name
Returns:
String [] the list of names registered on the host; if no Registry found, returns {}
Exceptions:
IOException If the given url does not map to a physical host, or if the connection is refused.

Definition at line 1419 of file ProActive.java.

static String org.objectweb.proactive.ProActive.getActiveObjectNodeUrl ( Object  activeObject  )  [static]

Return the URL of the remote activeObject.

Parameters:
activeObject the remote active object.
Returns:
the URL of activeObject.

Definition at line 1445 of file ProActive.java.

References org.objectweb.proactive.core.body.UniversalBody.getNodeURL().

static boolean org.objectweb.proactive.ProActive.isException ( Object  future  )  [static]

Find out if the object contains an exception that should be thrown.

Parameters:
future the future object that is examinated
Returns:
true iff an exception should be thrown when accessing the object

Definition at line 1455 of file ProActive.java.

static void org.objectweb.proactive.ProActive.waitFor ( Object  future  )  [static]

Blocks the calling thread until the object future is available.

future must be the result object of an asynchronous call. Usually the the wait by necessity model take care of blocking the caller thread asking for a result not yet available. This method allows to block before the result is first used.

Parameters:
future object to wait for

Definition at line 1479 of file ProActive.java.

static void org.objectweb.proactive.ProActive.waitFor ( Object  future,
long  timeout 
) throws ProActiveException [static]

Blocks the calling thread until the object future is available or until the timeout expires.

future must be the result object of an asynchronous call. Usually the the wait by necessity model take care of blocking the caller thread asking for a result not yet available. This method allows to block before the result is first used.

Parameters:
future object to wait for
timeout to wait in ms
Exceptions:
ProActiveException if the timeout expire

Definition at line 1505 of file ProActive.java.

static ProActiveDescriptor org.objectweb.proactive.ProActive.getProactiveDescriptor (  )  throws ProActiveException, IOException [static]

Returns a ProActiveDescriptor that gives an object representation of the XML document located at the url given by proactive.pad system's property.

Returns:
the pad located at the url given by proactive.pad system's property
Exceptions:
ProActiveException 
RemoteException 

Definition at line 1529 of file ProActive.java.

static ProActiveDescriptor org.objectweb.proactive.ProActive.getProactiveDescriptor ( String  xmlDescriptorUrl  )  throws ProActiveException [static]

Returns a ProActiveDescriptor that gives an object representation of the XML document located at the given url.

Parameters:
xmlDescriptorUrl The url of the XML document
Returns:
ProActiveDescriptor. The object representation of the XML document
Exceptions:
ProActiveException if a problem occurs during the creation of the object
See also:
org.objectweb.proactive.core.descriptor.data.ProActiveDescriptor

org.objectweb.proactive.core.descriptor.data.VirtualNode

org.objectweb.proactive.core.descriptor.data.VirtualMachine

Definition at line 1552 of file ProActive.java.

static ProActiveDescriptor org.objectweb.proactive.ProActive.getProactiveDescriptor ( String  xmlDescriptorUrl,
VariableContract  variableContract 
) throws ProActiveException [static]

Returns a ProActiveDescriptor that gives an object representation of the XML document located at the given url, and uses the given Variable Contract.

Parameters:
xmlDescriptorUrl The url of the XML document
Returns:
ProActiveDescriptor. The object representation of the XML document
Exceptions:
ProActiveException if a problem occurs during the creation of the object
See also:
org.objectweb.proactive.core.descriptor.data.ProActiveDescriptor

org.objectweb.proactive.core.descriptor.data.VirtualNode

org.objectweb.proactive.core.descriptor.data.VirtualMachine

Definition at line 1568 of file ProActive.java.

static void org.objectweb.proactive.ProActive.registerVirtualNode ( VirtualNode  virtualNode,
String  registrationProtocol,
boolean  replacePreviousBinding 
) throws ProActiveException, AlreadyBoundException [static]

Registers locally the given VirtualNode in a registry such RMIRegistry or JINI Lookup Service or HTTP registry.

The VirtualNode to register must exist on the local runtime. This is done when using XML Deployment Descriptors

Parameters:
virtualNode the VirtualNode to register.
registrationProtocol The protocol used for registration or null in order to use the protocol used to start the jvm. At this time RMI, JINI, HTTP, IBIS are supported. If set to null, the registration protocol will be set to the system property: proactive.communication.protocol
replacePreviousBinding 
Exceptions:
ProActiveException If the VirtualNode with the given name has not been yet activated or does not exist on the local runtime

Definition at line 1683 of file ProActive.java.

References org.objectweb.proactive.core.runtime.ProActiveRuntime.getVirtualNode(), and org.objectweb.proactive.core.runtime.ProActiveRuntime.registerVirtualNode().

static VirtualNode org.objectweb.proactive.ProActive.lookupVirtualNode ( String  url  )  throws ProActiveException [static]

Looks-up a VirtualNode previously registered in a registry(RMI or JINI or HTTP or IBIS) The registry where to look for is fully determined with the protocol included in the url.

Parameters:
url The url where to perform the lookup. The url takes the following form: protocol://machine_name:port/name. Protocol and port can be ommited if respectively RMI and 1099: //machine_name/name
Returns:
VirtualNode The virtualNode returned by the lookup
Exceptions:
ProActiveException If no objects are bound with the given url

Definition at line 1714 of file ProActive.java.

References org.objectweb.proactive.core.runtime.ProActiveRuntime.getVirtualNode().

static void org.objectweb.proactive.ProActive.unregisterVirtualNode ( VirtualNode  virtualNode  )  throws ProActiveException [static]

Unregisters the virtualNode previoulsy registered in a registry such as JINI or RMI.

Calling this method removes the VirtualNode from the local runtime.

Parameters:
virtualNode The VirtualNode to unregister
Exceptions:
ProActiveException if a problem occurs whle unregistering the VirtualNode

Definition at line 1733 of file ProActive.java.

References org.objectweb.proactive.core.descriptor.data.VirtualNodeImpl.getName(), and org.objectweb.proactive.core.runtime.ProActiveRuntime.unregisterVirtualNode().

static Body org.objectweb.proactive.ProActive.getBodyOnThis (  )  [static]

When an active object is created, it is associated with a Body that takes care of all non fonctionnal properties.

Assuming that the active object is only accessed by the different Stub objects, all method calls end-up as Requests sent to this Body. Therefore the only thread calling the method of the active object is the active thread managed by the body. There is an unique mapping between the active thread and the body responsible for it. From any method in the active object the current thread caller of the method is the active thread. When a reified method wants to get a reference to the Body associated to the active object, it can invoke this method. Assuming that the current thread is the active thread, the associated body is returned.

Returns:
the body associated to the active object whose active thread is calling this method.

Definition at line 1763 of file ProActive.java.

static StubObject org.objectweb.proactive.ProActive.getStubOnThis (  )  [static]

Returns a Stub-Proxy couple pointing to the local body associated to the active object whose active thread is calling this method.

Returns:
a Stub-Proxy couple pointing to the local body.
See also:
getBodyOnThis

Definition at line 1773 of file ProActive.java.

static void org.objectweb.proactive.ProActive.migrateTo ( Object  activeObject  )  throws MigrationException [static]

Migrates the active object whose active thread is calling this method to the same location as the active object given in parameter.

This method must be called from an active object using the active thread as the current thread will be used to find which active object is calling the method. The object given as destination must be an active object.

Parameters:
activeObject the active object indicating the destination of the migration.
Exceptions:
MigrationException if the migration fails
See also:
getBodyOnThis

Definition at line 1796 of file ProActive.java.

static void org.objectweb.proactive.ProActive.migrateTo ( String  nodeURL  )  throws MigrationException [static]

Migrates the active object whose active thread is calling this method to the node caracterized by the given url.

This method must be called from an active object using the active thread as the current thread will be used to find which active object is calling the method. The url must be the url of an existing node.

Parameters:
nodeURL the url of an existing where to migrate to.
Exceptions:
MigrationException if the migration fails
See also:
getBodyOnThis

Definition at line 1810 of file ProActive.java.

static void org.objectweb.proactive.ProActive.migrateTo ( Node  node  )  throws MigrationException [static]

Migrates the active object whose active thread is calling this method to the given node.

This method must be called from an active object using the active thread as the current thread will be used to find which active object is calling the method.

Parameters:
node an existing node where to migrate to.
Exceptions:
MigrationException if the migration fails
See also:
getBodyOnThis

Definition at line 1826 of file ProActive.java.

static void org.objectweb.proactive.ProActive.migrateTo ( Body  bodyToMigrate,
Object  activeObject,
boolean  isNFRequest 
) throws MigrationException [static]

Migrates the given body to the same location as the active object given in parameter.

This method can be called from any object and does not perform the migration. Instead it generates a migration request that is sent to the targeted body. The object given as destination must be an active object.

Parameters:
bodyToMigrate the body to migrate.
activeObject the active object indicating the destination of the migration.
isNFRequest a boolean indicating that the request is not functional i.e it does not modify the application's computation
Exceptions:
MigrationException if the migration fails

Definition at line 1849 of file ProActive.java.

static void org.objectweb.proactive.ProActive.migrateTo ( Body  bodyToMigrate,
String  nodeURL,
boolean  isNFRequest 
) throws MigrationException [static]

Migrates the given body to the node caracterized by the given url.

This method can be called from any object and does not perform the migration. Instead it generates a migration request that is sent to the targeted body. The object given as destination must be an active object.

Parameters:
bodyToMigrate the body to migrate.
nodeURL the url of an existing where to migrate to.
isNFRequest a boolean indicating that the request is not functional i.e it does not modify the application's computation
Exceptions:
MigrationException if the migration fails

Definition at line 1866 of file ProActive.java.

static void org.objectweb.proactive.ProActive.migrateTo ( Body  bodyToMigrate,
Node  node,
boolean  isNFRequest 
) throws MigrationException [static]

Migrates the body bodyToMigrate to the given node.

This method can be called from any object and does not perform the migration. Instead it generates a migration request that is sent to the targeted body. The object given as destination must be an active object.

Parameters:
bodyToMigrate the body to migrate.
node an existing node where to migrate to.
isNFRequest a boolean indicating that the request is not functional i.e it does not modify the application's computation
Exceptions:
MigrationException if the migration fails

Definition at line 1881 of file ProActive.java.

static void org.objectweb.proactive.ProActive.migrateTo ( Body  bodyToMigrate,
Node  node,
boolean  isNFRequest,
int  priority 
) throws MigrationException [static]

Migrates the body bodyToMigrate to the given node.

This method can be called from any object and does not perform the migration. Instead it generates a migration request that is sent to the targeted body. The object given as destination must be an active object.

Parameters:
bodyToMigrate the body to migrate.
node an existing node where to migrate to.
isNFRequest a boolean indicating that the request is not functional i.e it does not modify the application's computation
priority the level of priority of the non functional request. Levels are defined in Request interface of ProActive.
Exceptions:
MigrationException if the migration fails

Definition at line 1900 of file ProActive.java.

References org.objectweb.proactive.core.body.request.BodyRequest.send().

static int org.objectweb.proactive.ProActive.waitForAny ( java.util.Vector  futures  )  [static]

Blocks the calling thread until one of the futures in the vector is available.

THIS METHOD MUST BE CALLED FROM AN ACTIVE OBJECT.

Parameters:
futures vector of futures
Returns:
index of the available future in the vector

Definition at line 1927 of file ProActive.java.

static int org.objectweb.proactive.ProActive.waitForAny ( java.util.Vector  futures,
long  timeout 
) throws ProActiveException [static]

Blocks the calling thread until one of the futures in the vector is available or until the timeout expires.

THIS METHOD MUST BE CALLED FROM AN ACTIVE OBJECT.

Parameters:
futures vector of futures
timeout to wait in ms
Returns:
index of the available future in the vector
Exceptions:
ProActiveException if the timeout expires

Definition at line 1946 of file ProActive.java.

static void org.objectweb.proactive.ProActive.waitForAll ( java.util.Vector  futures  )  [static]

Blocks the calling thread until all futures in the vector are available.

THIS METHOD MUST BE CALLED FROM AN ACTIVE OBJECT.

Parameters:
futures vector of futures

Definition at line 1974 of file ProActive.java.

static void org.objectweb.proactive.ProActive.waitForAll ( java.util.Vector  futures,
long  timeout 
) throws ProActiveException [static]

Blocks the calling thread until all futures in the vector are available or until the timeout expires.

THIS METHOD MUST BE CALLED FROM AN ACTIVE OBJECT.

Parameters:
futures vector of futures
timeout to wait in ms
Exceptions:
ProActiveException if the timeout expires

Definition at line 1991 of file ProActive.java.

static void org.objectweb.proactive.ProActive.waitForTheNth ( java.util.Vector  futures,
int  n 
) [static]

Blocks the calling thread until the N-th of the futures in the vector is available.

THIS METHOD MUST BE CALLED FROM AN ACTIVE OBJECT.

Parameters:
futures vector of futures

Definition at line 2023 of file ProActive.java.

static void org.objectweb.proactive.ProActive.waitForTheNth ( java.util.Vector  futures,
int  n,
long  timeout 
) throws ProActiveException [static]

Blocks the calling thread until the N-th of the futures in the vector is available.

THIS METHOD MUST BE CALLED FROM AN ACTIVE OBJECT.

Parameters:
futures vector of futures
n 
timeout to wait in ms
Exceptions:
ProActiveException if the timeout expires

Definition at line 2043 of file ProActive.java.

static boolean org.objectweb.proactive.ProActive.allAwaited ( java.util.Vector  futures  )  [static]

Return false if one object of futures is available.

Parameters:
futures a table with futures.
Returns:
true if all futures are awaited, else false .

Definition at line 2063 of file ProActive.java.

static boolean org.objectweb.proactive.ProActive.isAwaited ( Object  future  )  [static]

Return false if the object future is available.

This method is recursive, i.e. if result of future is a future too, isAwaited is called again on this result, and so on.

Definition at line 2085 of file ProActive.java.

static Object org.objectweb.proactive.ProActive.getFutureValue ( Object  future  )  [static]

Return the object contains by the future (ie its target).

If parameter is not a future, it is returned. A wait-by-necessity occurs if future is not available. This method is recursive, i.e. if result of future is a future too, getFutureValue is called again on this result, and so on.

Definition at line 2112 of file ProActive.java.

static void org.objectweb.proactive.ProActive.terminateActiveObject ( Object  ao,
boolean  immediate 
) [static]

Kill an Active Object while calling terminate() method on its body.

Parameters:
ao the active object to kill
immediate if this boolean is true, this method is served as an immediate service. The active object dies immediatly. Else, the kill request is served as a normal request, it is put on the request queue.

Definition at line 2153 of file ProActive.java.

static void org.objectweb.proactive.ProActive.setImmediateService ( Object  obj,
String  methodName 
) throws java.io.IOException [static]

Set an immediate execution for the target active object obj of the method String, ie request of name methodName will be executed right away upon arrival at the target AO context.

Warning: the execution of an Immediate Service method is achieved in parallel of the current services, so it is the programmer responsibility to ensure that Immediate Services do not interfere with any other methods.

Parameters:
obj the object on which to set this immediate service
methodName the name of the method
Exceptions:
IOException 

Definition at line 2177 of file ProActive.java.

References org.objectweb.proactive.core.body.UniversalBody.setImmediateService().

static void org.objectweb.proactive.ProActive.setImmediateService ( Object  obj,
String  methodName,
Class[]  parametersTypes 
) throws IOException [static]

Set an immediate execution for the target active object obj of the method String, ie request of name methodName will be executed right away upon arrival at the target AO context.

Warning: the execution of an Immediate Service method is achieved in parallel of the current services, so it is the programmer responsibility to ensure that Immediate Services do not interfere with any other methods.

Parameters:
obj the object on which to set this immediate service
methodName the name of the method
parametersTypes the types of the parameters of the method
Exceptions:
IOException 

Definition at line 2195 of file ProActive.java.

References org.objectweb.proactive.core.body.UniversalBody.setImmediateService().

static void org.objectweb.proactive.ProActive.removeImmediateService ( Object  obj,
String  methodName,
Class[]  parametersTypes 
) throws IOException [static]

Removes an immmediate execution for the active object obj, i.e.

requests corresponding to the name and types of parameters will be executed by the calling thread, and not added in the request queue. BE CAREFUL : for the first release of this method, do not make use of getCurrentThreadBody nor getStubOnThis in the method defined by methodName !!

Parameters:
obj the object from which to remove this immediate service
methodName the name of the method
parametersTypes the types of the parameters of the method
Exceptions:
IOException 

Definition at line 2212 of file ProActive.java.

References org.objectweb.proactive.core.body.UniversalBody.removeImmediateService().

static void org.objectweb.proactive.ProActive.exposeAsWebService ( Object  o,
String  url,
String  urn,
String[]  methods 
) [static]

Expose an active object as a web service.

Parameters:
o The object to expose as a web service
url The url of the host where the object will be seployed (typically http://localhost:8080)
urn The name of the object
methods The methods that will be exposed as web services functionnalities

Definition at line 2256 of file ProActive.java.

static void org.objectweb.proactive.ProActive.unExposeAsWebService ( String  urn,
String  url 
) [static]

Delete the service on a web server.

Parameters:
urn The name of the object
url The url of the web server

Definition at line 2266 of file ProActive.java.

static void org.objectweb.proactive.ProActive.exposeComponentAsWebService ( Component  component,
String  url,
String  componentName 
) [static]

Deploy a component as a webservice.

Each interface of the component will be accessible by the urn [componentName]_[interfaceName]in order to identify the component an interface belongs to. All the interfaces public methods will be exposed.

Parameters:
componentName The name of the component
url The web server url where to deploy the service - typically "http://localhost:8080"
component The component owning the interfaces that will be deployed as web services.

Definition at line 2278 of file ProActive.java.

static void org.objectweb.proactive.ProActive.unExposeComponentAsWebService ( String  componentName,
String  url,
Component  component 
) [static]

Undeploy component interfaces on a web server.

Parameters:
componentName The name of the component
url The url of the web server
component The component owning the services interfaces

Definition at line 2289 of file ProActive.java.

static void org.objectweb.proactive.ProActive.tryWithCatch ( Class  c  )  [static]

This has to be called just before a try block for a single exception.

Parameters:
c the caught exception type in the catch block

Definition at line 2389 of file ProActive.java.

static void org.objectweb.proactive.ProActive.tryWithCatch ( Class[]  c  )  [static]

This has to be called just before a try block for many exceptions.

Parameters:
c the caught exception types in the catch block

Definition at line 2398 of file ProActive.java.

static void org.objectweb.proactive.ProActive.addNFEListenerOnJVM ( NFEListener  listener  )  [static]

Add a listener for NFE reaching the local JVM.

Parameters:
listener The listener to add

Definition at line 2438 of file ProActive.java.

static void org.objectweb.proactive.ProActive.removeNFEListenerOnJVM ( NFEListener  listener  )  [static]

Remove a listener for NFE reaching the local JVM.

Parameters:
listener The listener to remove

Definition at line 2447 of file ProActive.java.

static void org.objectweb.proactive.ProActive.addNFEListenerOnAO ( Object  ao,
NFEListener  listener 
) [static]

Add a listener for NFE reaching a given active object.

Parameters:
ao The active object receiving the NFE
listener The listener to add

Definition at line 2457 of file ProActive.java.

References org.objectweb.proactive.core.exceptions.manager.NFEProducer.addNFEListener().

static void org.objectweb.proactive.ProActive.removeNFEListenerOnAO ( Object  ao,
NFEListener  listener 
) [static]

Remove a listener for NFE reaching a given active object.

Parameters:
ao The active object receiving the NFE
listener The listener to remove

Definition at line 2470 of file ProActive.java.

References org.objectweb.proactive.core.exceptions.manager.NFEProducer.removeNFEListener().

static void org.objectweb.proactive.ProActive.addNFEListenerOnProxy ( Object  ao,
NFEListener  listener 
) [static]

Add a listener for NFE reaching the client side of a given active object.

Parameters:
ao The active object receiving the NFE
listener The listener to add

Definition at line 2481 of file ProActive.java.

static void org.objectweb.proactive.ProActive.removeNFEListenerOnProxy ( Object  ao,
NFEListener  listener 
) [static]

Remove a listener for NFE reaching the client side of a given active object.

Parameters:
ao The active object receiving the NFE
listener The listener to remove

Definition at line 2496 of file ProActive.java.

static void org.objectweb.proactive.ProActive.addNFEListenerOnGroup ( Object  group,
NFEListener  listener 
) [static]

Add a listener for NFE regarding a group.

Parameters:
group The group receiving the NFE
listener The listener to add

Definition at line 2527 of file ProActive.java.

References org.objectweb.proactive.core.body.proxy.AbstractProxy.addNFEListener().

static void org.objectweb.proactive.ProActive.removeNFEListenerOnGroup ( Object  group,
NFEListener  listener 
) [static]

Remove a listener for NFE regarding a group.

Parameters:
group The group receiving the NFE
listener The listener to remove

Definition at line 2537 of file ProActive.java.

static Collection org.objectweb.proactive.ProActive.getAllExceptions (  )  [static]

Get the exceptions that have been caught in the current ProActive.tryWithCatch()/ProActive.removeTryWithCatch() block.

This waits for every call in this block to return.

Returns:
a collection of these exceptions

Definition at line 2549 of file ProActive.java.

static Node org.objectweb.proactive.ProActive.getNode (  )  throws NodeException [static]

Returns:
The node of the current active object.

Exceptions:
NodeException problem with the node.

Definition at line 2557 of file ProActive.java.

References org.objectweb.proactive.core.body.proxy.BodyProxy.getBody(), and org.objectweb.proactive.core.body.UniversalBody.getNodeURL().

static String org.objectweb.proactive.ProActive.getProActiveVersion (  )  [static]

Returns the number of this version.

Returns:
String

Definition at line 2592 of file ProActive.java.

The documentation for this class was generated from the following file:
Generated on Mon Jan 22 15:16:13 2007 for ProActive by  doxygen 1.5.1