Package org.jpox.metadata

Examples of org.jpox.metadata.AbstractMemberMetaData


        Integer fieldKey = new Integer(fieldNumber);
        if (!fieldChanges.containsKey(fieldKey))
        {
            // Store the original value only - only good for PC fields really
            AbstractClassMetaData cmd = ownerSM.getClassMetaData();
            AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
            int relationType = mmd.getRelationType(ownerSM.getObjectManager().getClassLoaderResolver());
            if (relationType == Relation.ONE_TO_ONE_BI || relationType == Relation.MANY_TO_ONE_BI)
            {
                // Only allow for set of PC field (ignore set of Collection fields)
                fieldChanges.put(fieldKey, oldValue);
            }
View Full Code Here


        {
            return;
        }

        AbstractClassMetaData cmd = ownerSM.getClassMetaData();
        AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
        int relationType = mmd.getRelationType(ownerSM.getObjectManager().getClassLoaderResolver());
        if (relationType != Relation.ONE_TO_MANY_BI && relationType != Relation.MANY_TO_MANY_BI)
        {
            return;
        }
View Full Code Here

        {
            return;
        }

        AbstractClassMetaData cmd = ownerSM.getClassMetaData();
        AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
        int relationType = mmd.getRelationType(ownerSM.getObjectManager().getClassLoaderResolver());
        if (relationType != Relation.ONE_TO_MANY_BI && relationType != Relation.MANY_TO_MANY_BI)
        {
            return;
        }
View Full Code Here

        ObjectManager om = ownerSM.getObjectManager();
        while (iter.hasNext())
        {
            Map.Entry entry = (Map.Entry)iter.next();
            int fieldNumber = ((Integer)entry.getKey()).intValue();
            AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
            ClassLoaderResolver clr = om.getClassLoaderResolver();
            Object oldValue = entry.getValue();
            int relationType = mmd.getRelationType(clr);
            if (relationType == Relation.ONE_TO_ONE_BI)
            {
                // 1-1 bidirectional
                Object newValue = ownerSM.provideField(fieldNumber);
                checkOneToOneBidirectionalRelation(mmd, clr, om, oldValue, newValue);
View Full Code Here

        ObjectManager om = ownerSM.getObjectManager();
        while (iter.hasNext())
        {
            Map.Entry entry = (Map.Entry)iter.next();
            int fieldNumber = ((Integer)entry.getKey()).intValue();
            AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
            ClassLoaderResolver clr = om.getClassLoaderResolver();
            Object oldValue = entry.getValue();
            int relationType = mmd.getRelationType(clr);
            if (relationType == Relation.ONE_TO_ONE_BI)
            {
                // 1-1 bidirectional
                Object newValue = ownerSM.provideField(fieldNumber);
                processOneToOneBidirectionalRelation(mmd, clr, om, oldValue, newValue);
View Full Code Here

    {
        if (newValue != null)
        {
            // Previously had "a.b = b1"; Now have "a.b = b2"
            // Check that the new value hasnt been assigned to something other than this object
            AbstractMemberMetaData relatedMmd = mmd.getRelatedMemberMetaDataForObject(clr, pc, newValue);
            org.jpox.StateManager newSM = om.findStateManager(newValue);
            if (newSM != null && relatedMmd != null)
            {
                newSM.loadField(relatedMmd.getAbsoluteFieldNumber());
                Object newValueFieldValue = newSM.provideField(relatedMmd.getAbsoluteFieldNumber());
                if (newValueFieldValue != pc)
                {
                    RelationshipManager newRelMgr = newSM.getRelationshipManager();
                    if (newRelMgr != null && newRelMgr.managesField(relatedMmd.getAbsoluteFieldNumber()))
                    {
                        // New value has had its side of the relation changed to a different value altogether!
                        if (newValueFieldValue == null)
                        {
                            String msg = LOCALISER.msg("013003",
                                StringUtils.toJVMIDString(pc), mmd.getName(),
                                StringUtils.toJVMIDString(newValue), relatedMmd.getName());
                            JPOXLogger.PERSISTENCE.error(msg);
                            throw new JPOXUserException(msg);
                        }
                        else
                        {
                            String msg = LOCALISER.msg("013002",
                                StringUtils.toJVMIDString(pc), mmd.getName(),
                                StringUtils.toJVMIDString(newValue), relatedMmd.getName(),
                                StringUtils.toJVMIDString(newValueFieldValue));
                            JPOXLogger.PERSISTENCE.error(msg);
                            throw new JPOXUserException(msg);
                        }
                    }
View Full Code Here

                    throw new JPOXUserException(LOCALISER.msg("013008",
                        StringUtils.toJVMIDString(pc), mmd.getName(), StringUtils.toJVMIDString(change.value)));
                }
                else
                {
                    AbstractMemberMetaData relatedMmd = mmd.getRelatedMemberMetaData(clr)[0];
                    org.jpox.StateManager newElementSM = om.findStateManager(change.value);
                    if (newElementSM != null)
                    {
                        newElementSM.loadField(relatedMmd.getAbsoluteFieldNumber());
                        RelationshipManager newElementRelMgr = newElementSM.getRelationshipManager();
                        if (newElementRelMgr != null && newElementRelMgr.managesField(relatedMmd.getAbsoluteFieldNumber()))
                        {
                            // Element has had the owner set, so make sure it is set to this object
                            Object newValueFieldValue = newElementSM.provideField(relatedMmd.getAbsoluteFieldNumber());
                            if (newValueFieldValue != pc && newValueFieldValue != null)
                            {
                                // The element has a different owner than the PC with this collection
                                // This catches cases where the user has set the wrong owner, and also
                                // will catch cases where the user has added it to two collections
                                throw new JPOXUserException(LOCALISER.msg(
                                    "013009",
                                    StringUtils.toJVMIDString(pc), mmd.getName(),
                                    StringUtils.toJVMIDString(change.value),
                                    StringUtils.toJVMIDString(newValueFieldValue)));
                            }
                        }
                    }
                }
            }
            else if (change.type == REMOVE_OBJECT)
            {
                if (ownerSM.getObjectManager().getApiAdapter().isDeleted(change.value))
                {
                    // The element was removed and was then the element object was deleted so do nothing
                }
                else
                {
                    AbstractMemberMetaData relatedMmd = mmd.getRelatedMemberMetaData(clr)[0];
                    org.jpox.StateManager newElementSM = om.findStateManager(change.value);
                    if (newElementSM != null)
                    {
                        newElementSM.loadField(relatedMmd.getAbsoluteFieldNumber());
                        RelationshipManager newElementRelMgr = newElementSM.getRelationshipManager();
                        if (newElementRelMgr != null && newElementRelMgr.managesField(relatedMmd.getAbsoluteFieldNumber()))
                        {
                            // Element has had the owner set, so make sure it is not set to this object
                            Object newValueFieldValue = newElementSM.provideField(relatedMmd.getAbsoluteFieldNumber());
                            if (newValueFieldValue == pc)
                            {
                                // The element was removed from the collection, but was updated to have its owner
                                // set to the collection owner!
                                throw new JPOXUserException(LOCALISER.msg(
View Full Code Here

    {
        if (oldValue != null)
        {
            // Previously had "a.b = b1"; "a.b" has been changed
            // Need to remove from the other side if still set
            AbstractMemberMetaData relatedMmd = mmd.getRelatedMemberMetaDataForObject(clr, pc, oldValue);
            org.jpox.StateManager oldSM = om.findStateManager(oldValue);
            if (oldSM != null)
            {
                oldSM.loadField(relatedMmd.getAbsoluteFieldNumber());
                Object oldValueFieldValue = oldSM.provideField(relatedMmd.getAbsoluteFieldNumber());
                if (oldValueFieldValue == null)
                {
                    // Set to null so nothing to do
                }
                else if (oldValueFieldValue == pc)
                {
                    // Still set to this object, so null out the other objects relation
                    if (JPOXLogger.PERSISTENCE.isDebugEnabled())
                    {
                        JPOXLogger.PERSISTENCE.debug(
                            LOCALISER.msg("013004",
                            StringUtils.toJVMIDString(oldValue), relatedMmd.getFullFieldName(),
                            StringUtils.toJVMIDString(pc), StringUtils.toJVMIDString(newValue)));
                    }
                    oldSM.replaceFieldValue(relatedMmd.getAbsoluteFieldNumber(), null);
                }
            }
        }
        if (newValue != null)
        {
            // Previously had "a.b = b1"; Now have "a.b = b2"
            // Need to set the other side if not yet set, and unset any related old value on the other side
            AbstractMemberMetaData relatedMmd = mmd.getRelatedMemberMetaDataForObject(clr, pc, newValue);
            org.jpox.StateManager newSM = om.findStateManager(newValue);
            if (newSM != null && relatedMmd != null)
            {
                newSM.loadField(relatedMmd.getAbsoluteFieldNumber());
                Object newValueFieldValue = newSM.provideField(relatedMmd.getAbsoluteFieldNumber());
                if (newValueFieldValue == null)
                {
                    // Was set to null so set to our object
                    if (JPOXLogger.PERSISTENCE.isDebugEnabled())
                    {
                        JPOXLogger.PERSISTENCE.debug(
                            LOCALISER.msg("013005",
                                StringUtils.toJVMIDString(newValue), relatedMmd.getFullFieldName(),
                                StringUtils.toJVMIDString(pc)));
                    }
                    newSM.replaceFieldValue(relatedMmd.getAbsoluteFieldNumber(), pc);
                }
                else if (newValueFieldValue != pc)
                {
                    // Was set to different object, so null out the other objects relation
                    org.jpox.StateManager newValueFieldSM = om.findStateManager(newValueFieldValue);
                    if (newValueFieldSM != null)
                    {
                        // Null out the field of the related object of the new value
                        newValueFieldSM.loadField(mmd.getAbsoluteFieldNumber());
                        if (JPOXLogger.PERSISTENCE.isDebugEnabled())
                        {
                            JPOXLogger.PERSISTENCE.debug(
                                LOCALISER.msg("013004",
                                StringUtils.toJVMIDString(newValueFieldValue),
                                mmd.getFullFieldName(),
                                StringUtils.toJVMIDString(newValue), StringUtils.toJVMIDString(pc)));
                        }
                        newValueFieldSM.replaceFieldValue(mmd.getAbsoluteFieldNumber(), null);
                    }
                    // Update the field of the new value to our object
                    if (JPOXLogger.PERSISTENCE.isDebugEnabled())
                    {
                        JPOXLogger.PERSISTENCE.debug(
                            LOCALISER.msg("013005",
                                StringUtils.toJVMIDString(newValue), relatedMmd.getFullFieldName(),
                                StringUtils.toJVMIDString(pc)));
                    }
                    newSM.replaceFieldValue(relatedMmd.getAbsoluteFieldNumber(), pc);
                }
            }
        }
    }
View Full Code Here

            ClassLoaderResolver clr, ObjectManager om, Object oldValue, Object newValue)
    {
        if (oldValue != null)
        {
            // Has been removed from a Collection/Map
            AbstractMemberMetaData relatedMmd = mmd.getRelatedMemberMetaDataForObject(clr, pc, oldValue);
            org.jpox.StateManager oldSM = om.findStateManager(oldValue);
            if (oldSM != null && relatedMmd != null)
            {
                oldSM.loadField(relatedMmd.getAbsoluteFieldNumber());
                Object oldContainerValue = oldSM.provideField(relatedMmd.getAbsoluteFieldNumber());
                if (oldContainerValue instanceof Collection)
                {
                    Collection oldColl = (Collection)oldContainerValue;
                    if (oldColl.contains(pc))
                    {
                        if (JPOXLogger.PERSISTENCE.isDebugEnabled())
                        {
                            JPOXLogger.PERSISTENCE.debug(
                                LOCALISER.msg("013006",
                                    StringUtils.toJVMIDString(pc), mmd.getFullFieldName(),
                                    relatedMmd.getFullFieldName(), StringUtils.toJVMIDString(oldValue)));
                        }

                        if (oldColl instanceof SCOCollection)
                        {
                            // Avoid any cascade deletes that could have been fired by this action
                            ((SCOCollection)oldColl).remove(pc, false);
                        }
                        else
                        {
                            oldColl.remove(pc);
                        }
                    }
                }
            }
        }
        if (newValue != null)
        {
            // Has been added to a Collection/Map
            AbstractMemberMetaData relatedMmd = mmd.getRelatedMemberMetaDataForObject(clr, pc, newValue);
            org.jpox.StateManager newSM = om.findStateManager(newValue);
            if (newSM != null && relatedMmd != null)
            {
                newSM.loadField(relatedMmd.getAbsoluteFieldNumber());
                Object newContainerValue = newSM.provideField(relatedMmd.getAbsoluteFieldNumber());
                if (newContainerValue instanceof Collection)
                {
                    Collection newColl = (Collection)newContainerValue;
                    if (!newColl.contains(pc))
                    {
                        if (JPOXLogger.PERSISTENCE.isDebugEnabled())
                        {
                            JPOXLogger.PERSISTENCE.debug(
                                LOCALISER.msg("013007",
                                    StringUtils.toJVMIDString(pc), mmd.getFullFieldName(),
                                    relatedMmd.getFullFieldName(), StringUtils.toJVMIDString(newValue)));
                        }
                        newColl.add(pc);
                    }
                }
            }
View Full Code Here

            {
                // If using compound identity dont put it in the L2 Cache (the id uses a PC which we can't link to)
                int[] pkFieldNumbers = acmd.getPKMemberPositions();
                for (int i=0;i<pkFieldNumbers.length;i++)
                {
                    AbstractMemberMetaData fmd = acmd.getMetaDataForManagedMemberAtAbsolutePosition(pkFieldNumbers[i]);
                    if (getApiAdapter().isPersistable(fmd.getType()))
                    {
                        storeInL2Cache = false;
                    }
                }
            }
View Full Code Here

TOP

Related Classes of org.jpox.metadata.AbstractMemberMetaData

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.