Uses of Class
com.vii.brillien.kernel.BrillienException

Packages that use BrillienException
com.vii.brillien.kernel.axiom   
com.vii.brillien.kernel.axiom.atomic   
com.vii.brillien.kernel.axiom.atomic.component   
com.vii.brillien.kernel.axiom.atomic.shaper   
com.vii.brillien.kernel.axiom.atomic.shaper.filters   
com.vii.brillien.kernel.axiom.atomic.shaper.shifters   
com.vii.brillien.kernel.axiom.component   
com.vii.brillien.kernel.axiom.sso   
com.vii.brillien.kernel.axiom.transport   
 

Uses of BrillienException in com.vii.brillien.kernel.axiom
 

Methods in com.vii.brillien.kernel.axiom that throw BrillienException
 void Aspirer.activateCallable()
          Activates the callable activity.
 void Sensor.activateMessaging()
          Makes the object active
 void Progressor.addState(State state)
          Adds a new State into the statemachine
 void Progressor.changeState(State from, State to)
          Induces internal state change.
 Object Sensor.communicationReceived(C message)
          Notification method about an incoming text-based message addressed to this Sensor.
 Object Sensor.errorReceived(C message)
          Special method invoked by Brillien if an error message has been received.
 List<String> Presence.getMessageProcessorParameterNames(String messageProcessorName)
          Retrieves the name of the given messageprocessor if the parameters are annotated with @P
 List<String> Presence.getMessageProcessorParameterTypes(String messageProcessorName)
          Retrieves the formal parameter list's types of the given messageprocessor
 boolean Presence.hasMessageProcessorReturnValue(String messageProcessorName)
          Retrieves whether the messageprocessor with the given name has a return value
 void Aspirer.passivateCallable()
          Passivates the callable activity.
 void Sensor.passivateMessaging()
          Makes the object passive.
 void Aspirer.plan()
          After having all input parameters set, this method is called by the instantiation manager instance to make the Aspirer to activate itself
 void Sensor.presenseChangedState(String entityName, State oldState, State newState)
          Invoked when this entity has been registered as a listener to other entity's state change events
 void Progressor.registerStateChangeNotification(State state, String recipient)
          Any Sensor object can register to a specific state modification
 void Progressor.removeState(State state)
          Removes a State from the statemachine
 void Aspirer.sendAGet(String to, String message, String redirectMessage, Map<String,Object> parameters)
          Sends a get-like message to the given recipient.
 void Aspirer.sendDelegatedSet(String to, String message, String redirectEntityName, String redirectMessage, Map<String,Object> parameters)
          Sends a get-like message to the given recipient.
 void Aspirer.sendError(C c, int errorCode, String message)
          Sends an error message to a previously received message.
 void Aspirer.sendError(C c, int errorCode, String message, Object value)
          Sends an error message to a previously received message.
 void Aspirer.sendError(C c, String message)
          Sends an error message to a previously received message.
 C Aspirer.sendGet(long timeout, String to, String message, Map<String,Object> parameters)
          Sends a get-like message to the given recipient.
 C Aspirer.sendGet(String to, String message, Map<String,Object> parameters)
          Sends a get-like message to the given recipient.
 void Aspirer.sendResponse(C c, Object response)
          Sends a response to a previously received message.
 void Aspirer.sendSet(String to, String message, Map<String,Object> parameters)
          Sends a set-like message to the given recipient.
 void Aspirer.sendUnitAGet(String to, String message, String redirectMessage, Map<String,Object> parameters)
          Sends a unit-wide get-like message to the given recipient.
 void Aspirer.sendUnitDelegatedSet(String to, String message, String redirectEntityName, String redirectMessage, Map<String,Object> parameters)
          Sends a unit-wide get-like message to the given recipient.
 C Aspirer.sendUnitGet(int timeout, String to, String message, Map<String,Object> parameters)
          Sends a unit-wide get-like message to the given recipient.
 C Aspirer.sendUnitGet(String to, String message, Map<String,Object> parameters)
          Sends a unit-wide get-like message to the given recipient.
 void Aspirer.sendUnitSet(String to, String message, Map<String,Object> parameters)
          Sends a unit-wide set-like message to the given recipient.
 void Progressor.unregisterStateChangeNotification(State state, String recipient)
          Any Sensor object can unregister from a specific state altering takes place
 

