Examples of org.apache.cayenne.Persistent

org.apache.cayenne.Persistent
Defines minimal API of an object that can be persisted via Cayenne. @since 1.2

            while (it.hasNext()) {
                Map.Entry entry = (Map.Entry) it.next();


                ObjectId id = (ObjectId) entry.getKey();


                Persistent object = (Persistent) objectStore.getNode(id);


                // address manual id override.
                ObjectId objectId = object.getObjectId();
                if (!id.equals(objectId)) {


                    if (objectId != null) {
                        Map replacement = id.getReplacementIdMap();
                        replacement.clear();
                        replacement.putAll(objectId.getIdSnapshot());
                    }


                    object.setObjectId(id);
                }
            }
        }
    }

View Full Code Here


        Map modified = null;
        Object eventPostedBy = null;


        for (int i = 0; i < size; i++) {
            Persistent object = (Persistent) objects.get(i);


            // skip HOLLOW objects as they likely were created from partial snapshots
            if (object.getPersistenceState() == PersistenceState.HOLLOW) {
                continue;
            }


            ObjectId oid = object.getObjectId();


            // add snapshots if refresh is forced, or if a snapshot is
            // missing


            DataRow cachedSnapshot = (DataRow) this.snapshots.get(oid);
            if (refresh || cachedSnapshot == null) {


                DataRow newSnapshot = (DataRow) snapshots.get(i);


                if (cachedSnapshot != null) {
                    // use old snapshot if no changes occurred
                    if (object instanceof DataObject
                            && cachedSnapshot.equals(newSnapshot)) {
                        ((DataObject) object).setSnapshotVersion(cachedSnapshot
                                .getVersion());
                        continue;
                    }
                    else {
                        newSnapshot.setReplacesVersion(cachedSnapshot.getVersion());
                    }
                }


                if (modified == null) {
                    modified = new HashMap();
                    eventPostedBy = object.getObjectContext().getGraphManager();
                }


                modified.put(oid, newSnapshot);
            }
        }

