void postprocessRemove(Object removedObject) { // notify ObjectContext if (relationshipOwner.getObjectContext() != null) { relationshipOwner.getObjectContext().propertyChanged( relationshipOwner, relationshipName, removedObject, null); } }
void postprocessAdd(Object addedObject) { // notify ObjectContext if (relationshipOwner.getObjectContext() != null) { relationshipOwner.getObjectContext().propertyChanged( relationshipOwner, relationshipName, null, addedObject); } }
public void writeProperty(String propName, Object val) { if (objectContext != null) { // pass "false" to avoid unneeded fault processing objectContext.prepareForAccess(this, propName, false); // note how we notify ObjectContext of change BEFORE the object is // actually // changed... this is needed to take a valid current snapshot Object oldValue = readPropertyDirectly(propName); objectContext.propertyChanged(this, propName, oldValue, val); } writePropertyDirectly(propName, val); }
@Override public void nodePropertyChanged( Object nodeId, String property, Object oldValue, Object newValue) { super.nodePropertyChanged(nodeId, property, oldValue, newValue); Persistent object = (Persistent) context.getGraphManager().getNode(nodeId); context.propertyChanged(object, property, oldValue, newValue); }
void postprocessRemove(Object removedObject) { // notify ObjectContext if (relationshipOwner.getObjectContext() != null) { relationshipOwner.getObjectContext().propertyChanged( relationshipOwner, relationshipName, removedObject, null); if (removedObject instanceof Persistent) { Util.unsetReverse(relationshipOwner, relationshipName, (Persistent) removedObject); } } }
public void writeProperty(String propName, Object val) { if (objectContext != null) { objectContext.prepareForAccess(this, propName); // note how we notify DataContext of change BEFORE the object is actually // changed... this is needed to take a valid current snapshot Object oldValue = readPropertyDirectly(propName); objectContext.propertyChanged(this, propName, oldValue, val); } writePropertyDirectly(propName, val); }
protected void postprocessAdd(Object addedObject) { // notify ObjectContext if (relationshipOwner.getObjectContext() != null) { relationshipOwner.getObjectContext().propertyChanged( relationshipOwner, relationshipName, null, addedObject); if (addedObject instanceof Persistent) { Util.setReverse(relationshipOwner, relationshipName, (Persistent) addedObject); } } }
protected void postprocessRemove(Object removedObject) { // notify ObjectContext if (relationshipOwner.getObjectContext() != null) { relationshipOwner.getObjectContext().propertyChanged( relationshipOwner, relationshipName, removedObject, null); if (removedObject instanceof Persistent) { Util.unsetReverse(relationshipOwner, relationshipName, (Persistent) removedObject); } } }
protected void postprocessRemove(Object removedObject) { // notify ObjectContext if (relationshipOwner.getObjectContext() != null) { relationshipOwner.getObjectContext().propertyChanged( relationshipOwner, relationshipName, removedObject, null); if (removedObject instanceof Persistent) { Util.unsetReverse( relationshipOwner, relationshipName, (Persistent) removedObject); } } }
public void removeToManyTarget(String relName, DataObject value, boolean setReverse) { // Now do the rest of the normal handling (regardless of whether it was // flattened or not) Object holder = readProperty(relName); // call 'propertyChanged' AFTER readProperty as readProperty ensures // that this // object fault is resolved getObjectContext().propertyChanged(this, relName, value, null); // TODO: andrus 8/20/2007 - can we optimize this somehow, avoiding type // checking?? if (holder instanceof Collection) { ((Collection<Object>) holder).remove(value); } else if (holder instanceof Map) { ((Map<Object, Object>) holder).remove(getMapKey(relName, value)); } if (value != null && setReverse) { unsetReverseRelationship(relName, value); } }
void postprocessAdd(Object addedObject) { // notify ObjectContext if (relationshipOwner.getObjectContext() != null) { relationshipOwner.getObjectContext().propertyChanged( relationshipOwner, relationshipName, null, addedObject); if (addedObject instanceof Persistent) { Util.setReverse(relationshipOwner, relationshipName, (Persistent) addedObject); } } }
public void addToManyTarget(String relName, DataObject value, boolean setReverse) { if (value == null) { throw new NullPointerException("Attempt to add null target DataObject."); } willConnect(relName, value); // Now do the rest of the normal handling (regardless of whether it was // flattened or not) Object holder = readProperty(relName); // call 'propertyChanged' AFTER readProperty as readProperty ensures // that this // object fault is resolved getObjectContext().propertyChanged(this, relName, null, value); // TODO: andrus 8/20/2007 - can we optimize this somehow, avoiding type // checking?? if (holder instanceof Collection) { ((Collection<Object>) holder).add(value); } else if (holder instanceof Map) { ((Map<Object, Object>) holder).put(getMapKey(relName, value), value); } if (setReverse) { setReverseRelationship(relName, value); } }
protected void postprocessAdd(Object addedObject) { // notify ObjectContext if (relationshipOwner.getObjectContext() != null) { relationshipOwner.getObjectContext().propertyChanged( relationshipOwner, relationshipName, null, addedObject); if (addedObject instanceof Persistent) { Util.setReverse( relationshipOwner, relationshipName, (Persistent) addedObject); } } }
/** * Sets an object value, marking this ValueHolder as resolved. */ public synchronized Object setValue(Object value) throws CayenneRuntimeException { if (fault) { resolve(); } Object oldValue = setValueDirectly(value); if (oldValue != value) { // notify ObjectContext if (relationshipOwner.getObjectContext() != null) { relationshipOwner.getObjectContext().propertyChanged( relationshipOwner, relationshipName, oldValue, value); } } return oldValue; }
@Override public void arcCreated(Object nodeId, Object targetNodeId, Object arcId) { final Persistent source = findObject(nodeId); final Persistent target = findObject(targetNodeId); // if a target was later deleted, the diff for arcCreated is still preserved and // can result in NULL target here. if (target == null) { return; } ClassDescriptor descriptor = context.getEntityResolver().getClassDescriptor( ((ObjectId) nodeId).getEntityName()); ArcProperty property = (ArcProperty) descriptor.getProperty(arcId.toString()); property.visit(new PropertyVisitor() { public boolean visitAttribute(AttributeProperty property) { return false; } public boolean visitToMany(ToManyProperty property) { property.addTargetDirectly(source, target); return false; } public boolean visitToOne(ToOneProperty property) { property.setTarget(source, target, false); return false; } }); context.propertyChanged(source, (String) arcId, null, target); }
/** * Sets an object value, marking this ValueHolder as resolved. */ public synchronized Object setValue(Object value) throws CayenneRuntimeException { if (fault) { resolve(); } Object oldValue = setValueDirectly(value); if (oldValue != value && relationshipOwner.getObjectContext() != null) { relationshipOwner.getObjectContext().propertyChanged(relationshipOwner, relationshipName, oldValue, value); if (oldValue instanceof Persistent) { Util.unsetReverse(relationshipOwner, relationshipName, (Persistent) oldValue); } if (value instanceof Persistent) { Util.setReverse(relationshipOwner, relationshipName, (Persistent) value); } } return oldValue; }
context.propertyChanged(source, (String) arcId, target[0], null);
public void setToOneTarget(String relationshipName, DataObject value, boolean setReverse) { willConnect(relationshipName, value); Object oldTarget = readProperty(relationshipName); if (oldTarget == value) { return; } getObjectContext().propertyChanged(this, relationshipName, oldTarget, value); if (setReverse) { // unset old reverse relationship if (oldTarget instanceof DataObject) { unsetReverseRelationship(relationshipName, (DataObject) oldTarget); } // set new reverse relationship if (value != null) { setReverseRelationship(relationshipName, value); } } objectContext.prepareForAccess(this, relationshipName, false); writePropertyDirectly(relationshipName, value); }