Java Code Examples for org.omg.PortableServer.Servant

/** Given any Tie, return the corresponding object refernce, activating
 * the Servant if necessary.
 */
public static org.omg.CORBA.Object activateTie( Tie tie )
{
    /** Any implementation of Tie should be either a Servant or an ObjectImpl,
     * depending on which style of code generation is used.  rmic -iiop by
     * default results in an ObjectImpl-based Tie, while rmic -iiop -poa
     * results in a Servant-based Tie.  Dynamic RMI-IIOP also uses Servant-based
     * Ties (see impl.presentation.rmi.ReflectiveTie).
     */
    if (tie instanceof ObjectImpl) {
        return tie.thisObject() ;
    } else if (tie instanceof Servant) {
        Servant servant = (Servant)tie ;
        return activateServant( servant ) ;
    } else {
        throw wrapper.badActivateTieCall() ;
    }
}
 

/**
 * <code>set_servant</code>
 * <b>Section 3.3.8.13</b>
 */
public void set_servant(Servant defaultServant)
    throws WrongPolicy
{
    try {
        lock() ;

        if (debug) {
            ORBUtility.dprint( this, "Calling set_servant on poa " +
                this + " defaultServant=" + defaultServant ) ;
        }

        mediator.setDefaultServant( defaultServant ) ;
    } finally {
        unlock() ;
    }
}
 

/**
 * <code>servant_to_reference</code>
 * <b>3.3.8.20</b>
 */
public org.omg.CORBA.Object servant_to_reference(Servant servant)
    throws ServantNotActive, WrongPolicy
{
    try {
        lock() ;

        if (debug) {
            ORBUtility.dprint( this,
                "Calling servant_to_reference(servant=" +
                servant + ") on poa " + this ) ;
        }

        byte[] oid = mediator.servantToId(servant);
        String repId = servant._all_interfaces( this, oid )[0] ;
        return create_reference_with_id(oid, repId);
    } finally {
        unlock() ;
    }
}
 

/**
 * <code>reference_to_servant</code>
 * <b>3.3.8.21</b>
 */
public Servant reference_to_servant(org.omg.CORBA.Object reference)
    throws ObjectNotActive, WrongPolicy, WrongAdapter
{
    try {
        lock() ;

        if (debug) {
            ORBUtility.dprint( this,
                "Calling reference_to_servant(reference=" +
                reference + ") on poa " + this ) ;
        }

        if ( state >= STATE_DESTROYING ) {
            throw lifecycleWrapper().adapterDestroyed() ;
        }

        // reference_to_id should throw WrongAdapter
        // if the objref was not created by this POA
        byte [] id = internalReferenceToId(reference);

        return mediator.idToServant( id ) ;
    } finally {
        unlock() ;
    }
}
 

/**
 * <code>id_to_reference</code>
 * <b>3.3.8.24</b>
 */
public org.omg.CORBA.Object id_to_reference(byte[] id)
    throws ObjectNotActive, WrongPolicy

{
    try {
        lock() ;

        if (debug) {
            ORBUtility.dprint( this, "Calling id_to_reference(id=" +
                id + ") on poa " + this ) ;
        }

        if( state >= STATE_DESTROYING ) {
            throw lifecycleWrapper().adapterDestroyed() ;
        }

        Servant s = mediator.idToServant( id ) ;
        String repId = s._all_interfaces( this, id )[0] ;
        return makeObject(repId, id );
    } finally {
        unlock() ;
    }
}
 

protected void activateServant( ActiveObjectMap.Key key, AOMEntry entry, Servant servant )
{
    setDelegate(servant, key.id );

    if (orb.shutdownDebugFlag) {
        System.out.println("Activating object " + servant +
            " with POA " + poa);
    }

    activeObjectMap.putServant( servant, entry ) ;

    if (Util.isInstanceDefined()) {
        POAManagerImpl pm = (POAManagerImpl)poa.the_POAManager() ;
        POAFactory factory = pm.getFactory() ;
        factory.registerPOAForServant(poa, servant);
    }
}
 

/** Use implicit activation to get an object reference for the servant.
 */
