Uses of Class
org.objectweb.jac.core.Interaction

Packages that use Interaction
org.objectweb.jac.aspects.authentication Provides an aspect to handle authentication in JAC applications.  
org.objectweb.jac.aspects.cache This aspect handle caching of method results.  
org.objectweb.jac.aspects.confirmation Provides an aspect that allows the programmer to define methods that must be confirmed by the user before commiting. 
org.objectweb.jac.aspects.distribution Provides a highly configurable set of aspects to distribute JAC applications.  
org.objectweb.jac.aspects.distribution.consistency Provides a set of wrappers that implement data consistency protocols and that can be installed on objects to make them consistent.  
org.objectweb.jac.aspects.gui Provides a simple and generic GUI (Graphical User Interface) aspect. 
org.objectweb.jac.aspects.i18n   
org.objectweb.jac.aspects.idGen   
org.objectweb.jac.aspects.integrity Provides an aspect to handle data integrity whitin objects sets. 
org.objectweb.jac.aspects.naming Provides an aspect to handle the naming in the JAC system.  
org.objectweb.jac.aspects.persistence Provides a generic persistence aspect for JAC objects.  
org.objectweb.jac.aspects.queue   
org.objectweb.jac.aspects.session Provides an aspect that handles sessions within JAC programs.  
org.objectweb.jac.aspects.synchronization Provides an aspect that handles simple synchronization in a centralized way.  
org.objectweb.jac.aspects.tracing Provides an aspect which allows the users to trace their programs 
org.objectweb.jac.aspects.transaction Provides an aspect that handles transactional operations within JAC programs.  
org.objectweb.jac.aspects.user Provides a users management within an application.  
org.objectweb.jac.core Provides JAC system core classes.  
org.objectweb.jac.core.dist Provides JAC system core classes for distribution and remote communication.  
org.objectweb.jac.wrappers Provides a set of generic wrappers that can be used to program aspect components.  
 

Uses of Interaction in org.objectweb.jac.aspects.authentication
 

Methods in org.objectweb.jac.aspects.authentication with parameters of type Interaction
 Object AuthenticationWrapper.authenticateAndControl(Interaction interaction)
          This wrapping method authenticates a call on the wrapped method and controls that the authentcated user owns the rights to call it.
 

Uses of Interaction in org.objectweb.jac.aspects.cache
 

Methods in org.objectweb.jac.aspects.cache with parameters of type Interaction
 Object CacheWrapper.cache(Interaction interaction)
           
 

Uses of Interaction in org.objectweb.jac.aspects.confirmation
 

Methods in org.objectweb.jac.aspects.confirmation with parameters of type Interaction
 Object ConfirmationAC.ConfirmationWrapper.confirm(Interaction interaction)
          The wrapping method.
 

Uses of Interaction in org.objectweb.jac.aspects.distribution
 

Methods in org.objectweb.jac.aspects.distribution with parameters of type Interaction
 Object LoadBalancingAC.LoadBalancingWrapper.roundTripBalance(Interaction interaction)
          Performs a round-trip load-balancing.
 Object LoadBalancingAC.LoadBalancingWrapper.randomBalance(Interaction interaction)
          Performs a random load-balancing.
 Object DeploymentWrapper.deploy(Interaction i)
          Actually performs the deployment on a constructor interaction.
 Object BroadcastingAC.BroadcastingWrapper.broadcast(Interaction interaction)
          Performs a broadcasting.
 

Uses of Interaction in org.objectweb.jac.aspects.distribution.consistency
 