Uses of BrillienException in com.vii.brillien.kernel.axiom.atomic
 

Methods in com.vii.brillien.kernel.axiom.atomic that return BrillienException
 BrillienException Context.levelException(BrillienException be)
          Transforms the given exception according to the filter-shifter mappings available in this context
 

Methods in com.vii.brillien.kernel.axiom.atomic with parameters of type BrillienException
 Shifter Context.getShifter(BrillienException be)
          Gets the proper Shifter to the given BrillienException instance if exists
 BrillienException Context.levelException(BrillienException be)
          Transforms the given exception according to the filter-shifter mappings available in this context
 

Methods in com.vii.brillien.kernel.axiom.atomic that throw BrillienException
 void Flow.activate(C c, Long timeout)
          Activates the flow instance, making it started.
 void Presence.activateAll()
          Activates all activity of the Presence (messaging, aspiring).
 void PresenceManager.activatePresenceManager()
          Activates the PresenceManager according to the initialized configuration.
 void Unit.activateUnitAll()
          Activates all Presences in this Unit.
 void Unit.activateUnitCallable()
          Activates the callable activity of all Presences in this Unit.
 void Unit.activateUnitMessaging()
          Makes all Presences in this Unit active
 void Unit.addPresences(P... ses)
          Adds new Presences.
 Unit<P,C,R> Unit.addSubUnits(Unit... ses)
          Adds new subunits.
 void Presence.addSuperUnits(Unit... ses)
          Adds new superunits.
 Collection<Unit> Unit.classify(EquivalenceRelation<P,C,R> function)
          Classifies the unit by using an equivalence relation
 void Unit.clearPresences()
          Clears all Presences
 void Unit.clearSubUnits()
          Clears all subunits
 void Presence.clearSuperUnits()
          Clears all subunits
 void Unit.communicationUnitReceived(C message)
          Notification method about an incoming message addressed to this all Sensors of this Unit.
 Unit<P,C,R> Unit.complement(Unit<P,C,R> unit)
          Creates complement set from the actual and the given Unit
 P PresenceManager.getInstance(Presence caller)
          Getter method for a new instance of the Presence type specifying the caller
 P PresenceManager.getInstance(Presence caller, String name)
          Getter method for a new instance of the Presence type specifying the caller
 P PresenceManager.getInstance(String flowID)
          Getter method for a new instance of the Presence type specifying the ID of the flow
 P PresenceManager.getInstance(String flowID, String name)
          Getter method for a new instance of the Presence type specifying the ID of the flow
 void PresenceManager.initPresenceManager(String presenceName, Class<P> PresenceClass)
          Initializes the PresenceManager with the given class instance, reads the annotations of the presence type
 Unit<P,C,R> Unit.intersect(Unit<P,C,R> unit)
          Creates intersect set from the actual and the given Unit
 void Flow.oppress(String message)
          Sets all state of a flow to "Error" state marking it to be terminated.
 Collection<P> Unit.order(OrderRelation<P,C,R> function)
          Orders the presences of the unit by using an order relation
 void Presence.passivateAll()
          Passivates all activity of the Presence (messaging, aspiring).
 void Unit.passivateUnitAll()
          Passivates all Presences in this Unit.
 void Unit.passivateUnitCallable()
          Passivates the callable activity of all Presences in this Unit.
 void Unit.passivateUnitMessaging()
          Makes all Presences in this Unit passive.
<T extends Presence>
String
Commander.registerPresence(Class<T> Presence)
          Registers a Presence.
