Uses of Interface
com.sun.jini.outrigger.TransactableMgr

Packages that use TransactableMgr
com.sun.jini.outrigger This is an implementation of a JavaSpaces technology-enabled service. 
 

Uses of TransactableMgr in com.sun.jini.outrigger
 

Classes in com.sun.jini.outrigger that implement TransactableMgr
(package private)  class Txn
          This class represents a space's state in a single transaction.
 

Fields in com.sun.jini.outrigger declared as TransactableMgr
private  TransactableMgr EntryHolder.SimpleRepEnum.mgr
           
private  TransactableMgr[] TxnState.rslt
          Used by mgr()
private  TransactableMgr EntryTransition.txn
          If this is a transition to visibility and/or availability, what transaction the entry is now available/visible to.
private  TransactableMgr EntryHolder.ContinuingQuery.txn
          Transaction (if any) being used for the query
 

Methods in com.sun.jini.outrigger that return TransactableMgr
(package private)  TransactableMgr EntryTransition.getTxn()
          If this is a transition to visibility and/or availability, what transaction the entry is now available/visible to.
private  TransactableMgr TxnState.mgr()
          Returns the one manager associated with this transaction.
 

Methods in com.sun.jini.outrigger with parameters of type TransactableMgr
 void TakeIfExistsWatcher.abort(TransactableMgr mgr, OutriggerServerImpl space)
          If a transaction ends in the middle of a query we want to throw an exception to the client making the query (not the Txn calling us here.)
 void TakeMultipleWatcher.abort(TransactableMgr mgr, OutriggerServerImpl space)
          If a transaction ends in the middle of a query we want to throw an exception to the client making the query (not the Txn calling us here.)
 void TransactableAvailabilityWatcher.abort(TransactableMgr mgr, OutriggerServerImpl space)
          Just need to terminate this registration.
 void TransactableEventWatcher.abort(TransactableMgr mgr, OutriggerServerImpl space)
          Just need to terminate this registration.
 void Transactable.abort(TransactableMgr mgr, OutriggerServerImpl space)
          Abort this object's part of the transaction.
 void EntryHandle.abort(TransactableMgr mgr, OutriggerServerImpl space)
           
 void ConsumingWatcher.abort(TransactableMgr mgr, OutriggerServerImpl space)
          If a transaction ends in the middle of a query we want to throw an exception to the client making the query (not the Txn calling us here.)
 void TransactableReadIfExistsWatcher.abort(TransactableMgr mgr, OutriggerServerImpl space)
          If a transaction ends in the middle of a query we want to throw an exception to the client making the query (not the Txn calling us here.)
(package private)  boolean TxnState.abort(TransactableMgr mgr, OutriggerServerImpl space, EntryHandle owner)
          Abort this object's part of the transaction.
(package private)  void EntryHolder.add(EntryHandle handle, TransactableMgr txn)
          Add new new entry to the holder.
(package private)  void TxnState.add(TransactableMgr mgr, int op)
          Add mgr to the list of known managers, setting the state of this handle to op.
(package private)  void EntryHandle.add(TransactableMgr mgr, int op, EntryHolder holder)
          Add mgr to the list of known managers, setting the the type of lock on this entry to op.
(package private)  boolean EntryHolder.attemptCapture(EntryHandle handle, TransactableMgr txn, boolean takeIt, Set conflictSet, Set lockedEntrySet, WeakHashMap provisionallyRemovedEntrySet, long now)
          Atomically check to see if the passed entry can be read/taken by the specified operation using the specified transaction and if it can read/take it and return true, otherwise return false.
(package private)  boolean OutriggerServerImpl.attemptCapture(EntryHandle handle, TransactableMgr txn, boolean takeIt, Set lockedEntrySet, WeakHashMap provisionallyRemovedEntrySet, long now, QueryWatcher watcher)
          Atomically check to see if the passed entry can be read/taken by the specified operation using the specified transaction and if it can read/take it and return true, otherwise return false.
(package private)  boolean TxnState.canPerform(TransactableMgr mgr, int op)
          Returns true if the operation op under the transaction manager by mgr is legal on the associated entry given the operations already performed on the entry under other transactions.