Methods in org.objectweb.jac.aspects.distribution.consistency with parameters of type Interaction
 Object WeakConsistencyWrapper.whenWrite(Interaction interaction)
          Update the wrappee state with the owner replica state before proceeding the writing method.
 Object ClientServerConsistencyWrapper.whenCall(Interaction interaction)
          Forwards the call to the server(s).
 Object StrongPullConsistencyWrapper.whenRead(Interaction interaction)
          This wrapping method first try to use the wrappee to get the result of the read method.
 Object StrongPushConsistencyWrapper.whenWrite(Interaction interaction)
          Forwards the call to all the replicas and then call the replica.
 Object ConsistencyWrapper.whenCall(Interaction interaction)
          This wrapping method must be defined to implement a given builtin consistency protocol and must wrap the replica methods that need to be consistent with the other replicas.
 Object ConsistencyWrapper.whenWrite(Interaction interaction)
          This wrapping method must be defined to implement a given builtin consistency protocol and must wrap all the replicas methods that provoque a change in this replica state.
 Object ConsistencyWrapper.whenRead(Interaction interaction)
          This wrapping method must be defined to implement a given builtin consistency protocol and must wrap all the replica methods that read the replica state.
 

Uses of Interaction in org.objectweb.jac.aspects.gui
 

Methods in org.objectweb.jac.aspects.gui with parameters of type Interaction
 Object WaitWrapper.pleaseWait(Interaction interaction)
           
 Object InputWrapper.askForParameters(Interaction interaction)
          Calls the Display.showInput method on the current display.
protected  boolean InputWrapper.autoCreate(Display display, DisplayContext context, AbstractMethodItem method, Interaction interaction, Class[] paramTypes)
           
protected  boolean InputWrapper.askingSequence(Display display, DisplayContext context, AbstractMethodItem method, Interaction interaction, Class[] paramTypes)
           
 Object ViewControlWrapper.updateView(Interaction interaction)
          A wrapping method that updates the views of the objects.
 

Uses of Interaction in org.objectweb.jac.aspects.i18n
 

Methods in org.objectweb.jac.aspects.i18n with parameters of type Interaction
 Object I18nAC.TranslatorWrapper.translateParameters(Interaction interaction)
           
 Object I18nAC.TranslatorWrapper.translateReturnedValue(Interaction interaction)
           
 

Uses of Interaction in org.objectweb.jac.aspects.idGen
 

Methods in org.objectweb.jac.aspects.idGen with parameters of type Interaction
 Object IdGenAC.IdGenWrapper.genId(Interaction interaction)
           
 

Uses of Interaction in org.objectweb.jac.aspects.integrity
 

Methods in org.objectweb.jac.aspects.integrity with parameters of type Interaction
 Object PrimaryKeyWrapper.checkDoubles(Interaction interaction)
          This wrapping method checks if the added Object's fields match with an Object in the added collection, and throws an exception if there is one.
 Object ConstraintWrapper.testConditions(Interaction interaction)
          This wrapping method checks if pre and post conditions are validated for modified fields.
 Object RepositoryWrapper.addToRepository(Interaction interaction)
          Adds the object added to field to the repository
 Object RepositoryWrapper.doAddToRepository(Interaction interaction)
          Disables addToRepository
 Object RepositoryWrapper.removeFromRepository(Interaction interaction)
           
 Object RoleWrapper.updateOppositeRole(Interaction interaction)
          Tells the integrity aspect to update the opposite roles of the declared associations.
protected  void RoleWrapper.doUpdate(Interaction interaction)
           
 Object RoleWrapper.initAutoCreatedObject(Interaction interaction)
          Initializes the opposite role of an object auto created on an adder or reference setter if there's an attribute GuiAC.AUTOCREATE_REASON in the context, whose value is an Interaction.
 

Uses of Interaction in org.objectweb.jac.aspects.naming
 

Methods in org.objectweb.jac.aspects.naming with parameters of type Interaction
 Object BindingWrapper.bind(Interaction interaction)
          This wrapping method binds the wrappee.
 void NamingAC.whenUsingNewInstance(Interaction interaction)
          Name a new instance using the nameObject() and generateName() methods.
 

Uses of Interaction in org.objectweb.jac.aspects.persistence
 