public static org.omg.CORBA.Object activateServant( Servant servant )
{
    POA poa = servant._default_POA() ;
    org.omg.CORBA.Object ref = null ;

    try {
        ref = poa.servant_to_reference( servant ) ;
    } catch (ServantNotActive sna) {
        throw wrapper.getDelegateServantNotActive( sna ) ;
    } catch (WrongPolicy wp) {
        throw wrapper.getDelegateWrongPolicy( wp ) ;
    }

    // Make sure that the POAManager is activated if no other
    // POAManager state management has taken place.
    POAManager mgr = poa.the_POAManager() ;
    if (mgr instanceof POAManagerImpl) {
        POAManagerImpl mgrImpl = (POAManagerImpl)mgr ;
        mgrImpl.implicitActivation() ;
    }

    return ref ;
}
 

/** Given any Tie, return the corresponding object refernce, activating
 * the Servant if necessary.
 */
public static org.omg.CORBA.Object activateTie( Tie tie )
{
    /** Any implementation of Tie should be either a Servant or an ObjectImpl,
     * depending on which style of code generation is used.  rmic -iiop by
     * default results in an ObjectImpl-based Tie, while rmic -iiop -poa
     * results in a Servant-based Tie.  Dynamic RMI-IIOP also uses Servant-based
     * Ties (see impl.presentation.rmi.ReflectiveTie).
     */
    if (tie instanceof ObjectImpl) {
        return tie.thisObject() ;
    } else if (tie instanceof Servant) {
        Servant servant = (Servant)tie ;
        return activateServant( servant ) ;
    } else {
        throw wrapper.badActivateTieCall() ;
    }
}
 

/**
 * <code>servant_to_reference</code>
 * <b>3.3.8.20</b>
 */
public org.omg.CORBA.Object servant_to_reference(Servant servant)
    throws ServantNotActive, WrongPolicy
{
    try {
        lock() ;

        if (debug) {
            ORBUtility.dprint( this,
                "Calling servant_to_reference(servant=" +
                servant + ") on poa " + this ) ;
        }

        byte[] oid = mediator.servantToId(servant);
        String repId = servant._all_interfaces( this, oid )[0] ;
        return create_reference_with_id(oid, repId);
    } finally {
        unlock() ;
    }
}
 

/**
 * <code>reference_to_servant</code>
 * <b>3.3.8.21</b>
 */
public Servant reference_to_servant(org.omg.CORBA.Object reference)
    throws ObjectNotActive, WrongPolicy, WrongAdapter
{
    try {
        lock() ;

        if (debug) {
            ORBUtility.dprint( this,
                "Calling reference_to_servant(reference=" +
                reference + ") on poa " + this ) ;
        }

        if ( state >= STATE_DESTROYING ) {
            throw lifecycleWrapper().adapterDestroyed() ;
        }

        // reference_to_id should throw WrongAdapter
        // if the objref was not created by this POA
        byte [] id = internalReferenceToId(reference);

        return mediator.idToServant( id ) ;
    } finally {
        unlock() ;
    }
}
 

protected void deactivateHelper( ActiveObjectMap.Key key, AOMEntry entry,
    Servant s ) throws ObjectNotActive, WrongPolicy
{
    // Default does nothing, but the USE_SERVANT_MANAGER case
    // must handle etherealization

    activeObjectMap.remove(key);

    if (Util.isInstanceDefined()) {
        POAManagerImpl pm = (POAManagerImpl)poa.the_POAManager() ;
        POAFactory factory = pm.getFactory() ;
        factory.unregisterPOAForServant(poa, s);
    }
}
 

protected Servant internalKeyToServant( ActiveObjectMap.Key key )
{
    AOMEntry entry = activeObjectMap.get(key);
    if (entry == null)
        return null ;

    return activeObjectMap.getServant( entry ) ;
}
 

public Servant preinvoke(byte[] oid, POA adapter, String operation,
                         CookieHolder cookie) throws ForwardRequest
{

    String objKey = new String(oid);

    Servant servant = (Servant) contexts.get(objKey);

    if (servant == null)
    {
             servant =  readInContext(objKey);
    }

    return servant;
}
 

public Servant idToServant( byte[] id )
    throws WrongPolicy, ObjectNotActive
{
    if (defaultServant != null)
        return defaultServant;

    throw new ObjectNotActive() ;
}
 

/**
 * <code>activate_object</code>
 * <b>Section 3.3.8.14</b>
 */
