Package org.castor.persist

Examples of org.castor.persist.ProposedEntity


            for (int j = 0; j < v.size(); j++) {
                if (!newSetOfIds.contains(v.get(j))) {
                    // load all the dependent object in cache for
                    // modification
                    // check at commit time.
                    ProposedEntity proposedValue = new ProposedEntity(fieldClassMolder);
                    tx.load((Identity) v.get(j), proposedValue, suggestedAccessMode);
                }
            }
        }
    }
View Full Code Here


                Class collectionType = _fieldMolder.getCollectionType();
                if (collectionType.isArray()) {
                    Object[] value = (Object[]) java.lang.reflect.Array
                            .newInstance(collectionType.getComponentType(), v.size());
                    for (int j = 0; j < v.size(); j++) {
                        ProposedEntity proposedValue = new ProposedEntity(fieldClassMolder);
                        value[j] = tx.load((Identity) v.get(j), proposedValue, suggestedAccessMode);
                    }
                    _fieldMolder.setValue(proposedObject.getEntity(), value, tx
                            .getClassLoader());
                } else {
                    CollectionProxy cp = CollectionProxy.create(_fieldMolder,
                            proposedObject.getEntity(), tx.getClassLoader());
                    for (int j = 0; j < v.size(); j++) {
                        ProposedEntity proposedValue = new ProposedEntity(fieldClassMolder);
                        cp.add((Identity) v.get(j), tx.load((Identity) v.get(j),
                                proposedValue, suggestedAccessMode));
                    }
                    cp.close();
                }
View Full Code Here

                // integrity problem here, if user forgot to create
                // "value" explicitly. We autoload the value for him.
                if ((value != null) && !tx.isRecorded(value)) {
                    Identity fieldValue = fieldClassMolder.getIdentity(tx, value);
                    if (fieldValue != null) {
                        ProposedEntity temp = new ProposedEntity(fieldClassMolder);
                        tx.load(fieldValue, temp, null);
                        _fieldMolder.setValue(object, temp.getEntity(), tx.getClassLoader());
                    } else {
                        throw new PersistenceException(
                            "Object, " + object + ", links to another object, " + value
                            + " that is not loaded/updated/created in this transaction");
                    }
View Full Code Here

            }

            // load the cached dependent object from the data store.
            // The loaded will be compared with the new one
            if (nfield != null) {
                ProposedEntity proposedValue = new ProposedEntity(fieldClassMolder);
                tx.load(nfield, proposedValue, suggestedAccessMode);
            }
        } else if (tx.isAutoStore()) {
            if ((o != null) && !tx.isRecorded(o)) {
                tx.markUpdate(fieldClassMolder, o, null);
            }

            if (nfield != null) {
                ProposedEntity proposedValue = new ProposedEntity(fieldClassMolder);
                tx.load(nfield, proposedValue, suggestedAccessMode);
            }
        }
    }
View Full Code Here

                // should I use lazy loading for this object?
                if (_fieldMolder.isLazy()) {
                    temp = SingleProxy.getProxy(tx, fieldClassMolder, fieldValue, null,
                            suggestedAccessMode);
                } else {
                    ProposedEntity proposedTemp = new ProposedEntity(fieldClassMolder);
                    temp = tx.load(fieldValue, proposedTemp, suggestedAccessMode);
                }
            } catch (ObjectNotFoundException ex) {
                temp = null;
            }