View Full Code Here

        // guess target collection size
        Collection objects = new ArrayList(len > 100 ? len / 2 : len);


        Iterator it = getObjectStore().getObjectIterator();
        while (it.hasNext()) {
            Persistent object = (Persistent) it.next();
            int state = object.getPersistenceState();
            if (state == PersistenceState.MODIFIED
                    || state == PersistenceState.NEW
                    || state == PersistenceState.DELETED) {


                objects.add(object);

View Full Code Here

        // objects where fetched as a part of the same query, as they may belong to
        // different subclasses
        ClassDescriptor descriptor = getEntityResolver().getClassDescriptor(
                id.getEntityName());


        Persistent cachedObject = (Persistent) getGraphManager().getNode(id);


        // merge into an existing object
        if (cachedObject != null) {


            int state = cachedObject.getPersistenceState();


            // TODO: Andrus, 1/24/2006 implement smart merge for modified objects...
            if (cachedObject != prototype
                    && state != PersistenceState.MODIFIED
                    && state != PersistenceState.DELETED) {


                descriptor.injectValueHolders(cachedObject);


                if (prototype != null
                        && prototype.getPersistenceState() != PersistenceState.HOLLOW) {


                    descriptor.shallowMerge(prototype, cachedObject);


                    if (state == PersistenceState.HOLLOW) {
                        cachedObject.setPersistenceState(PersistenceState.COMMITTED);
                    }
                }
            }


            return cachedObject;
        }
        // create and merge into a new object
        else {


            Persistent localObject = (Persistent) descriptor.createObject();


            localObject.setObjectContext(this);
            localObject.setObjectId(id);


            getGraphManager().registerNode(id, localObject);


            if (prototype != null
                    && prototype.getPersistenceState() != PersistenceState.HOLLOW) {
                localObject.setPersistenceState(PersistenceState.COMMITTED);
                descriptor.injectValueHolders(localObject);
                descriptor.shallowMerge(prototype, localObject);
            }
            else {
                localObject.setPersistenceState(PersistenceState.HOLLOW);
            }


            return localObject;
        }
    }

View Full Code Here

                Iterator it = addedToUnresolved.iterator();
                while (it.hasNext()) {
                    Object next = it.next();


                    if (next instanceof Persistent) {
                        Persistent dataObject = (Persistent) next;
                        if (dataObject.getPersistenceState() == PersistenceState.TRANSIENT) {
                            continue;
                        }
                    }


                    if (!fetchedList.contains(next)) {

View Full Code Here


        // No point in adding a new or transient object -- these will never be fetched
        // from the database.
        boolean shouldAddToRemovedFromUnresolvedList = true;
        if (object instanceof Persistent) {
            Persistent dataObject = (Persistent) object;
            if ((dataObject.getPersistenceState() == PersistenceState.TRANSIENT)
                    || (dataObject.getPersistenceState() == PersistenceState.NEW)) {
                shouldAddToRemovedFromUnresolvedList = false;
            }
        }


        if (shouldAddToRemovedFromUnresolvedList) {

View Full Code Here


        ObjectDiff objectDiff = changes.get(nodeId);


        if (objectDiff == null) {


            Persistent object = objectMap.get(nodeId);
            if (object.getPersistenceState() == PersistenceState.COMMITTED) {
                object.setPersistenceState(PersistenceState.MODIFIED);


                // TODO: andrus 3/23/2006 snapshot versions are obsolete, but there is no
                // replacement yet, so we still need to handle them...
                if (object instanceof DataObject) {

View Full Code Here


        Collection<ObjectId> ids = new ArrayList<ObjectId>(objects.size());


        Iterator it = objects.iterator();
        while (it.hasNext()) {
            Persistent object = (Persistent) it.next();


            ObjectId id = object.getObjectId();


            // remove object but not snapshot
            objectMap.remove(id);
            changes.remove(id);
            ids.add(id);


            object.setObjectContext(null);
            object.setObjectId(null);
            object.setPersistenceState(PersistenceState.TRANSIENT);
        }


        // TODO, andrus 3/28/2006 - DRC is null in nested contexts... implement
        // propagation of unregister operation through the stack ... or do the opposite
        // and keep unregister local even for non-nested DC?

View Full Code Here

    public synchronized void objectsRolledBack() {
        Iterator it = getObjectIterator();


        // collect candidates
        while (it.hasNext()) {
            Persistent object = (Persistent) it.next();
            int objectState = object.getPersistenceState();
            switch (objectState) {
                case PersistenceState.NEW:
                    it.remove();


                    object.setObjectContext(null);
                    object.setObjectId(null);
                    object.setPersistenceState(PersistenceState.TRANSIENT);
                    break;
                case PersistenceState.DELETED:
                    // Do the same as for modified... deleted is only a persistence state,
                    // so
                    // rolling the object back will set the state to committed
                case PersistenceState.MODIFIED:
                    // this will clean any modifications and defer refresh from snapshot
                    // till the next object accessor is called
                    object.setPersistenceState(PersistenceState.HOLLOW);
                    break;
                default:
                    // Transient, committed and hollow need no handling
                    break;
            }

View Full Code Here

     */
    void postprocessAfterPhantomCommit() {


        for (Object id : changes.keySet()) {


            Persistent object = objectMap.get(id);


            // assume that no new or deleted objects are present (as otherwise commit
            // wouldn't have been phantom).
            object.setPersistenceState(PersistenceState.COMMITTED);
        }


        // clear caches
        this.changes.clear();
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.cayenne.Persistent

org.apache.cayenne.access.ChildDiffLoader

org.apache.cayenne.access.ClientServerChannelQueryAction

org.apache.cayenne.access.DataContext

org.apache.cayenne.access.DataContextDeleteAction

org.apache.cayenne.access.DataContextExtrasTest

org.apache.cayenne.access.DataContextFlushEventHandler

org.apache.cayenne.access.DataContextMergeHandler

org.apache.cayenne.access.DataContextObjectTrackingTest

org.apache.cayenne.access.DataContextQueryAction

org.apache.cayenne.access.DataDomainDeleteBucket

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.