public byte[] activate_object(Servant servant)
    throws ServantAlreadyActive, WrongPolicy
{
    try {
        lock() ;

        if (debug) {
            ORBUtility.dprint( this,
                "Calling activate_object on poa " + this +
                " (servant=" + servant + ")" ) ;
        }

        // Allocate a new system-generated object-id.
        // This will throw WrongPolicy if not SYSTEM_ID
        // policy.
        byte[] id = mediator.newSystemId();

        try {
            mediator.activateObject( id, servant ) ;
        } catch (ObjectAlreadyActive oaa) {
            // This exception can not occur in this case,
            // since id is always brand new.
            //
        }

        return id ;
    } finally {
        if (debug) {
            ORBUtility.dprint( this,
                "Exiting activate_object on poa " + this ) ;
        }

        unlock() ;
    }
}
 

/**
 * <code>activate_object_with_id</code>
 * <b>Section 3.3.8.15</b>
 */
public void activate_object_with_id(byte[] id,
                                                 Servant servant)
    throws ObjectAlreadyActive, ServantAlreadyActive, WrongPolicy
{
    try {
        lock() ;

        if (debug) {
            ORBUtility.dprint( this,
                "Calling activate_object_with_id on poa " + this +
                " (servant=" + servant + " id=" + id + ")" ) ;
        }

        // Clone the id to avoid possible errors due to aliasing
        // (e.g. the client passes the id in and then changes it later).
        byte[] idClone = (byte[])(id.clone()) ;

        mediator.activateObject( idClone, servant ) ;
    } finally {
        if (debug) {
            ORBUtility.dprint( this,
                "Exiting activate_object_with_id on poa " + this ) ;
        }

        unlock() ;
    }
}
 

public final void remove( Key key )
{
    AOMEntry entry = (AOMEntry)keyToEntry.remove( key ) ;
    Servant servant = (Servant)entryToServant.remove( entry ) ;
    if (servant != null)
        servantToEntry.remove( servant ) ;

    removeEntry( entry, key ) ;
}
 

Servant getServant()
{
    Servant servant = (Servant)(peekThrowInternal().getServantContainer());
    // If is OK for the servant to be null.
    // This could happen if POAImpl.getServant is called but
    // POAImpl.internalGetServant throws an exception.
    return servant;
}
 

public final void remove( Key key )
{
    AOMEntry entry = (AOMEntry)keyToEntry.remove( key ) ;
    Servant servant = (Servant)entryToServant.remove( entry ) ;
    if (servant != null)
        servantToEntry.remove( servant ) ;

    removeEntry( entry, key ) ;
}
 

protected java.lang.Object internalGetServant( byte[] id,
    String operation ) throws ForwardRequest
{
    Servant servant = internalIdToServant( id ) ;
    if (servant == null)
        servant = defaultServant ;

    if (servant == null)
        throw poa.invocationWrapper().poaNoDefaultServant() ;

    return servant ;
}
 

public Servant idToServant( byte[] id )
    throws WrongPolicy, ObjectNotActive
{
    Servant s = internalIdToServant( id ) ;

    if (s == null)
        throw new ObjectNotActive() ;
    else
        return s;
}
 

public Servant idToServant( byte[] id )
    throws WrongPolicy, ObjectNotActive
{
    ActiveObjectMap.Key key = new ActiveObjectMap.Key( id ) ;
    Servant s = internalKeyToServant(key);

    if (s == null)
        if (defaultServant != null)
            s = defaultServant;

    if (s == null)
        throw new ObjectNotActive() ;

    return s;
}
 

public void deactivateHelper( ActiveObjectMap.Key key, AOMEntry entry,
    Servant servant ) throws ObjectNotActive, WrongPolicy
{
    if (activator == null)
        throw poa.invocationWrapper().poaNoServantManager() ;

    Etherealizer eth = new Etherealizer( this, key, entry, servant, poa.getDebug() ) ;
    entry.startEtherealize( eth ) ;
}
 

public Servant idToServant( byte[] id )
    throws WrongPolicy, ObjectNotActive
{
    Servant s = internalIdToServant( id ) ;

    if (s == null)
        throw new ObjectNotActive() ;
    else
        return s;
}
 

protected Servant internalKeyToServant( ActiveObjectMap.Key key )
{
    AOMEntry entry = activeObjectMap.get(key);
    if (entry == null)
        return null ;

    return activeObjectMap.getServant( entry ) ;
}
 

public final void activateObject(byte[] id, Servant servant)
    throws WrongPolicy, ServantAlreadyActive, ObjectAlreadyActive
{
    if (isUnique && activeObjectMap.contains(servant))
        throw new ServantAlreadyActive();
    ActiveObjectMap.Key key = new ActiveObjectMap.Key( id ) ;

    AOMEntry entry = activeObjectMap.get( key ) ;

    // Check for an ObjectAlreadyActive error
    entry.activateObject() ;
    activateServant( key, entry, servant ) ;
}
 