Methods in org.objectweb.jac.aspects.persistence with parameters of type Interaction
 Object MapWrapper.containsKey(Interaction interaction)
           
 Object MapWrapper.containsValue(Interaction interaction)
           
 Object MapWrapper.put(Interaction interaction)
           
 Object MapWrapper.get(Interaction interaction)
           
 Object MapWrapper.remove(Interaction interaction)
           
 Object MapWrapper.clear(Interaction interaction)
          Remove all instances from the collection
 Object MapWrapper.iterator(Interaction interaction)
           
 Object SetWrapper.contains(Interaction interaction)
           
 boolean SetWrapper.add(Interaction interaction)
           
 Object SetWrapper.remove(Interaction interaction)
           
 Object SetWrapper.clear(Interaction interaction)
          Remove all instances from the collection
 Object SetWrapper.iterator(Interaction interaction)
           
 Object ListWrapper.contains(Interaction interaction)
           
 Object ListWrapper.add(Interaction interaction)
           
 Object ListWrapper.addAll(Interaction interaction)
           
 Object ListWrapper.get(Interaction interaction)
           
 Object ListWrapper.remove(Interaction interaction)
           
 Object ListWrapper.removeRange(Interaction interaction)
           
 Object ListWrapper.clear(Interaction interaction)
          Remove all instances from the collection
 Object ListWrapper.set(Interaction interaction)
           
 Object ListWrapper.indexOf(Interaction interaction)
           
 Object ListWrapper.lastIndexOf(Interaction interaction)
           
 Object ListWrapper.iterator(Interaction interaction)
           
 Object PersistenceWrapper.handleStatic(Interaction interaction)
          This wrapping method is called on static objects constructors as defined by the pointcut of PersistenceAC.
 Object PersistenceWrapper.applyPersistence(Interaction interaction)
          This wrapping method apply the persistence aspect for a given call on a persistent object.
protected  void PersistenceWrapper.addToCollection(Interaction interaction, OID oid, CollectionItem collection, Object value)
          This method stores the persistent object that is added to the collection into the storage.
protected  void PersistenceWrapper.removeFromCollection(Interaction interaction, OID oid, CollectionItem collection, Object value)
          This method delete the persistent object that is removed from the collection from the storage.
abstract  Object CollectionWrapper.clear(Interaction interaction)
          Remove all instances from the collection
 Object CollectionWrapper.preload(Interaction interaction)
           
 Object CollectionWrapper.size(Interaction interaction)
           
 Object CollectionWrapper.isEmpty(Interaction interaction)
           
abstract  Object CollectionWrapper.iterator(Interaction interaction)
           
 

Uses of Interaction in org.objectweb.jac.aspects.queue
 

Methods in org.objectweb.jac.aspects.queue with parameters of type Interaction
 Object MessageQueueWrapper.fieldChange(Interaction interaction)
           
 

Uses of Interaction in org.objectweb.jac.aspects.session
 

Methods in org.objectweb.jac.aspects.session with parameters of type Interaction
 Object PerSessionObjectWrapper.handlePerSessionObject(Interaction interaction)
          This wrapping method handles an hashtable of copied objects.
 Object SessionWrapper.handleSession(Interaction interaction)
          Handles sessions for the wrapped method.
 

Uses of Interaction in org.objectweb.jac.aspects.synchronization
 

Methods in org.objectweb.jac.aspects.synchronization with parameters of type Interaction
 Object SynchronizationAC.SynchronizationWrapper.synchronize(Interaction interaction)
           
 

Uses of Interaction in org.objectweb.jac.aspects.tracing
 

Methods in org.objectweb.jac.aspects.tracing with parameters of type Interaction
 Object RecordingWrapper.record(Interaction interaction)
           
 Object OptimizedCountingWrapper.incrWithField(Interaction interaction)
          This wrapping method increments the counter with the field when the wrapped method is called.
 Object OptimizedCountingWrapper.incrWithArg(Interaction interaction)
          This wrapping method increments the counter with the argument value when the wrapped method is called.
 Object SimpleCountingWrapper.incr(Interaction interaction)
          This wrapping method increments the counter when the wrapped method is called.
 Object DebuggingWrapper.step(Interaction interaction)
          This wrapping method is used to upcall the debugger at each method call.
 

Uses of Interaction in org.objectweb.jac.aspects.transaction
 

