import java.util.Map;
import java.util.Set;
-
/**
- * Extension of {@link
- * org.springframework.orm.hibernate.support.HibernateDaoSupport}.
- *
+ * Extension of
+ * {@link org.springframework.orm.hibernate.support.HibernateDaoSupport}.
+ *
* @author Erik Brakkee
*/
public class HibernateSupport extends HibernateDaoSupport {
- /**
- * DOCUMENT ME!
- */
private static final Log LOG = LogFactory.getLog(HibernateSupport.class);
-/**
+ /**
* Constructs the object.
*
*/
}
/**
- * Performes a hibernate <code>Session.merge()</code> and updates
- * the object with the correct primary key and version. This is an
- * extension to the hibernate merge operation because hibernate itself
- * leaves the object passed to merge untouched. Use this method with
- * extreme caution since it will recursively load all objects that the
- * current object has relations with and for which cascade="merge" was
- * specified in the Hibernate mapping file.
- *
- * @param aPersistent Object to merge.
+ * Performes a hibernate <code>Session.merge()</code> and updates the object
+ * with the correct primary key and version. This is an extension to the
+ * hibernate merge operation because hibernate itself leaves the object
+ * passed to merge untouched. Use this method with extreme caution since it
+ * will recursively load all objects that the current object has relations
+ * with and for which cascade="merge" was specified in the Hibernate mapping
+ * file.
+ *
+ * @param aPersistent
+ * Object to merge.
*/
public void merge(Persistent aPersistent) {
merge(getHibernateTemplate(), aPersistent);
}
/**
- * As {@link #merge(Persistent)} but with a given template. This
- * method can be accessed in a static way.
- *
- * @param aTemplate Hibernate template
- * @param aPersistent Object to merge.
+ * As {@link #merge(Persistent)} but with a given template. This method can
+ * be accessed in a static way.
+ *
+ * @param aTemplate
+ * Hibernate template
+ * @param aPersistent
+ * Object to merge.
*/
public static void merge(HibernateTemplate aTemplate, Persistent aPersistent) {
Persistent merged = (Persistent) aTemplate.merge(aPersistent);
}
/**
- * Copies primary keys and version from the result of the merged to
- * the object that was passed to the merge operation. It does this by
- * traversing the properties of the object. It copies the primary key and
- * version for objects that implement {@link Persistent} and applies the
- * same rules to objects in maps and sets as well (i.e. recursively).
- *
- * @param aPersistent Object whose primary key and version are to be set.
- * @param aMerged Object that was the result of the merge.
- * @param aProcessed List of already processed Persistent objects of the
- * persistent part.
- *
- * @throws RuntimeException DOCUMENT ME!
+ * Copies primary keys and version from the result of the merged to the
+ * object that was passed to the merge operation. It does this by traversing
+ * the properties of the object. It copies the primary key and version for
+ * objects that implement {@link Persistent} and applies the same rules to
+ * objects in maps and sets as well (i.e. recursively).
+ *
+ * @param aPersistent
+ * Object whose primary key and version are to be set.
+ * @param aMerged
+ * Object that was the result of the merge.
+ * @param aProcessed
+ * List of already processed Persistent objects of the persistent
+ * part.
+ *
*/
public static void processPersistent(Persistent aPersistent,
Persistent aMerged, List<ObjectElem> aProcessed) {
}
if ((aPersistent == null) || (aMerged == null)) {
- throw new RuntimeException("persistent or merged object is null '"
- + aPersistent + "'" + " '" + aMerged + "'");
+ throw new RuntimeException("persistent or merged object is null '" +
+ aPersistent + "'" + " '" + aMerged + "'");
}
ObjectElem elem = new ObjectElem(aPersistent);
LOG.debug("Setting pk/version on " + aPersistent + " from " + aMerged);
- if ((aPersistent.getPrimaryKey() != null)
- && !aMerged.getPrimaryKey().equals(aPersistent.getPrimaryKey())) {
- LOG.error("Mismatch between primary key values: " + aPersistent
- + " " + aMerged);
+ if ((aPersistent.getPrimaryKey() != null) &&
+ !aMerged.getPrimaryKey().equals(aPersistent.getPrimaryKey())) {
+ LOG.error("Mismatch between primary key values: " + aPersistent +
+ " " + aMerged);
} else {
aPersistent.setPersistedVersion(aMerged.getPersistedVersion());
aPersistent.setPrimaryKey(aMerged.getPrimaryKey());
try {
if (Set.class.isAssignableFrom(returnType)) {
- Set merged = (Set) getter.invoke(aMerged);
+ Set merged = (Set) getter.invoke(aMerged);
Set persistent = (Set) getter.invoke(aPersistent);
processSet(persistent, merged, aProcessed);
} else if (List.class.isAssignableFrom(returnType)) {
- List merged = (List) getter.invoke(aMerged);
+ List merged = (List) getter.invoke(aMerged);
List persistent = (List) getter.invoke(aPersistent);
processList(persistent, merged, aProcessed);
} else if (Map.class.isAssignableFrom(returnType)) {
- Map merged = (Map) getter.invoke(aMerged);
+ Map merged = (Map) getter.invoke(aMerged);
Map persistent = (Map) getter.invoke(aPersistent);
processMap(persistent, merged, aProcessed);
} else if (Persistent.class.isAssignableFrom(returnType)) {
- Persistent merged = (Persistent) getter.invoke(aMerged);
- Persistent persistent = (Persistent) getter.invoke(aPersistent);
+ Persistent merged = (Persistent) getter.invoke(aMerged);
+ Persistent persistent = (Persistent) getter
+ .invoke(aPersistent);
processPersistent(persistent, merged, aProcessed);
- } else if (returnType.isArray()
- && Persistent.class.isAssignableFrom(
- returnType.getComponentType())) {
- Persistent[] merged = (Persistent[]) getter.invoke(aMerged);
- Persistent[] persistent = (Persistent[]) getter.invoke(aPersistent);
+ } else if (returnType.isArray() &&
+ Persistent.class.isAssignableFrom(returnType
+ .getComponentType())) {
+ Persistent[] merged = (Persistent[]) getter
+ .invoke(aMerged);
+ Persistent[] persistent = (Persistent[]) getter
+ .invoke(aPersistent);
for (int i = 0; i < persistent.length; i++) {
processPersistent(persistent[i], merged[i],
/**
* Process the persistent objects in the collections.
- *
- * @param aPersistent Collection in the original object.
- * @param aMerged Collection as a result of the merge.
- * @param aProcessed List of processed persistent objects.
- *
- * @throws RuntimeException DOCUMENT ME!
+ *
+ * @param aPersistent
+ * Collection in the original object.
+ * @param aMerged
+ * Collection as a result of the merge.
+ * @param aProcessed
+ * List of processed persistent objects.
+ *
*/
public static void processList(List aPersistent, List aMerged,
List<ObjectElem> aProcessed) {
- Object[] merged = aMerged.toArray();
+ Object[] merged = aMerged.toArray();
Object[] persistent = aPersistent.toArray();
if (merged.length != persistent.length) {
- throw new RuntimeException("Array sizes differ " + merged.length
- + " " + persistent.length);
+ throw new RuntimeException("Array sizes differ " + merged.length +
+ " " + persistent.length);
}
for (int i = 0; i < merged.length; i++) {
/**
* Process the persistent objects in sets.
- *
- * @param aPersistent Collection in the original object.
- * @param aMerged Collection as a result of the merge.
- * @param aProcessed List of processed persistent objects.
- *
- * @throws RuntimeException DOCUMENT ME!
+ *
+ * @param aPersistent
+ * Collection in the original object.
+ * @param aMerged
+ * Collection as a result of the merge.
+ * @param aProcessed
+ * List of processed persistent objects.
+ *
*/
public static void processSet(Set aPersistent, Set aMerged,
List<ObjectElem> aProcessed) {
if (aMerged.size() != aPersistent.size()) {
- throw new RuntimeException("Array sizes differ " + aMerged.size()
- + " " + aPersistent.size());
+ throw new RuntimeException("Array sizes differ " + aMerged.size() +
+ " " + aPersistent.size());
}
for (Object merged : aMerged) {
/**
* Process the Map objects in the collections.
- *
- * @param aPersistent Collection in the original object.
- * @param aMerged Collection as a result of the merge.
- * @param aProcessed List of processed persistent objects.
- *
- * @throws RuntimeException DOCUMENT ME!
+ *
+ * @param aPersistent
+ * Collection in the original object.
+ * @param aMerged
+ * Collection as a result of the merge.
+ * @param aProcessed
+ * List of processed persistent objects.
+ *
*/
public static void processMap(Map aPersistent, Map aMerged,
List<ObjectElem> aProcessed) {
if (aMerged.size() != aPersistent.size()) {
- throw new RuntimeException("Sizes differ " + aMerged.size() + " "
- + aPersistent.size());
+ throw new RuntimeException("Sizes differ " + aMerged.size() + " " +
+ aPersistent.size());
}
Set keys = aMerged.keySet();
throw new RuntimeException("Key '" + key + "' not found");
}
- Object mergedValue = aMerged.get(key);
+ Object mergedValue = aMerged.get(key);
Object persistentValue = aPersistent.get(key);
if (mergedValue instanceof Persistent) {
}
/**
- * This class provided an equality operation based on the object
- * reference of the wrapped object. This is required because we cannto
- * assume that the equals operation has any meaning for different types of
- * persistent objects. This allows us to use the standard collection
- * classes for detecting cyclic dependences and avoiding recursion.
+ * This class provided an equality operation based on the object reference
+ * of the wrapped object. This is required because we cannto assume that the
+ * equals operation has any meaning for different types of persistent
+ * objects. This allows us to use the standard collection classes for
+ * detecting cyclic dependences and avoiding recursion.
*/
private static final class ObjectElem {
private Object object;
git://wamblee.org / utils / blobdiff