public Servant deactivateObject( ActiveObjectMap.Key key )
    throws ObjectNotActive, WrongPolicy
{
    if (orb.poaDebugFlag) {
        ORBUtility.dprint( this,
            "Calling deactivateObject for key " + key ) ;
    }

    try {
        AOMEntry entry = activeObjectMap.get(key);
        if (entry == null)
            throw new ObjectNotActive();

        Servant s = activeObjectMap.getServant( entry ) ;
        if (s == null)
            throw new ObjectNotActive();

        if (orb.poaDebugFlag) {
            System.out.println("Deactivating object " + s + " with POA " + poa);
        }

        deactivateHelper( key, entry, s ) ;

        return s ;
    } finally {
        if (orb.poaDebugFlag) {
            ORBUtility.dprint( this,
                "Exiting deactivateObject" ) ;
        }
    }
}
 

public Etherealizer( POAPolicyMediatorImpl_R_USM mediator,
    ActiveObjectMap.Key key, AOMEntry entry, Servant servant,
    boolean debug )
{
    this.mediator = mediator ;
    this.key = key ;
    this.entry = entry;
    this.servant = servant;
    this.debug = debug ;
}
 

public Servant idToServant( byte[] id )
    throws WrongPolicy, ObjectNotActive
{
    ActiveObjectMap.Key key = new ActiveObjectMap.Key( id ) ;
    Servant s = internalKeyToServant(key);

    if (s == null)
        if (defaultServant != null)
            s = defaultServant;

    if (s == null)
        throw new ObjectNotActive() ;

    return s;
}
 

public Servant idToServant( byte[] id )
    throws WrongPolicy, ObjectNotActive
{
    ActiveObjectMap.Key key = new ActiveObjectMap.Key( id ) ;
    AOMEntry entry = activeObjectMap.get(key);

    Servant servant = activeObjectMap.getServant( entry ) ;
    if (servant != null)
        return servant ;
    else
        throw new ObjectNotActive() ;
}
 

Servant getServant()
{
    Servant servant = (Servant)(peekThrowInternal().getServantContainer());
    // If is OK for the servant to be null.
    // This could happen if POAImpl.getServant is called but
    // POAImpl.internalGetServant throws an exception.
    return servant;
}
 

public Servant idToServant( byte[] id )
    throws WrongPolicy, ObjectNotActive
{
    ActiveObjectMap.Key key = new ActiveObjectMap.Key( id ) ;
    AOMEntry entry = activeObjectMap.get(key);

    Servant servant = activeObjectMap.getServant( entry ) ;
    if (servant != null)
        return servant ;
    else
        throw new ObjectNotActive() ;
}
 

/**
 * Returns true if the servant is the given RepositoryId, false if it is
 * not.
 */
public boolean target_is_a (String id) {
    checkAccess( MID_TARGET_IS_A );

    boolean result = false ;
    if( servant instanceof Servant ) {
        result = ((Servant)servant)._is_a( id );
    } else if (StubAdapter.isStub( servant )) {
        result = ((org.omg.CORBA.Object)servant)._is_a( id );
    } else {
        throw wrapper.servantInvalid() ;
    }

    return result;
}
 

public Servant deactivateObject( ActiveObjectMap.Key key )
    throws ObjectNotActive, WrongPolicy
{
    if (orb.poaDebugFlag) {
        ORBUtility.dprint( this,
            "Calling deactivateObject for key " + key ) ;
    }

    try {
        AOMEntry entry = activeObjectMap.get(key);
        if (entry == null)
            throw new ObjectNotActive();

        Servant s = activeObjectMap.getServant( entry ) ;
        if (s == null)
            throw new ObjectNotActive();

        if (orb.poaDebugFlag) {
            System.out.println("Deactivating object " + s + " with POA " + poa);
        }

        deactivateHelper( key, entry, s ) ;

        return s ;
    } finally {
        if (orb.poaDebugFlag) {
            ORBUtility.dprint( this,
                "Exiting deactivateObject" ) ;
        }
    }
}
 

public Servant preinvoke(byte[] oid, POA adapter, String operation,
                         CookieHolder cookie) throws ForwardRequest
{

    String objKey = new String(oid);

    Servant servant = (Servant) contexts.get(objKey);

    if (servant == null)
    {
             servant =  readInContext(objKey);
    }

    return servant;
}
 

