void shallowCopyToOneRelationship(T source, T destination, EORelationship relationship) {
+ String relationshipName = relationship.name();
+ ERXCopyable sourceRelatedEO = (ERXCopyable) source.valueForKey(relationshipName);
+ if (sourceRelatedEO != null) {
+ ERXCopyable.copyLogger.debug("Copying " + sourceRelatedEO.userPresentableDescription() + " object for relationship " + relationshipName);
+ ERXCopyable destinationRelatedEO = Utility.shallowCopy(sourceRelatedEO);
+ destination.addObjectToBothSidesOfRelationshipWithKey(destinationRelatedEO, relationshipName);
+ }
+ }
+
+ /**
+ *
+ * Creates a new instance of the {@code source}'s Entity, then steps
+ * through all attributes and relationships, copying them as defined in
+ * each property's UserInfo dictionary in the EOModel.
+ *
+ *
+ *
+ * To make use of this method of copying an EO, simply override the
+ * {@link ERXCopyable#duplicate(NSMutableDictionary)
+ * duplicate(NSMutableDictionary)} method in your EO with the following:
+ *
+ *
+ * public MyEO duplicate(NSMutableDictionary<EOGlobalID, ERXCopyable<?>> copiedObjects) {
+ * MyEO duplicate = ERXCopyable.Utility.modelCopy(copiedObjects, (MyEO) this);
+ * return duplicate;
+ * }
+ *
+ *
+ *
+ *
+ * @param
+ * the Type of the {@code source} and returned objects
+ * @param copiedObjects
+ * the copied objects keyed on the {@link EOGlobalID} of the
+ * object the copy was made from.
+ * @param source
+ * the subclass of {@code ERXCopyable} to copy
+ * @return a copy of the {@code source} object in the same
+ * {@link EOEditingContext}
+ *
+ * @author David Avendasora
+ */
+ public static T modelCopy(NSMutableDictionary> copiedObjects, T source) {
+ EOEntity entity = Utility.entity(source);
+ EOModel model = entity.model();
+ NSDictionary entityUserInfo = entity.userInfo();
+ String entityName = entity.name();
+ String modelName = model.name();
+
+ if (!entityUserInfo.containsKey(ERXCopyable.ERXCOPYABLE_KEY)) {
+ String message = "In order to use modelCopy the \"" + ERXCopyable.ERXCOPYABLE_KEY + "\" key must be set in the UserInfo dictionary of the \"" + entityName + "\" Entity in the " + modelName + " EOModel.";
+ throw new IllegalStateException(message);
+ }
+ ERXCopyable.copyLogger.debug("Making copy of " + source + " based on UserInfo settings in the " + modelName + " EOModel");
+ T copy = Utility.newInstance(source);
+
+ // Register this object right away to handle circular relationships
+ copiedObjects.setObjectForKey(copy, Utility.globalIDForObject(source));
+
+ for (EOProperty property : entity.classProperties()) {
+ if (property instanceof EOAttribute) {
+ EOAttribute attribute = (EOAttribute) property;
+ if (exposedPKAndFKAttributes(source).containsObject(attribute)) {
+ copy.takeStoredValueForKey(null, attribute.name());
+ }
+ else {
+ Utility.modelCopyAttribute(source, copy, attribute);
+ }
+ }
+ else {
+ EORelationship relationship = (EORelationship) property;
+ Utility.modelCopyRelationship(copiedObjects, source, copy, relationship);
+ }
+ }
+ return copy;
+ }
+
+ /**
+ * Reads the values set in the EOModel's attribute and relationship
+ * UserInfo dictionaries and then uses them to control how the
+ * {@code source} object is copied.
+ *
+ * @param
+ * the Type of the {@code source} and {@code destination}
+ * @param copiedObjects
+ * the copied objects keyed on the {@link EOGlobalID} of the
+ * object the copy was made from.
+ * @param source
+ * the subclass of {@code ERXCopyable} to copy all (to-one
+ * and to-many) class relationships values from
+ * @param destination
+ * the subclass of {@code ERXCopyable} to copy all (to-one
+ * and to-many) class relationships values to
+ */
+ public static void modelCopyClassRelationships(NSMutableDictionary> copiedObjects, T source, T destination) {
+ ERXCopyable.copyLogger.debug("Model-copying class relationships for " + source.userPresentableDescription());
+ for (EORelationship relationship : Utility.classRelationships(Utility.entity(source))) {
+ Utility.modelCopyRelationship(copiedObjects, source, destination, relationship);
+ }
+ }
+
+ /**
+ * Reads the values set in the EOModel's attribute and relationship
+ * UserInfo dictionaries and then uses them to control how the
+ * {@code source} object is copied.
+ *
+ * @param
+ * the Type of the {@code source} and {@code destination}
+ * objects
+ * @param copiedObjects
+ * the copied objects keyed on the {@link EOGlobalID} of the
+ * object the copy was made from. the Type of the
+ * {@code source} and {@code destination}
+ * @param source
+ * the subclass of {@code ERXCopyable} to copy the
+ * {@code relationship}'s value(s) from
+ * @param destination
+ * the subclass of {@code ERXCopyable} to copy the
+ * {@code relationship}'s value(s) to
+ * @param relationship
+ * the {@link EORelationship} to copy values for from the
+ * {@code source} to the {@code destination}
+ */
+ public static void modelCopyRelationship(NSMutableDictionary> copiedObjects, T source, T destination, EORelationship relationship) {
+ String relationshipName = relationship.name();
+ CopyType copyType = Utility.copyType(relationship);
+ ERXCopyable.copyLogger.debug("CopyType \"" + copyType.type() + "\" specified for " + relationshipName);
+ switch (copyType) {
+ case REFERENCE:
+ Utility.referenceCopyRelationship(source, destination, relationship);
+ break;
+ case SHALLOW:
+ Utility.shallowCopyRelationship(source, destination, relationship);
+ break;
+ case DEEP:
+ Utility.deepCopyRelationship(copiedObjects, source, destination, relationship);
+ break;
+ case NULLIFY:
+ destination.takeStoredValueForKey(null, relationshipName);
+ break;
+ default:
+ handleMissingOrInvalidCopyType(relationship, copyType);
+ }
+ }
+
+ /**
+ * @param
+ * the Type of the {@code source} and {@code destination}
+ * objects
+ * @param source
+ * the subclass of {@code ERXCopyable} to copy the class
+ * attribute values from
+ * @param destination
+ * the subclass of {@code ERXCopyable} to copy the class
+ * attribute values to
+ */
+ public static void modelCopyClassAttributes(T source, T destination) {
+ ERXCopyable.copyLogger.debug("Model-copying class attributes for " + source.userPresentableDescription());
+ NSArray attributesToCopy = Utility.classAttributes(Utility.entity(source));
+ for (EOAttribute attribute : attributesToCopy) {
+ modelCopyAttribute(source, destination, attribute);
+ }
+ }
+
+ /**
+ * @param
+ * the Type of the {@code source} and {@code destination}
+ * objects
+ * @param source
+ * the subclass of {@code ERXCopyable} to copy the
+ * {@code attribute}'s value from
+ * @param destination
+ * the subclass of {@code ERXCopyable} to copy the
+ * {@code attribute}'s value to
+ * @param attribute
+ * the {@link EOAttribute} that should have its value copied
+ * from the {@code source} to the {@code destination}
+ */
+ public static void modelCopyAttribute(T source, T destination, EOAttribute attribute) {
+ String attributeName = attribute.name();
+ CopyType copyType = Utility.copyType(attribute);
+ switch (copyType) {
+ case REFERENCE:
+ Utility.copyAttribute(source, destination, attribute);
+ break;
+ case CURRENT_TIMESTAMP:
+ destination.takeStoredValueForKey(new NSTimestamp(), attributeName);
+ break;
+ case NULLIFY:
+ destination.takeStoredValueForKey(null, attributeName);
+ break;
+ case DEEP:
+ handleMissingOrInvalidCopyType(attribute, copyType);
+ break;
+ default:
+ handleMissingOrInvalidCopyType(attribute, copyType);
+ }
+ }
+
+ /**
+ * @param property
+ * the attribute or relationship being copied
+ * @return the {@link CopyType} value specified for the
+ * {@code ERXCopyable.CopyType} key in the {@code property}'s
+ * UserInfo dictionary in the EOModel
+ */
+ public static CopyType copyType(EOProperty property) {
+ CopyType copyType;
+ if (property instanceof EOAttribute) {
+ EOAttribute attribute = (EOAttribute) property;
+ @SuppressWarnings("unchecked")
+ NSDictionary userInfo = attribute.userInfo();
+ copyType = Utility.copyType(attribute, userInfo);
+ }
+ else {
+ EORelationship relationship = (EORelationship) property;
+ NSDictionary userInfo = relationship.userInfo();
+ copyType = Utility.copyType(relationship, userInfo);
+ }
+ return copyType;
+ }
+
+ /**
+ * Abstracted out of {@link #copyType(EOProperty)} to handle exceptions
+ * if the userInfo dictionary is null, there is no
+ * {@code ERXCopyable.CopyType} key, or the value for the key is null or
+ * invalid.
+ *
+ * @param property
+ * the attribute or relationship being copied
+ * @param userInfo
+ * the {@code property}'s UserInfo dictionary that contains a
+ * {@code ERXCopyable.CopyType} key
+ * @return the {@link CopyType} value specified for the
+ * {@code ERXCopyable.CopyType} key in {@code userInfo}
+ * dictionary for {@code property}'s UserInfo dictionary in the
+ * EOModel
+ */
+ public static CopyType copyType(EOProperty property, NSDictionary userInfo) {
+ if (userInfo == null) {
+ Utility.handleMissingOrInvalidCopyType(property, null);
+ }
+ String userInfoKey = ERXCopyable.COPY_TYPE_KEY;
+ @SuppressWarnings("null")
+ String copyTypeString = (String) userInfo.objectForKey(userInfoKey);
+ CopyType copyType = (CopyType.get(copyTypeString));
+ if (copyType == null) {
+ Utility.handleMissingOrInvalidCopyType(property, copyType);
+ }
+ return copyType;
+ }
+
+ public static void handleMissingERXCopyableKey(Class invalidClass) {
+ String exceptionMessage = "To use ERXCopyable with " + invalidClass.getSimpleName() + " it must implement " + ERXCopyable.class.getSimpleName() + ".";
+ throw new IllegalStateException(exceptionMessage);
+ }
+
+ /**
+ * Creates a meaningful error message to be displayed when
+ * {@code modelCopy} was specified for the {@code ERXCopyable} key in an
+ * Entity's UserInfo dictionary, but not all attributes and
+ * relationships have a valid {@code ERXCopyable.CopyType} specified.
+ *
+ * @param property
+ * the attribute or relationship being copied
+ * @param copyType
+ * the invalid {@link CopyType} specified in the
+ * {@code property}'s UserInfo dictionary in the EOModel
+ */
+ public static void handleMissingOrInvalidCopyType(EOProperty property, CopyType copyType) {
+ String propertyType = Utility.propertyType(property);
+ @SuppressWarnings("unchecked")
+ NSArray copyTypes = (NSArray) Utility.copyTypes(property).valueForKey("type");
+ String validCopyTypes = copyTypes.componentsJoinedByString(", ");
+ String propertyName = property.name();
+ EOEntity entity = property.entity();
+ String entityName = entity.name();
+ EOModel model = entity.model();
+ String modelName = model.name();
+ String exceptionMessage = "To use ERXCopyable's modelCopy methods the \"" + ERXCopyable.COPY_TYPE_KEY + "\" key must be set in the UserInfo dictionary of the \"" + entityName + "." + propertyName + "\" " + propertyType + " in " + modelName + " AND it must be set to one of these values: {" + validCopyTypes + "}. " + copyType + " is not a valid value.";
+ throw new IllegalStateException(exceptionMessage);
+ }
+
+ /**
+ * @param property
+ * the attribute or relationship being copied
+ * @return "attribute" if the passed in property is an instance of
+ * {@link EOAttribute}, "relationship" if it is an instance of
+ * {@link EORelationship}
+ */
+ public static String propertyType(EOProperty property) {
+ String propertyType;
+ if (property instanceof EOAttribute) {
+ propertyType = "attribute";
+ }
+ else {
+ propertyType = "relationship";
+ }
+ return propertyType;
+ }
+
+ /**
+ * @param property
+ * the attribute or relationship being copied
+ * @return an array of the valid {@link CopyType}s for the passed-in
+ * {@link EOProperty}
+ */
+ public static NSArray copyTypes(EOProperty property) {
+ NSArray validCopyTypes;
+ if (property instanceof EOAttribute) {
+ validCopyTypes = new NSArray(CopyType.NULLIFY, CopyType.CURRENT_TIMESTAMP, CopyType.REFERENCE);
+ }
+ else {
+ validCopyTypes = new NSArray(CopyType.NULLIFY, CopyType.REFERENCE, CopyType.SHALLOW, CopyType.DEEP);
+ }
+ return validCopyTypes;
+ }
+
+ /**
+ * @param
+ * the Type of the {@code source} object
+ * @param source
+ * the subclass of {@code ERXCopyable} that is being copied
+ * @return an array of {@link EOAttribute}s that are the Primary- and
+ * Foreign-Key attributes for the {@code source} subclass of
+ * {@link ERXCopyable}
+ */
+ public static NSArray primaryAndForeignKeyAttributes(T source) {
+ EOEntity entity = Utility.entity(source);
+ NSArray primaryKeyAttributes = entity.primaryKeyAttributes();
+ NSMutableSet keyAttributes = new NSMutableSet(primaryKeyAttributes);
+ NSArray classRelationships = Utility.classRelationships(entity);
+ for (EORelationship relationship : classRelationships) {
+ NSArray foreignKeyAttributes = relationship.sourceAttributes();
+ keyAttributes.addObjectsFromArray(foreignKeyAttributes);
+ }
+ NSArray primaryAndForeignKeyAttributes = keyAttributes.allObjects();
+ return primaryAndForeignKeyAttributes;
+ }
+ }
+
+ public static Logger copyLogger = LoggerFactory.getLogger(ERXCopyable.class);
+
+ /**
+ * "{@link ERXCopyable}" which is the exact String that must be used as the
+ * key in the Entity's EOModel UserInfo dictionary to designate it as
+ * implementing {@link ERXCopyable} interface.
+ */
+ public static final String ERXCOPYABLE_KEY = ERXCopyable.class.getSimpleName();
+
+ /**
+ * "{@code ERXCopyable.CopyType}" which is the exact String that must be
+ * used as the key in an Attribute's or Relationship's EOModel UserInfo
+ * dictionary to specify the way the property should be copied by
+ * {@link ERXCopyable}.
+ */
+ public static final String COPY_TYPE_KEY = ERXCOPYABLE_KEY + "." + CopyType.class.getSimpleName();
+
+ /**
+ * Convenience cover method for {@link #copy(NSMutableDictionary)} that
+ * creates the dictionary for you. You can use this to start the copying of
+ * a graph if you have no need to reference the dictionary.
+ *
+ * @return a copy of this object
+ */
+ public T copy();
+
+ /**
+ * Returns a copy of this object, copying related objects as well. The
+ * actual copy mechanism (by reference, deep, or custom) for each object is
+ * up to the object being copied. If a copy already exists in
+ * {@code copiedObjects}, then that copy is returned instead of making a new
+ * copy. This allows complex graphs of objects, including those with cycles,
+ * to be copied without producing duplicate objects. The graph of copied
+ * objects will be the same regardless of where copy is started with two
+ * exceptions: if it is started on a reference copied object or if a
+ * reference copied object is the only path between two disconnected parts
+ * of the graph. In these cases the reference copied object prevents the
+ * copy from following the graph further.
+ *
+ * @param copiedObjects
+ * the copied objects keyed on the {@link EOGlobalID} of the
+ * object the copy was made from.
+ * @return a copy of this object
+ */
+ public T copy(NSMutableDictionary> copiedObjects);
+
+ /**
+ * Returns a copy of this object. Each {@code ERXCopyable} should implement
+ * this to produce the actual copy by an appropriate mechanism (reference,
+ * shallow, deep, or custom).
+ *
+ * @param copiedObjects
+ * the copied objects keyed on the {@link EOGlobalID} of the
+ * object the copy was made from.
+ * @return a copy of this object
+ */
+ public T duplicate(NSMutableDictionary> copiedObjects);
+}