<T extends Presence>
String
Commander.registerPresence(Class<T> Presence, String cloneName)
          Makes a presence "clone".
 String Commander.registerPresence(String originalName, String cloneName)
          Makes a presence "clone".
 void Unit.removePresences(P... ses)
          Removes Presences.
 Unit<P,C,R> Unit.removeSubUnits(Unit... ses)
          Removes subunits.
 void Presence.removeSuperUnits(Unit... ses)
          Removes superunits.
 void Presence.retrieve()
          Makes this presence to be retrieved by the proper Presencemanager
 void PresenceManager.retrieveReferences(P... presences)
          All Presence instances managed by this PresenceManager will be retrieved
 void Unit.retrieveUnit()
          Makes all presences in this unit to be retrieved by the proper Presencemanagers
 void Flow.revivified()
          Notify the given flow instance about the occured revivfication process.
 void Unit.scrutinise(Presence p)
          Checks if the Presence could became set element
 void Presence.setFlow(Flow flow)
          Sets the flow ID of the Presence.
 void Flow.setStateSpace(HashMap<String,Object> stateSpace)
          This method sets the state space of the flow called when the flow will be reactivated
 Unit<P,C,R> Unit.subset(CharacteristicFunction<P,C,R> function)
          Subset creation from the given Unit
 void Flow.suspend()
          All Indispensable flows can be suspended and resumed.
 Unit<P,C,R> Unit.symmetricDifference(Unit<P,C,R> unit)
          Creates symmetric difference set from the actual and the given Unit
 void Flow.terminate()
          Sets all state of a flow to "Exit" state marking it to be terminated.
 Unit<P,C,R> Unit.union(Unit<P,C,R> unit)
          Creates union set from the actual and the given Unit
 void Commander.unregisterPresence(String PresenceName)
          Unregisters a Presence by its name.
 

Uses of BrillienException in com.vii.brillien.kernel.axiom.atomic.component
 

Methods in com.vii.brillien.kernel.axiom.atomic.component that throw BrillienException
 void CharacteristicFunction.inspect(P f)
          Checks if the Presence could became set element
 

Uses of BrillienException in com.vii.brillien.kernel.axiom.atomic.shaper
 

Methods in com.vii.brillien.kernel.axiom.atomic.shaper that return BrillienException
 BrillienException Shifter.transform(BrillienException be)
          Transforms a BrillienException into T-type exception
 

Methods in com.vii.brillien.kernel.axiom.atomic.shaper with parameters of type BrillienException
 boolean Filter.interestedIn(BrillienException be)
          Tells wether the exception need to be transformed.
 BrillienException Shifter.transform(BrillienException be)
          Transforms a BrillienException into T-type exception
 

Uses of BrillienException in com.vii.brillien.kernel.axiom.atomic.shaper.filters
 

Methods in com.vii.brillien.kernel.axiom.atomic.shaper.filters with parameters of type BrillienException
protected  boolean ErrorCodeFilter.innerInterest(BrillienException be)
           
 boolean TypeFilter.interestedIn(BrillienException be)
           
 boolean OrFilter.interestedIn(BrillienException be)
           
 boolean ErrorCodeFilter.interestedIn(BrillienException be)
           
 boolean AndFilter.interestedIn(BrillienException be)
           
 

Uses of BrillienException in com.vii.brillien.kernel.axiom.atomic.shaper.shifters
 

Methods in com.vii.brillien.kernel.axiom.atomic.shaper.shifters that return BrillienException
 BrillienException MessageShifter.transform(BrillienException be)
           
 

Methods in com.vii.brillien.kernel.axiom.atomic.shaper.shifters with parameters of type BrillienException
 BrillienException MessageShifter.transform(BrillienException be)
           
 

Uses of BrillienException in com.vii.brillien.kernel.axiom.component
 

Methods in com.vii.brillien.kernel.axiom.component that throw BrillienException
 void Validable.checkValidity()
          Checks the validity of a type's instance.
 

Uses of BrillienException in com.vii.brillien.kernel.axiom.sso
 

Methods in com.vii.brillien.kernel.axiom.sso that throw BrillienException
 Session SubjectService.authenticate(String username, String principal)
          Authenticates the user with the given username and principal
 boolean SubjectService.hasAPermission(Session session, List<String> permissions)
          Tells whether the user associated with the given session has a permission from the given collection
 boolean SubjectService.hasARole(Session session, List<String> roleIdentifiers)
          Tells whether the user associated with the given session has a role from the given collection
 boolean SubjectService.hasPermission(Session session, String permission)
          Tells whether the user associated with the given session has the given permission
 boolean SubjectService.hasPermissions(Session session, List<String> permissions)
          Tells whether the user associated with the given session has all the given permissions
 boolean SubjectService.hasRole(Session session, String roleIdentifier)
          Tells whether the user associated with the given session has the given role
 boolean SubjectService.hasRoles(Session session, List<String> roleIdentifiers)
          Tells whether the user associated with the given session has all the given roles
 boolean SubjectService.isAuthenticated(Session session)
          Tells whether the user associated with the given session is authenticated
 void SubjectService.logout(Session session)
          Logs out the user associated with the given session
 

Uses of BrillienException in com.vii.brillien.kernel.axiom.transport
 