public Servant idToServant( byte[] id )
    throws WrongPolicy, ObjectNotActive
{
    if (defaultServant != null)
        return defaultServant;

    throw new ObjectNotActive() ;
}
 

/**
 * <code>get_servant</code>
 * <b>Section 3.3.8.12</b>
 */
public Servant get_servant() throws NoServant, WrongPolicy
{
    try {
        lock() ;

        return mediator.getDefaultServant() ;
    } finally {
        unlock() ;
    }
}
 

public void returnServant()
{
    OAInvocationInfo info = orb.peekInvocationInfo();
    if (locator == null)
        return;

    try {
        poa.unlock() ;
        locator.postinvoke(info.id(), (POA)(info.oa()),
            info.getOperation(), info.getCookieHolder().value,
            (Servant)(info.getServantContainer()) );
    } finally {
        poa.lock() ;
    }
}
 

/**
 * <code>activate_object_with_id</code>
 * <b>Section 3.3.8.15</b>
 */
public void activate_object_with_id(byte[] id,
                                                 Servant servant)
    throws ObjectAlreadyActive, ServantAlreadyActive, WrongPolicy
{
    try {
        lock() ;

        if (debug) {
            ORBUtility.dprint( this,
                "Calling activate_object_with_id on poa " + this +
                " (servant=" + servant + " id=" + id + ")" ) ;
        }

        // Clone the id to avoid possible errors due to aliasing
        // (e.g. the client passes the id in and then changes it later).
        byte[] idClone = (byte[])(id.clone()) ;

        mediator.activateObject( idClone, servant ) ;
    } finally {
        if (debug) {
            ORBUtility.dprint( this,
                "Exiting activate_object_with_id on poa " + this ) ;
        }

        unlock() ;
    }
}
 

public Servant getDefaultServant() throws NoServant, WrongPolicy
{
    throw new WrongPolicy();
}
 

public void setDefaultServant( Servant servant ) throws WrongPolicy
{
    throw new WrongPolicy();
}
 

protected Servant internalIdToServant( byte[] id )
{
    ActiveObjectMap.Key key = new ActiveObjectMap.Key( id ) ;
    return internalKeyToServant( key ) ;
}
 

/**
* Implements resolving names in this NamingContext. The first component
* of the supplied name is resolved in this NamingContext by calling
* Resolve(). If there are no more components in the name, the
* resulting object reference is returned. Otherwise, the resulting object
* reference must have been bound as a context and be narrowable to
* a NamingContext. If this is the case, the remaining
* components of the name is resolved in the resulting NamingContext.
* This method is static for maximal reuse - even for extended naming
* context implementations where the recursive semantics still apply.
* @param impl an implementation of NamingContextDataStore
* @param n a sequence of NameComponents which is the name to be resolved.
* @return the object reference bound under the supplied name.
* @exception org.omg.CosNaming.NamingContextPackage.NotFound A name with
* multiple components was supplied, but the first component could not be
* resolved.
* @exception org.omg.CosNaming.NamingContextPackage.CannotProceed Could not
* proceed
* in resolving the first component of the supplied name.
* @exception org.omg.CosNaming.NamingContextPackage.InvalidName The supplied
* name is invalid (i.e., has length less than 1).
* @exception org.omg.CORBA.SystemException One of a fixed set of CORBA system
* exceptions.
* @see resolve
*/
 public static org.omg.CORBA.Object doResolve(NamingContextDataStore impl,
                                              NameComponent[] n)
     throws org.omg.CosNaming.NamingContextPackage.NotFound,
            org.omg.CosNaming.NamingContextPackage.CannotProceed,
            org.omg.CosNaming.NamingContextPackage.InvalidName
 {
     org.omg.CORBA.Object obj = null;
     BindingTypeHolder bth = new BindingTypeHolder();


     // Length must be greater than 0
     if (n.length < 1)
         throw new InvalidName();

     // The identifier must be set
     if (n.length == 1) {
         synchronized (impl) {
             // Resolve first level in this context
             obj = impl.Resolve(n[0],bth);
         }
         if (obj == null) {
             // Object was not found
             throw new NotFound(NotFoundReason.missing_node,n);
         }
         return obj;
     } else {
         // n.length > 1
         if ( (n[1].id.length() == 0) && (n[1].kind.length() == 0) ) {
             throw new InvalidName();
         }

         NamingContext context = resolveFirstAsContext(impl,n);

         // Compute restOfName = name[1..length]
         NameComponent[] tail = new NameComponent[n.length -1];
         System.arraycopy(n,1,tail,0,n.length-1);

         // Resolve rest of name in context
         try {
             // First try to resolve using the local call, this should work
             // most of the time unless there are federated naming contexts.
             Servant servant = impl.getNSPOA().reference_to_servant(
                 context );
             return doResolve(((NamingContextDataStore)servant), tail) ;
         } catch( Exception e ) {
             return context.resolve(tail);
         }
     }
 }
 

