public DetachManager(BrokerImpl broker,
    boolean full,
    OpCallbacks call) 
{
        _broker = broker;
        _proxy = broker.getConfiguration().getProxyManagerInstance();
        _opts = broker.getConfiguration().getDetachStateInstance();
        _copy = !full;
        _flushed = full;
        _call = call;
        _failFast = (broker.getConfiguration().getMetaDataRepositoryInstance().
            getMetaDataFactory().getDefaults().getCallbackMode()
            & CallbackModes.CALLBACK_FAIL_FAST) != 0;
        // we can only rely on our "all" shortcuts if we know we won't be
        // loading any more data
        _full = full && broker.getDetachState() == DetachState.DETACH_LOADED;
        if (_full) {
            _detached = null;
            _fullFM = new DetachFieldManager();
        } else {
            _detached = new IdentityMap();
            _fullFM = null;
        }
        _flushBeforeDetach =
                broker.getConfiguration().getCompatibilityInstance()
                        .getFlushBeforeDetach();
}

Constructor.

Parameters:

broker - owning broker

full - whether the entire broker cache is being detached; if this is the case, we assume the broker has already flushed if needed, and that we're detaching in-place

 public Object detach(Object toDetach) 
{
        List exceps = null;
        try {
            return detachInternal(toDetach);
        } catch (CallbackException ce) {
            exceps = new ArrayList(1);
            exceps.add(ce);
            return null; // won't be reached as exception will be rethrown
        } finally {
            if (exceps == null || !_failFast)
                exceps = invokeAfterDetach(Collections.singleton(toDetach),
                    exceps);
            if (_detached != null)
                _detached.clear();
            throwExceptions(exceps);
        }
}

Return a detached version of the given instance.

 public Object[] detachAll(Collection instances) 
{
        List exceps = null;
        List detached = null;
        if (_copy)
            detached = new ArrayList(instances.size());
        boolean failFast = false;
        try {
            Object detach;
            for (Iterator itr = instances.iterator(); itr.hasNext();) {
                detach = detachInternal(itr.next());
                if (_copy)
                    detached.add(detach);
            }
        }
        catch (RuntimeException re) {
            if (re instanceof CallbackException && _failFast)
                failFast = true;
            exceps = add(exceps, re);
        } finally {
            if (!failFast)
                exceps = invokeAfterDetach(instances, exceps);
            if (_detached != null)
                _detached.clear();
        }
        throwExceptions(exceps);
        if (_copy)
            return detached.toArray();
        return null;
}

Return detached versions of all the given instances. If not copying, null will be returned.

 static boolean preSerialize(StateManagerImpl sm) 
{
                     
        if (!sm.isPersistent())
            return false;
        if (sm.getBroker().getConfiguration().getCompatibilityInstance()
                .getFlushBeforeDetach()) {
            flushDirty(sm);
        }
        ClassMetaData meta = sm.getMetaData();
        boolean setState = meta.getDetachedState() != null
            && !ClassMetaData.SYNTHETIC.equals(meta.getDetachedState());
        BitSet idxs = (setState) ? new BitSet(meta.getFields().length) : null;
        preDetach(sm.getBroker(), sm, idxs);
        if (setState) {
            sm.getPersistenceCapable().pcSetDetachedState(getDetachedState
                (sm, idxs));
            return false; // don't null state
        }
        return true;
}

Used to prepare a detachable instance that does not externalize detached state.

 static boolean writeDetachedState(StateManagerImpl sm,
    ObjectOutput out,
    BitSet idxs) throws IOException 
{
        if (!sm.isPersistent()) {
            out.writeObject(null); // state
            out.writeObject(null); // sm
            return false;
        }
        // dirty state causes flush
        flushDirty(sm);
        Broker broker = sm.getBroker();
        preDetach(broker, sm, idxs);
        // write detached state object and state manager
        DetachOptions opts = broker.getConfiguration().
            getDetachStateInstance();
        if (!opts.getDetachedStateManager()
            || !useDetachedStateManager(sm, opts)) {
            out.writeObject(getDetachedState(sm, idxs));
            out.writeObject(null);
            return false;
        }
        out.writeObject(null);
        out.writeObject(new DetachedStateManager(sm.getPersistenceCapable(),
            sm, idxs, opts.getAccessUnloaded(), broker.getMultithreaded()));
        return true;
}

Used by classes that externalize detached state.