Methods in org.objectweb.jac.aspects.transaction with parameters of type Interaction
 Object TransactionAC.TransactionWrapper.handleTransaction(Interaction interaction)
          This wrapping method wraps a transactional method.
 void TransactionAC.TransactionWrapper.beginOfTransaction(Interaction interaction)
          Initializes the transaction.
 void TransactionAC.TransactionWrapper.endOfTransaction(Interaction interaction)
          Ends the transaction (when success).
 void TransactionAC.TransactionWrapper.catchException(Interaction interaction, Exception e)
          Handles an exception within a transaction (rollback).
 Object DispatchTransactionWrapper.dispatch(Interaction interaction)
          Dispatches a call on a wrappee transaction-clone depending on the current transaction if any (if not, it performs a regular call).
 

Uses of Interaction in org.objectweb.jac.aspects.user
 

Methods in org.objectweb.jac.aspects.user with parameters of type Interaction
 Object UserWrapper.setUserOnNew(Interaction interaction)
          Set the user attribute of new objects
 Object UserWrapper.setUser(Interaction interaction)
          Set user attributes of parameters.
 Object UserAC.OwnerFilterWrapper.filterResult(Interaction interaction)
          Filters the result of a collection's getter to keep only the object that are owned by the currently logged user.
 Object UserAC.FilterWrapper.filterResult(Interaction interaction)
           
 

Uses of Interaction in org.objectweb.jac.core
 

Methods in org.objectweb.jac.core with parameters of type Interaction
 void ACManager.whenUsingNewInstance(Interaction interaction)
          Dispatch this event to all the registered Aspect Components that are woven.
 void AspectComponent.whenUsingNewInstance(Interaction interaction)
          This method is called when a new instance (that has not been wrapped by the aspect component yet) is used by a peer object.
 void BaseProgramListener.whenUsingNewInstance(Interaction interaction)
          This method is upcalled by JAC when a given instance is used for the first time at construction-time.
static Object Wrapping.nextWrapper(Interaction interaction)
          This method factorizes the common code that is used when the next wrapper is called.
static Object Wrapping.methodNextWrapper(Interaction interaction)
           
 

Uses of Interaction in org.objectweb.jac.core.dist
 

Methods in org.objectweb.jac.core.dist with parameters of type Interaction
 Object NonBlockingStubWrapper.invoke(Interaction interaction)
          Forward a call to the remote reference.
 Object StubWrapper._invoke(Interaction interaction)
          Forward a call to the remote reference.
 

Uses of Interaction in org.objectweb.jac.wrappers
 

Methods in org.objectweb.jac.wrappers with parameters of type Interaction
 Object LimiterWrapper.inc(Interaction interaction)
          This wrapping method increments the limiter counter and calls the wrappee method.
 Object LimiterWrapper.dec(Interaction interaction)
          This wrapping method decrements the limiter counter and calls the wrappee method.
 Object LimiterWrapper.testMax(Interaction interaction)
          This wrapping method tests the counter of the limiter and raises the LimiterExeption when when it is over the maximum value.
 Object LimiterWrapper.testMin(Interaction interaction)
          This wrapping method tests the counter of the limiter and raises the LimiterExeption when when it is below the minimum value.
 Object VerboseWrapper.printCallingInfos(Interaction interaction)
          A wrapping method that prints out the calling informations.
 Object VerboseWrapper.printNamedArgs(Interaction interaction)
           
 Object VerboseWrapper.printStackTrace(Interaction interaction)
           
 Object VerboseWrapper.printWrappersTrace(Interaction interaction)
           
 Object ForwardingWrapper.forward(Interaction interaction)
          Forwards all the incoming calls to the forwardee.
 Object CacheWrapper.statelessCache(Interaction interaction)
          This wrapping method seeks in the cache wether the couple (method, args) has already been called on the wrappee object.
 Object CacheWrapper.stateCache(Interaction interaction)
          This wrapping method seeks in the cache wether the triple (wrappe, method, args) has already been called on the wrappee object when wrappee was in the same state.
 Object CacheWrapper.clearCache(Interaction interaction)
          Clear the cache.