public void postinvoke(byte[] oid, POA adapter, String operation,
                       java.lang.Object cookie, Servant servant)
{
    // nada
}
 

public void etherealizeAll()
{
    if (activator != null)  {
        Set keySet = activeObjectMap.keySet() ;

        // Copy the elements in the set to an array to avoid
        // changes in the set due to concurrent modification
        ActiveObjectMap.Key[] keys =
            (ActiveObjectMap.Key[])keySet.toArray(
                new ActiveObjectMap.Key[ keySet.size() ] ) ;

        for (int ctr=0; ctr<keySet.size(); ctr++) {
            ActiveObjectMap.Key key = keys[ctr] ;
            AOMEntry entry = activeObjectMap.get( key ) ;
            Servant servant = activeObjectMap.getServant( entry ) ;
            if (servant != null) {
                boolean remainingActivations =
                    activeObjectMap.hasMultipleIDs(entry) ;

                // Here we etherealize in the thread that called this
                // method, rather than etherealizing in a new thread
                // as in the deactivate case.  We still inform the
                // entry state machine so that only one thread at a
                // time can call the etherealize method.
                entry.startEtherealize( null ) ;
                try {
                    poa.unlock() ;
                    try {
                        activator.etherealize(key.id, poa, servant, true,
                            remainingActivations);
                    } catch (Exception exc) {
                        // ignore all exceptions
                    }
                } finally {
                    poa.lock() ;
                    entry.etherealizeComplete() ;
                }
            }
        }
    }
}
 

public void setDefaultServant( Servant servant ) throws WrongPolicy
{
    this.defaultServant = servant;
    setDelegate(defaultServant, "DefaultServant".getBytes());
}
 

public final void activateObject(byte[] id, Servant servant)
    throws WrongPolicy, ServantAlreadyActive, ObjectAlreadyActive
{
    throw new WrongPolicy();
}
 

public Servant deactivateObject( byte[] id ) throws ObjectNotActive, WrongPolicy
{
    throw new WrongPolicy();
}
 

public byte[] servantToId( Servant servant ) throws ServantNotActive, WrongPolicy
{
    throw new WrongPolicy();
}
 

public String[] getInterfaces( java.lang.Object servant, byte[] objectId )
{
    Servant serv = (Servant)servant ;
    return serv._all_interfaces( this, objectId ) ;
}
 

public Servant deactivateObject( byte[] id ) throws ObjectNotActive, WrongPolicy
{
    throw new WrongPolicy();
}
 

public String[] getInterfaces( java.lang.Object servant, byte[] objectId )
{
    Servant serv = (Servant)servant ;
    return serv._all_interfaces( this, objectId ) ;
}
 

void activateObject( byte[] id, Servant servant )
throws ObjectAlreadyActive, ServantAlreadyActive, WrongPolicy ;
 

void setServant(Servant servant)
{
    peekThrowInternal().setServant( servant );
}
 

public final boolean contains(Servant value)
{
    return servantToEntry.containsKey( value ) ;
}
 

void activateObject( byte[] id, Servant servant )
throws ObjectAlreadyActive, ServantAlreadyActive, WrongPolicy ;
 

public final void putServant( Servant servant, AOMEntry value )
{
    entryToServant.put( value, servant ) ;
    servantToEntry.put( servant, value ) ;
}
 

public final boolean contains(Servant value)
{
    return servantToEntry.containsKey( value ) ;
}
 

public final void putServant( Servant servant, AOMEntry value )
{
    entryToServant.put( value, servant ) ;
    servantToEntry.put( servant, value ) ;
}
 

protected Servant internalIdToServant( byte[] id )
{
    ActiveObjectMap.Key key = new ActiveObjectMap.Key( id ) ;
    return internalKeyToServant( key ) ;
}