Methods in com.vii.brillien.kernel.axiom.transport that throw BrillienException
 Map<String,Object> Communication.acquireParameters(Map<String,Class> types)
           
<T> T
Communication.acquireResponse(Class<T> type)
           
<T> T
Communication.acquireResponse(Class<T> type, Map<String,Class> typeHint)
           
<T> T
Communication.acquireResponse(Class<T> type, String typeHint, Class hintClass)
           
<T> T
Communication.acquireResponse(Map<String,Class> typeHint)
           
<T> T
Communication.acquireResponse(String typeHint, Class hintClass)
           
 void Mediator.connect()
          Sets up the connection with the underlaying transport layer
 void Manager.createAccountFor(M m)
          Creates account by the values of the given Mediator
 void Mediator.disconnect()
          Dismisses the connection with the underlaying transport layer
<M extends MessageProcessor>
Iterable<M>
Mediator.getNewMessageProcessorInstances(C comm)
          Creates an instances of evety registered MessageProcessor type and initiates them with the give Communication
 C Mediator.prepareNewCommunication()
          Factory method to initiate a communication
 C Mediator.prepareNewCommunication(C comm, String sender, String flowID, String recipient, String subject, int type)
          Factory method to initiate a communication
 C Mediator.prepareNewCommunication(C comm, String sender, String flowID, String recipient, String subject, int type, Map<String,Object> parameters)
          Factory method to initiate a communication
 C Mediator.prepareNewCommunication(Session session, C comm, String sender, String flowID, String recipient, String subject, int type)
          Factory method to initiate a communication
 C Mediator.prepareNewCommunication(Session session, C comm, String sender, String flowID, String recipient, String subject, int type, Map<String,Object> parameters)
          Factory method to initiate a communication
 C Mediator.prepareNewCommunication(Session session, String sender, String flowID, String recipient, String subject, int type)
          Factory method to initiate a communication
 C Mediator.prepareNewCommunication(Session session, String sender, String flowID, String recipient, String subject, int type, Map<String,Object> parameters)
          Factory method to initiate a communication
 C Mediator.prepareNewCommunication(String sender, String flowID, String recipient, String subject, int type)
          Factory method to initiate a communication
 C Mediator.prepareNewCommunication(String sender, String flowID, String recipient, String subject, int type, Map<String,Object> parameters)
          Factory method to initiate a communication
 void Mediator.receiveCommunication(C comm)
          Special entry point allowing to put insider messages into the Mediator
 void CommunicationListener.received(T t)
           
 void Mediator.sendAGet(Session session, String to, String message, String redirectMessage)
          Sends a get-like message to the given recipient.
 void Mediator.sendAGet(Session session, String to, String message, String redirectMessage, Map<String,Object> parameters)
          Sends a get-like message to the given recipient.
 C Mediator.sendCommunication(C comm)
          Sends a message.
 C Mediator.sendCommunication(HashMap<String,Object> properties, C comm)
          Sends a message.
 C Mediator.sendCommunication(long timeout, C comm)
          Sends a packet.
 C Mediator.sendCommunication(long timeout, HashMap<String,Object> properties, C comm)
          Sends a packet.
 void Mediator.sendDelegatedGet(Session session, String to, String message, String redirectEntityName, String redirectMessage)
          Sends a get-like message to the given recipient.
 void Mediator.sendDelegatedGet(Session session, String to, String message, String redirectEntityName, String redirectMessage, Map<String,Object> parameters)
          Sends a get-like message to the given recipient.
 C Mediator.sendGet(Session session, long timeout, String to, String message)
          Sends a get-like message to the given recipient.
 C Mediator.sendGet(Session session, long timeout, String to, String message, Map<String,Object> parameters)
          Sends a get-like message to the given recipient.
 C Mediator.sendGet(Session session, String to, String message)
          Sends a get-like message to the given recipient.
 C Mediator.sendGet(Session session, String to, String message, Map<String,Object> parameters)
          Sends a get-like message to the given recipient.
 void Mediator.sendSet(Session session, String to, String message)
          Sends a set-like message to the given recipient.
 void Mediator.sendSet(Session session, String to, String message, Map<String,Object> parameters)
          Sends a set-like message to the given recipient.
 void Mediator.startListening()
          Initiates the internal listening process of the given Mediator to start accept incoming packets
 



Copyright © 2012. All Rights Reserved.