View Full Code Here

            while (removedItor.hasNext()) {
                // must be loaded thur transaction, so that the related object
                // is properly locked and updated before we delete it.
                Identity identity = (Identity) removedItor.next();
                if (!tx.isDeletedByOID(new OID(fieldClassMolder, identity))) {
                    ProposedEntity proposedValue = new ProposedEntity(fieldClassMolder);
                    Object reldel = tx.load(identity, proposedValue, null);
                    if (reldel != null && tx.isPersistent(reldel)) {
                        tx.writeLock(reldel, tx.getLockTimeout());

                        _fieldMolder.getRelationLoader().deleteRelation(
View Full Code Here

                for (int j = 0; j < v.size(); j++) {
                    if (!newSetOfIds.contains(v.get(j))) {
                        // load all the dependent object in cache for
                        // modification
                        // check at commit time.
                        ProposedEntity proposedValue = new ProposedEntity(fieldClassMolder);
                        tx.load((Identity) v.get(j), proposedValue, suggestedAccessMode);
                    }
                }
            }
        }
View Full Code Here

        if (_scope == null) {
            throw new PersistenceException(Messages.message("jdo.dbClosed"));
        }
        TransactionContext tx = getTransaction();
        ClassMolder molder = _scope.getClassMolder(type);
        ProposedEntity proposedObject = new ProposedEntity(molder);
        return tx.load(new Identity(identity), proposedObject, mode);
    }
View Full Code Here

            loadObject = newInstance(tx.getClassLoader());
        } catch (Exception ex) {
            throw new PersistenceException("failed to load object", ex);
        }

        ProposedEntity proposedObject = new ProposedEntity(this);
        proposedObject.setProposedEntityClass(loadObject.getClass());
        proposedObject.setEntity(loadObject);
       
        OID oid = locker.getOID();
       
        Object[] cachedFieldValues = locker.getObject(tx);
        proposedObject.setFields(cachedFieldValues);
       
        AccessMode accessMode = getAccessMode(suggestedAccessMode);

        // load the fields from the persistent storage if the cache is empty
        // or the access mode is DBLOCKED (thus guaranteeing that a lock at the
        // database level will be created)
        if (!proposedObject.isFieldsSet() || accessMode == AccessMode.DbLocked) {
            proposedObject.initializeFields(_fhs.length);

            Connection conn = tx.getConnection(oid.getMolder().getLockEngine());
            _persistence.load(conn, proposedObject, oid.getIdentity(), accessMode);

            oid.setDbLock(accessMode == AccessMode.DbLocked);
           
            // store (new) field values to cache
            locker.setObject(tx, proposedObject.getFields(), System.currentTimeMillis());
        }

        mold(tx, locker, proposedObject, suggestedAccessMode);
    }
View Full Code Here

        if (_persistence == null) {
            throw new PersistenceException("non persistence capable: "
                    + oid.getName());
        }

        ProposedEntity entity = new ProposedEntity();
        entity.initializeFields(_fhs.length);
        Identity ids = oid.getIdentity();

        // set the new timeStamp into the data object
        long timeStamp = System.currentTimeMillis();
        if (object instanceof TimeStampable) {
            ((TimeStampable) object).jdoSetTimeStamp(timeStamp);
        }

        // copy the object to cache should make a new field now,
        for (int i = 0; i < _fhs.length; i++) {
            fieldType = _fhs[i].getFieldType();

            switch (fieldType) {
            case FieldMolder.PRIMITIVE:
            case FieldMolder.PERSISTANCECAPABLE:
            case FieldMolder.SERIALIZABLE:
            case FieldMolder.ONE_TO_MANY:
            case FieldMolder.MANY_TO_MANY:
                entity.setField(_resolvers[i].create(tx, object), i);
                break;

            default:
                throw new IllegalArgumentException("Field type invalid!");
            }
        }
       
        // ask Persistent to create the object into the persistence storage
        Identity createdId = _persistence.create(tx.getDatabase(),
                tx.getConnection(oid.getMolder().getLockEngine()), entity, ids);

        if (createdId == null) {
            throw new PersistenceException("Identity can't be created!");
        }

        // set the field values into the cache
        locker.setObject(tx, entity.getFields(), timeStamp);
        oid.setDbLock(true);

        // set the identity into the object
        setIdentity(tx, object, createdId);

        // after successful creation, add the entry in the relation table for
        // all many-to-many relationship
        for (int i = 0; i < _fhs.length; i++) {
            entity.setField(_resolvers[i].postCreate(
                    tx, oid, object, entity.getField(i), createdId), i);
        }

        return createdId;
    }
View Full Code Here

TOP

Related Classes of org.castor.persist.ProposedEntity

Copyright © 2018 www.massapicom. All rights reserved.
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.