(package private)  boolean EntryHandle.canPerform(TransactableMgr mgr, int op)
          Return true if the operation op under the given transaction (represented by the transaction's manager) can be performed on the object represented by this handle.
 void TakeIfExistsWatcher.commit(TransactableMgr mgr, OutriggerServerImpl space)
          This should never happen since we always return NOTCHANGED from prepare.
 void TakeMultipleWatcher.commit(TransactableMgr mgr, OutriggerServerImpl space)
          This should never happen since we always return NOTCHANGED from prepare.
 void TransactableAvailabilityWatcher.commit(TransactableMgr mgr, OutriggerServerImpl space)
          This should never happen since we always return NOTCHANGED from prepare.
 void TransactableEventWatcher.commit(TransactableMgr mgr, OutriggerServerImpl space)
          This should never happen since we always return NOTCHANGED from prepare.
 void Transactable.commit(TransactableMgr mgr, OutriggerServerImpl space)
          Commit this object's part of the transaction.
 void EntryHandle.commit(TransactableMgr mgr, OutriggerServerImpl space)
           
 void ConsumingWatcher.commit(TransactableMgr mgr, OutriggerServerImpl space)
          This should never happen since we always return NOTCHANGED from prepare.
 void TransactableReadIfExistsWatcher.commit(TransactableMgr mgr, OutriggerServerImpl space)
          This should never happen since we always return NOTCHANGED from prepare.
(package private)  boolean TxnState.commit(TransactableMgr mgr, OutriggerServerImpl space, EntryHandle owner)
          Commit this object's part of the transaction.
private  boolean EntryHolder.confirmAvailability(EntryRep rep, EntryHandle handle, TransactableMgr txn, boolean takeIt, long time, Set conflictSet, Set lockedEntrySet, WeakHashMap provisionallyRemovedEntrySet)
          With the EntryRep rep passed in, verify that the entry hasn't been taken by someone else, hasn't expired, etc.
private  boolean EntryHolder.confirmAvailabilityWithTxn(EntryRep rep, EntryHandle handle, TransactableMgr txnMgr, boolean takeIt, long time, Set conflictSet, Set lockedEntrySet, WeakHashMap provisionallyRemovedEntrySet)
           
(package private)  RepEnum EntryHolder.contents(TransactableMgr mgr)
          Return an enumerator over the contents of this space that are visible from the given mgr.
(package private)  EntryHolder.ContinuingQuery EntryHolder.continuingQuery(EntryRep[] tmpls, TransactableMgr txn, boolean takeThem, long now)
          Return an object that can be used to perform a query that can return multiple matches and be restarted in another thread.
private  boolean EntryHolder.grab(EntryHandle handle, TransactableMgr txn, int op, boolean takeIt, boolean recovery)
          Given an entry that we want to return as the result of a query and we have confirmed we can return it, make the results of the query visible to the rest of the service.
(package private)  EntryHandle EntryHolder.hasMatch(EntryRep tmpl, TransactableMgr txn, boolean takeIt, Set conflictSet, Set lockedEntrySet, WeakHashMap provisionallyRemovedEntrySet)
          Return an EntryHandle object that matches the given template, or null if none does.
(package private)  boolean TxnState.knownMgr(TransactableMgr mgr)
          Return true if mgr is one of the managers known to be managing this entry.
(package private)  boolean EntryHandle.knownMgr(TransactableMgr mgr)
          Return true if the given transaction is already known to the entry this handle represents.
private  void TxnState.monitor(TransactableMgr mgr)
          If we need to, add this manager to the list of transactions that need to be monitored because of conflicts over this entry.
(package private)  boolean TxnState.onlyMgr(TransactableMgr mgr)
          Return true if the given manager is the only one we know about.
(package private)  boolean EntryHandle.onlyMgr(TransactableMgr mgr)
          Return true if we are being managed the given manager is the only one we know about.
 int TakeIfExistsWatcher.prepare(TransactableMgr mgr, OutriggerServerImpl space)
          If a transaction ends in the middle of a query we want to throw an exception to the client making the query not the Txn calling us here.)
 int TakeMultipleWatcher.prepare(TransactableMgr mgr, OutriggerServerImpl space)
          If a transaction ends in the middle of a query we want to throw an exception to the client making the query (not to the Txn calling us here.)
 int TransactableAvailabilityWatcher.prepare(TransactableMgr mgr, OutriggerServerImpl space)
          Just need to terminate this registration and return NOTCHANGED.
 int TransactableEventWatcher.prepare(TransactableMgr mgr, OutriggerServerImpl space)
          Just need to terminate this registration and return NOTCHANGED.
 int Transactable.prepare(TransactableMgr mgr, OutriggerServerImpl space)
          Prepare to commit this object's part of the transaction.
 int EntryHandle.prepare(TransactableMgr mgr, OutriggerServerImpl space)
          Methods required by the Transactable interface
 int ConsumingWatcher.prepare(TransactableMgr mgr, OutriggerServerImpl space)
          If a transaction ends in the middle of a query we want to throw an exception to the client making the query not the Txn calling us here.)
 int TransactableReadIfExistsWatcher.prepare(TransactableMgr mgr, OutriggerServerImpl space)
          If a transaction ends in the middle of a query we want to throw an exception to the client making the query not the Txn calling us here.)
(package private)  int TxnState.prepare(TransactableMgr mgr, OutriggerServerImpl space, EntryHandle owner)
          Prepare to commit this object's part of the transaction.
private  int TxnState.removeMgr(TransactableMgr mgr)
          Remove the given mgr from the list of known managers.
 

Constructors in com.sun.jini.outrigger with parameters of type TransactableMgr
EntryHandle(EntryRep rep, TransactableMgr mgr, EntryHolder holder)
          Create a new handle, calculating the hash for the object.
EntryHolder.ContinuingQuery(EntryRep[] tmpls, TransactableMgr txn, boolean takeThem, long now)
          Create a new ContinuingQuery object.
EntryHolder.SimpleRepEnum(TransactableMgr mgr)
           
EntryTransition(EntryHandle handle, TransactableMgr txn, boolean available, boolean visible, boolean newEntry)
          Create a new EntryTransition object with the specified content.
TxnState(TransactableMgr mgr, int state, EntryHolder holder)
          Create a new TxnState.
 



Copyright 2007-2010, multiple authors.
Licensed under the Apache License, Version 2.0, see the NOTICE file for attributions.