[Andromda-devel] AndroMDA/JIRA Closed: (SPRING-165) When 'daoInheritanceEnabled=false', VO transformations are generated incorrectly

[Jens V. (JIRA) <ji...@an...>]

     [ http://jira.andromda.org/browse/SPRING-165?page=all ]
     
Jens Vagts closed SPRING-165:
-----------------------------


> When 'daoInheritanceEnabled=false', VO transformations are generated incorrectly
> --------------------------------------------------------------------------------
>
>          Key: SPRING-165
>          URL: http://jira.andromda.org/browse/SPRING-165
>      Project: Spring Cartridge
>         Type: Bug

>     Versions: 3.2-RC1
>     Reporter: olaf kruger
>     Assignee: Jens Vagts
>      Fix For: 3.2-RC1

>
> When using 'daoInheritanceEnabled=false', the following are incorrectly (or not all) generated:
> 1. the dao interface classes should contain (but don't) (a) transformation constants; (b) transformation functions for all VO references (including those "inherited" from super-entities and not just those specific to the DAO being processed);
> 2. the DAO *Base and *Impl classes should reflect the same approach.
> At present, the compile / build fails.
> See the forum discussion: http://galaxy.andromda.org/forum/viewtopic.php?t=1969&start=15 
> (I have attached - i.e. pasted in - contents of SpringDao.vsl, SpringHibernateDaoImpl.vsl and SpringHibernateDaoBase.vsl. Couldn't find a means to attach the files. They are the amended *.vsl from the March, 23 snapshot... See also said forum discussion which contains similar snippets of code.)
> Now, while the fixes work fine for me, due diligence should (probably) be applied ;-)
> Hope this helps,
> cheers,
> -olaf
> ************************* SpringDao.vsl **************************
> #set ($generatedFile = "${entity.packagePath}/${entity.daoName}.java")
> #if ($enableTemplating)
> #set ($entityCollectionType = "java.util.Collection<${entity.fullyQualifiedEntityName}>")
> #else
> #set ($entityCollectionType = "java.util.Collection")
> #end
> // license-header java merge-point
> //
> // Attention: Generated code! Do not modify by hand!
> // Generated by: SpringDao.vsl in andromda-spring-cartridge.
> //
> #if ($stringUtils.isNotBlank($entity.packageName))
> package $entity.packageName;
> #end
> #set ($superclass = $entity.generalization)
> #set ($daoInheritance = $superclass && $daoInheritanceEnabled)
> #if ($daoInheritance)
> #set ($rootEntityType = $entity.root.fullyQualifiedEntityName)
> #else
> #set ($rootEntityType = $entity.fullyQualifiedEntityName)
> #end
> /**
>  * @see $entity.fullyQualifiedEntityName
>  */
> public interface $entity.daoName
> #if ($daoInheritance)
>     extends $superclass.fullyQualifiedDaoName
> #end
> {
> #if (!$daoInheritance)
>     /**
>      * This constant is used as a transformation flag; entities can be converted automatically into value objects
>      * or other types, different methods in a class implementing this interface support this feature: look for
>      * an <code>int</code> parameter called <code>transform</code>.
>      * <p/>
>      * This specific flag denotes no transformation will occur.
>      */
>     public final static int $entity.daoNoTransformationConstantName = 0;
> #if ($hibernateUtils.xmlPersistenceActive)
>     /**
>      * A transformation flag constant that denotes a transformation into a dom4j XML document tree should occur.
>      */
>     public final static int TRANSFORM_XML = 1;
> #end
> #end
> ##
> ##	With dao inheritance disabled, each and every interface in the hierarchy must generate the complete set of 
> ##	transformation operators (except the "noTransformation" transformation constant which is already generated above).
> ##
> ##	Note: 'valueObjectReferences' holds all of the VO references that the entity currently being processed has;
> ##		In contrast, 'allValuObjectReference' holds all VO references including the "inherited" ones.
> ##
> #if ($daoInheritance)
> #set ($valueObjectReferences = $entity.valueObjectReferences)
> #else
> #set ($valueObjectReferences = $entity.allValueObjectReferences)
> #end
> #foreach ($valueObjectRef in $valueObjectReferences)
>     /**
>      * This constant is used as a transformation flag; entities can be converted automatically into value objects
>      * or other types, different methods in a class implementing this interface support this feature: look for
>      * an <code>int</code> parameter called <code>transform</code>.
>      * <p/>
>      * This specific flag denotes entities must be transformed into objects of type
>      * {@link $valueObjectRef.targetElement.fullyQualifiedName}.
>      */
>     public final static int $valueObjectRef.transformationConstantName = $valueObjectRef.transformationConstantValue;
>     /**
>      * Copies the fields of the specified entity to the target value object.  This method is similar to
>      * ${valueObjectRef.transformationMethodName}(), but it does not handle any attributes in the target
>      * value object that are "read-only" (as those do not have setter methods exposed).
>      */
>     public void ${valueObjectRef.transformationMethodName}(
>         $entity.fullyQualifiedEntityName sourceEntity, 
>         $valueObjectRef.targetElement.fullyQualifiedName targetVO);
>     /**
>      * Converts this DAO's entity to an object of type {@link $valueObjectRef.targetElement.fullyQualifiedName}.
>      */
>     public $valueObjectRef.targetElement.fullyQualifiedName ${valueObjectRef.transformationMethodName}($entity.fullyQualifiedEntityName entity);
>     /**
>      * Converts this DAO's entity to a Collection of instances of type {@link $valueObjectRef.targetElement.fullyQualifiedName}.
>      */
>     public void ${valueObjectRef.transformationToCollectionMethodName}(java.util.Collection entities);
>     
>     /**
>      * Copies the fields of {@link $valueObjectRef.targetElement.fullyQualifiedName} to the specified entity.
>      * @param copyIfNull If FALSE, the value object's field will not be copied to the entity if the value is NULL. If TRUE,
>      *        it will be copied regardless of its value.
>      */
>     public void ${valueObjectRef.transformationToEntityMethodName}(
>         $valueObjectRef.targetElement.fullyQualifiedName sourceVO,
>         $entity.fullyQualifiedEntityName targetEntity,
>         boolean copyIfNull);
>     /**
>      * Converts an instance of type {@link $valueObjectRef.targetElement.fullyQualifiedName} to this DAO's entity.
>      */
>     public $entity.fullyQualifiedEntityName ${valueObjectRef.transformationToEntityMethodName}($valueObjectRef.targetElement.fullyQualifiedName $stringUtils.uncapitalize($valueObjectRef.name));
>     /**
>      * Converts a Collection of instances of type {@link $valueObjectRef.targetElement.fullyQualifiedName} to this
>      * DAO's entity.
>      */
>     public void ${valueObjectRef.transformationToEntityCollectionMethodName}(java.util.Collection instances);
> #end
> #set ($identifier = $entity.identifiers.iterator().next())
> #set ($argumentName = $stringUtils.uncapitalize($entity.name))
>     /**
>      * Loads an instance of $entity.fullyQualifiedEntityName from the persistent store.
>      */
>     public $rootEntityType load($identifier.type.fullyQualifiedName $identifier.name);
>     /**
>      * <p>
>      *   Does the same thing as {@link #load($identifier.type.fullyQualifiedName)} with an
>      *   additional flag called <code>transform</code>.  If this flag is set to <code>$entity.daoNoTransformationConstantName</code> then
>      *   the returned entity will <strong>NOT</strong> be transformed.  If this flag is any of the other constants
>      *   defined in this class then the result <strong>WILL BE</strong> passed through an operation which can
>      *   optionally transform the entity (into a value object for example).  By default, transformation does
>      *   not occur.
>      * </p>
>      *
>      * @param $identifier.name the identifier of the entity to load.
>      * @return either the entity or the object transformed from the entity.
>      */
>     public Object load(int transform, $identifier.type.fullyQualifiedName $identifier.name);
>     /**
>      * Loads all entities of type {@link ${entity.fullyQualifiedEntityName}}.
>      *
>      * @return the loaded entities.
>      */
>     public $entityCollectionType loadAll();
>     /**
>      * <p>
>      *   Does the same thing as {@link #loadAll()} with an
>      *   additional flag called <code>transform</code>.  If this flag is set to <code>$entity.daoNoTransformationConstantName</code> then
>      *   the returned entity will <strong>NOT</strong> be transformed.  If this flag is any of the other constants
>      *   defined here then the result <strong>WILL BE</strong> passed through an operation which can optionally
>      *   transform the entity (into a value object for example).  By default, transformation does
>      *   not occur.
>      * </p>
>      *
>      * @param transform the flag indicating what transformation to use.
>      * @return the loaded entities.
>      */
>     public java.util.Collection loadAll(final int transform);
> ## Only add these methods if the entity isn't abstract
> #if (!$entity.abstract)
>     /**
>      * Creates an instance of $entity.fullyQualifiedEntityName and adds it to the persistent store.
>      */
>     public $rootEntityType create($entity.fullyQualifiedEntityName $argumentName);
> #if ($hibernateUtils.xmlPersistenceActive)
>     /**
>      * Creates an instance of $entity.fullyQualifiedEntityName using XML defined in <code>$argumentName</code> 
>      * and adds it to the persistent store.
>      */
>     public $rootEntityType create(org.dom4j.Element $argumentName);
>     /**
>      * Creates an instance of $entity.fullyQualifiedEntityName using XML defined in <code>$argumentName</code> 
>      * and adds it to the persistent store.
>      */
>     public Object create(int transform, org.dom4j.Element $argumentName);
> #end
>     /**
>      * <p>
>      *   Does the same thing as {@link #create($entity.fullyQualifiedEntityName)} with an
>      *   additional flag called <code>transform</code>.  If this flag is set to <code>$entity.daoNoTransformationConstantName</code> then
>      *   the returned entity will <strong>NOT</strong> be transformed.  If this flag is any of the other constants
>      *   defined here then the result <strong>WILL BE</strong> passed through an operation which can optionally
>      *   transform the entity (into a value object for example).  By default, transformation does
>      *   not occur.
>      * </p>
>      */
>     public Object create(int transform, $entity.fullyQualifiedEntityName $argumentName);
>     /**
>      * Creates a new instance of $entity.fullyQualifiedEntityName and adds
>      * from the passed in <code>entities</code> collection
>      *
>      * @param entities the collection of $entity.fullyQualifiedEntityName
>      *        instances to create.
>      *
>      * @return the created instances.
>      */
>     public $entityCollectionType create($entityCollectionType entities);
>     /**
>      * <p>
>      *   Does the same thing as {@link #create($entity.fullyQualifiedEntityName)} with an
>      *   additional flag called <code>transform</code>.  If this flag is set to <code>$entity.daoNoTransformationConstantName</code> then
>      *   the returned entity will <strong>NOT</strong> be transformed.  If this flag is any of the other constants
>      *   defined here then the result <strong>WILL BE</strong> passed through an operation which can optionally
>      *   transform the entities (into value objects for example).  By default, transformation does
>      *   not occur.
>      * </p>
>      */
>     public java.util.Collection create(int transform, $entityCollectionType entities);
> #if ($enableDaoPropertiesCreateMethod.equalsIgnoreCase('true'))
> #set ($attributes = $entity.getAttributes(true, $entity.usingAssignedIdentifier))
> #if (!$attributes.empty)
>     /**
>      * <p>
>      *   Creates a new <code>$entity.fullyQualifiedEntityName</code>
>      *   instance from <strong>all</strong> attributes and adds it to
>      *   the persistent store.
>      * </p>
>      */
>     public $rootEntityType create(
> #foreach($attribute in $attributes)
>         $attribute.type.fullyQualifiedName $attribute.name#if($velocityCount != $attributes.size()),#else);#end
> #end
>     /**
>      * <p>
>      *   Does the same thing as {@link #create($entity.getAttributeTypeList(true,false))} with an
>      *   additional flag called <code>transform</code>.  If this flag is set to <code>$entity.daoNoTransformationConstantName</code> then
>      *   the returned entity will <strong>NOT</strong> be transformed.  If this flag is any of the other constants
>      *   defined here then the result <strong>WILL BE</strong> passed through an operation which can optionally
>      *   transform the entity (into a value object for example).  By default, transformation does
>      *   not occur.
>      * </p>
>      */
>     public Object create(
>         int transform,
> #foreach($attribute in $attributes)
>         $attribute.type.fullyQualifiedName $attribute.name#if($velocityCount != $attributes.size()),#else);#end
> #end
> #end
> #set ($requiredProperties = $entity.getRequiredProperties(true,false))
> #if (!$requiredProperties.empty && $entity.getRequiredAttributes(true,false).size() != $requiredProperties.size())
>     /**
>      * <p>
>      *  Creates a new <code>$entity.fullyQualifiedEntityName</code>
>      *  instance from only <strong>required</strong> properties (attributes
>      *  and association ends) and adds it to the persistent store.
>      * </p>
>      */
>     public $rootEntityType create(
> #foreach($property in $requiredProperties)
>         $property.getterSetterTypeName $property.name#if($velocityCount != $requiredProperties.size()),#else);#end
> #end
>     /**
>      * <p>
>      *   Does the same thing as {@link #create($entity.getRequiredAttributeTypeList(true,false))} with an
>      *   additional flag called <code>transform</code>.  If this flag is set to <code>$entity.daoNoTransformationConstantName</code> then
>      *   the returned entity will <strong>NOT</strong be transformed.  If this flag is any of the other constants
>      *   defined here then the result <strong>WILL BE</strong> passed through an operation which can optionally
>      *   transform the entity (into a value object for example).  By default, transformation does
>      *   not occur.
>      * </p>
>      */
>     public Object create(
>         int transform,
> #foreach($property in $requiredProperties)
>         $property.getterSetterTypeName $property.name#if($velocityCount != $requiredProperties.size()),#else);#end
> #end
> #end
> #end
> #end
>     /**
>      * Updates the <code>$argumentName</code> instance in the persistent store.
>      */
>     public void update($entity.fullyQualifiedEntityName $argumentName);
> #if ($hibernateUtils.xmlPersistenceActive)
>     /**
>      * Updates the <code>$argumentName</code> instance in the persistent store.
>      */
>     public void update(org.dom4j.Element $argumentName);
> #end
>     /**
>      * Updates all instances in the <code>entities</code> collection in the persistent store.
>      */
>     public void update($entityCollectionType entities);
>     /**
>      * Removes the instance of $entity.fullyQualifiedEntityName from the persistent store.
>      */
>     public void remove($entity.fullyQualifiedEntityName $argumentName);
> #if ($hibernateUtils.xmlPersistenceActive)
>     /**
>      * Removes the <code>$argumentName</code> instance in the persistent store.
>      */
>     public void remove(org.dom4j.Element $argumentName);
> #end
>     /**
>      * Removes the instance of $entity.fullyQualifiedEntityName having the given
>      * <code>identifier</code> from the persistent store.
>      */
>     public void remove($identifier.type.fullyQualifiedName $identifier.name);
>     /**
>      * Removes all entities in the given <code>entities<code> collection.
>      */
>     public void remove($entityCollectionType entities);
> #foreach ($operation in $entity.queryOperations)
> #set ($returnType = $operation.returnType.fullyQualifiedName)
>     /**
> $operation.getDocumentation("     * ")
>      */
> #if ($operation.exceptionsPresent)
>     $operation.visibility $returnType $operation.signature
>         throws $operation.exceptionList;
> #else
>     $operation.visibility $returnType $operation.signature;
> #end
> #if(!$operation.criteriaFinder)
>     /**
>      * <p>
>      *   Does the same thing as {@link #${operation.getSignature(false)}} with an
>      *   additional argument called <code>queryString</code>.  This <code>queryString</code>
>      *   argument allows you to override the query string defined in {@link #${operation.getSignature(false)}}.
>      * </p>
>      */
> #if ($operation.exceptionsPresent)
>     $operation.visibility $returnType ${operation.name}(String queryString#if(!$operation.arguments.empty), ${operation.typedArgumentList}#end)
>         throws $operation.exceptionList;
> #else
>     $operation.visibility $returnType ${operation.name}(String queryString#if(!$operation.arguments.empty), ${operation.typedArgumentList}#end);
> #end
> #if ($operation.query && !$operation.returnType.collectionType)
> #set ($returnType = "Object")
> #end
>     /**
>      * <p>
>      *   Does the same thing as {@link #${operation.getSignature(false)}} with an
>      *   additional flag called <code>transform</code>.  If this flag is set to <code>$entity.daoNoTransformationConstantName</code> then
>      *   finder results will <strong>NOT</strong> be transformed during retrieval.
>      *   If this flag is any of the other constants defined here
>      *   then finder results <strong>WILL BE</strong> passed through an operation which can optionally
>      *   transform the entities (into value objects for example).  By default, transformation does
>      *   not occur.
>      * </p>
>      */
> #if ($operation.exceptionsPresent)
>     $operation.visibility $returnType ${operation.name}(int transform#if(!$operation.arguments.empty), ${operation.typedArgumentList}#end)
>         throws $operation.exceptionList;
> #else
>     $operation.visibility $returnType ${operation.name}(int transform#if(!$operation.arguments.empty), ${operation.typedArgumentList}#end);
> #end
>     /**
>      * <p>
>      *   Does the same thing as {@link #${operation.name}(boolean#if(!$operation.arguments.empty), ${operation.argumentTypeNames}#end)} with an
>      *   additional argument called <code>queryString</code>.  This <code>queryString</code>
>      *   argument allows you to override the query string defined in {@link #${operation.name}(int#if(!$operation.arguments.empty), ${operation.typedArgumentList}#end)}.
>      * </p>
>      */
> #if ($operation.exceptionsPresent)
>     $operation.visibility $returnType ${operation.name}(int transform, String queryString#if(!$operation.arguments.empty), ${operation.typedArgumentList}#end)
>         throws $operation.exceptionList;
> #else
>     $operation.visibility $returnType ${operation.name}(int transform, String queryString#if(!$operation.arguments.empty), ${operation.typedArgumentList}#end);
> #end
> #else
>     /**
>      * <p>
>      *   Does the same thing as {@link #${operation.getSignature(false)}} with an
>      *   additional flag called <code>transform</code>.  If this flag is set to <code>$entity.daoNoTransformationConstantName</code> then
>      *   finder results will <strong>NOT</strong> be transformed during retrieval.
>      *   If this flag is any of the other constants defined here
>      *   then finder results <strong>WILL BE</strong> passed through an operation which can optionally
>      *   transform the entities (into value objects for example).  By default, transformation does
>      *   not occur.
>      * </p>
>      */
> #if ($operation.exceptionsPresent)
>     $operation.visibility $returnType ${operation.name}(final int transform#if(!$operation.arguments.empty), ${operation.getTypedArgumentList('final')}#end)
>         throws $operation.exceptionList;
> #else
>     $operation.visibility $returnType ${operation.name}(final int transform#if(!$operation.arguments.empty), ${operation.getTypedArgumentList('final')}#end);
> #end
> #end
> #end
> #foreach ($operation in $entity.daoBusinessOperations)
> #set ($returnType = $operation.returnType.fullyQualifiedName)
>     /**
> $operation.getDocumentation("     * ")
>      */
> #if ($operation.exceptionsPresent)
>     $operation.visibility $returnType $operation.signature
>         throws $operation.exceptionList;
> #else
>     $operation.visibility $returnType $operation.signature;
> #end
> #end
> }
> ************************************** SpringHibernateDaoBase.vsl ****************************************************
> #set ($generatedFile = "${entity.packagePath}/${entity.daoBaseName}.java")
> #if ($enableTemplating)
> #set ($entityCollectionType = "java.util.Collection<${entity.fullyQualifiedEntityName}>")
> #else
> #set ($entityCollectionType = "java.util.Collection")
> #end
> // license-header java merge-point
> //
> // Attention: Generated code! Do not modify by hand!
> // Generated by: SpringHibernateDaoBase.vsl in andromda-spring-cartridge.
> //
> #if ($stringUtils.isNotBlank($entity.packageName))
> package $entity.packageName;
> #end
> #set ($daoInheritance = $entity.generalization && $daoInheritanceEnabled)
> #if ($daoInheritance)
> #set ($rootEntityType = $entity.root.fullyQualifiedEntityName)
> #set ($rootDaoType = $entity.root.fullyQualifiedDaoName)
> #else
> #set ($rootEntityType = $entity.fullyQualifiedEntityName)
> #set ($rootDaoType = $entity.fullyQualifiedDaoName)
> #end
> /**
>  * <p>
>  * Base Spring DAO Class: is able to create, update, remove, load, and find
>  * objects of type <code>$entity.fullyQualifiedEntityName</code>.
>  * </p>
>  *
>  * @see $entity.fullyQualifiedEntityName
>  */
> public abstract class $entity.daoBaseName
> #if ($daoInheritance)
>     extends $entity.generalization.fullyQualifiedDaoImplementationName
> #else
>     extends ${hibernateUtils.springHibernatePackage}.support.HibernateDaoSupport
> #end
>     implements $entity.fullyQualifiedDaoName
> {
> #foreach($entityRef in $entity.entityReferences)
>     private $entityRef.targetElement.fullyQualifiedDaoName $entityRef.daoName;
>     /**
>      * Sets the reference to <code>$entityRef.daoName</code>.
>      */
>     public void ${entityRef.daoSetterName}($entityRef.targetElement.fullyQualifiedDaoName $entityRef.daoName)
>     {
>         this.$entityRef.daoName = $entityRef.daoName;
>     }
>     /**
>      * Gets the reference to <code>$entityRef.daoName</code>.
>      */
>     protected $entityRef.targetElement.fullyQualifiedDaoName ${entityRef.daoGetterName}()
>     {
>         return this.$entityRef.daoName;
>     }
> #end
> #set ($identifier = $entity.identifiers.iterator().next())
> #set ($argumentName = $stringUtils.uncapitalize($entity.name))
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#load(int, $identifier.type.fullyQualifiedName)
>      */
>     public Object load(final int transform, final $identifier.type.fullyQualifiedName $identifier.name)
>     {
> #set ($argument = $identifier.name)
> #if($identifier.type.primitive)
> #set ($argument = "new ${identifier.type.wrapperName}(${identifier.name})")
> #else
>         if ($argument == null)
>         {
>             throw new IllegalArgumentException(
>                 "${entity.name}.load - '$argument' can not be null");
>         }
> #end
> #if ($hibernateUtils.xmlPersistenceActive)
> #set ($xmlIndent = "    ")
>         if (transform == TRANSFORM_XML)
>         {
>             final Object entity = this.getHibernateTemplate().execute(
>                     new org.springframework.orm.hibernate3.HibernateCallback()
>                     {
>                         public Object doInHibernate(org.hibernate.Session hibernateSession)
>                             throws org.hibernate.HibernateException
>                         {
>                             org.hibernate.Session xmlSession = hibernateSession.getSession(org.hibernate.EntityMode.DOM4J);
>                             return xmlSession.get(${entity.fullyQualifiedEntityImplementationName}.class, $identifier.name);
>                         }
>                     },
>                     true);
>             return entity;
>         }
>         else
>         {
> #else
> #set ($xmlIndent = "")
> #end
> $xmlIndent        final Object entity = this.getHibernateTemplate().get(${entity.fullyQualifiedEntityImplementationName}.class, $identifier.name);
> $xmlIndent        return transformEntity(transform, ($entity.fullyQualifiedName)entity);
> #if ($hibernateUtils.xmlPersistenceActive)
>         }
> #end
>     }
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#load($identifier.type.fullyQualifiedName)
>      */
>     public $rootEntityType load($identifier.type.fullyQualifiedName $identifier.name)
>     {
>         return ($entity.fullyQualifiedEntityName)this.load($entity.daoNoTransformationConstantName, $identifier.name);
>     }
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#loadAll()
>      */
> #if ($enableTemplating)
>     @SuppressWarnings({"unchecked"})
> #end
>     public $entityCollectionType loadAll()
>     {
>         return ($entityCollectionType)this.loadAll(TRANSFORM_NONE);
>     }
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#loadAll(int)
>      */
>     public java.util.Collection loadAll(final int transform)
>     {
>         final java.util.Collection results = this.getHibernateTemplate().loadAll(${entity.fullyQualifiedEntityImplementationName}.class);
>         this.transformEntities(transform, results);
>         return results;
>     }
> ## Only add these methods if the entity isn't abstract
> #if (!$entity.abstract)
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#create($entity.fullyQualifiedEntityName)
>      */
>     public $rootEntityType create($entity.fullyQualifiedEntityName $argumentName)
>     {
>         return ($entity.fullyQualifiedEntityName)this.create($entity.daoNoTransformationConstantName, $argumentName);
>     }
> #if ($hibernateUtils.xmlPersistenceActive)
> #set ($identifier = $entity.identifiers.iterator().next())
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#create(org.dom4j.Element)
>      */
>     public $rootEntityType create(org.dom4j.Element $argumentName)
>     {
>        return ($entity.fullyQualifiedEntityName)this.create(TRANSFORM_NONE, $argumentName);
>     }
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#create(int transform, org.dom4j.Element)
>      */
>     public Object create(int transform, final org.dom4j.Element $argumentName)
>     {
>         if ($argumentName == null)
>         {
>             throw new IllegalArgumentException(
>                 "${entity.name}.create - '$argumentName' can not be null");
>         }
>         Object newID = this.getHibernateTemplate().execute(
>                 new org.springframework.orm.hibernate3.HibernateCallback()
>                 {
>                     public Object doInHibernate(org.hibernate.Session hibernateSession)
>                         throws org.hibernate.HibernateException
>                     {
>                         org.hibernate.Session xmlSession = hibernateSession.getSession(org.hibernate.EntityMode.DOM4J);
>                         return xmlSession.save("$entity.fullyQualifiedEntityImplementationName", $argumentName);
>                     }
>                 },
>                 true);
>         
>         return this.load(transform, ($identifier.type.fullyQualifiedName)newID);
>         
>     }
> #end
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#create(int transform, $entity.fullyQualifiedEntityName)
>      */
>     public Object create(final int transform, final $entity.fullyQualifiedName $argumentName)
>     {
>         if ($argumentName == null)
>         {
>             throw new IllegalArgumentException(
>                 "${entity.name}.create - '$argumentName' can not be null");
>         }
> #if ($hibernateUtils.xmlPersistenceActive)
> #set ($identifierProperty = "identifier")
> #if($identifier.type.primitive)
> #set ($identifierProperty = "(($identifier.type.wrapperName)$identifierProperty).${identifier.type.fullyQualifiedName}Value()")
> #else
> #set ($identifierProperty = "($identifier.type.fullyQualifiedName)$identifierProperty")
> #end
>         Object identifier = this.getHibernateTemplate().save($argumentName);
>         if (transform == TRANSFORM_XML)
>           return this.load(TRANSFORM_XML, (($identifierProperty)));
>         else
>           return this.transformEntity(transform, $argumentName);
> #else
>         this.getHibernateTemplate().save($argumentName);
>         return this.transformEntity(transform, $argumentName);
> #end
>     }
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#create($entityCollectionType)
>      */
> #if ($enableTemplating)
>     @SuppressWarnings({"unchecked"})
> #end
>     public $entityCollectionType create(final $entityCollectionType entities)
>     {
>         return create($entity.daoNoTransformationConstantName, entities);
>     }
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#create(int, $entityCollectionType)
>      */
>     public java.util.Collection create(final int transform, final $entityCollectionType entities)
>     {
>         if (entities == null)
>         {
>             throw new IllegalArgumentException(
>                 "${entity.name}.create - 'entities' can not be null");
>         }
>         this.getHibernateTemplate().execute(
>             new ${hibernateUtils.springHibernatePackage}.HibernateCallback()
>             {
> #if ($enableTemplating)
>                 @SuppressWarnings({"ForLoopReplaceableByForEach"})
> #end
>                 public Object doInHibernate(${hibernateUtils.basePackage}.Session session)
>                     throws ${hibernateUtils.basePackage}.HibernateException
>                 {
>                     for (java.util.Iterator entityIterator = entities.iterator(); entityIterator.hasNext();)
>                     {
>                         create(transform, ($entity.fullyQualifiedEntityName)entityIterator.next());
>                     }
>                     return null;
>                 }
>             },
>             true);
>         return entities;
>     }
> #if ($enableDaoPropertiesCreateMethod.equalsIgnoreCase('true'))
> #set ($attributes = $entity.getAttributes(true, $entity.usingAssignedIdentifier))
> #if (!$attributes.empty)
>     /**
>      * @see ${rootDaoType}#create(${entity.getAttributeTypeList(true, false)})
>      */
>     public $rootEntityType create(
> #foreach($attribute in $attributes)
>         $attribute.type.fullyQualifiedName $attribute.name#if($velocityCount != $attributes.size()),#else)#end
> #end
>     {
>         return ($rootEntityType)this.create($entity.daoNoTransformationConstantName, ${entity.getAttributeNameList(true, $entity.usingAssignedIdentifier)});
>     }
>     /**
>      * @see ${rootDaoType}#create(int, ${entity.getAttributeTypeList(true, false)})
>      */
>     public Object create(
>         final int transform,
> #foreach($attribute in $attributes)
>         $attribute.type.fullyQualifiedName $attribute.name#if($velocityCount != $attributes.size()),#else)#end
> #end
>     {
>         $entity.fullyQualifiedEntityName entity = new ${entity.fullyQualifiedEntityImplementationName}();
> #foreach ($attribute in $attributes)
>         entity.${attribute.setterName}($attribute.name);
> #end
>         return this.create(transform, entity);
>     }
> #end
> #set ($requiredProperties = $entity.getRequiredProperties(true,false))
> #if (!$requiredProperties.empty && $entity.getRequiredAttributes(true,false).size() != $requiredProperties.size())
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#create(${entity.getRequiredPropertyTypeList(true, false)})
>      */
>     public $rootEntityType create(
> #foreach($property in $requiredProperties)
>         $property.getterSetterTypeName $property.name#if($velocityCount != $requiredProperties.size()),#else)#end
> #end
>     {
>         return ($rootEntityType)this.create($entity.daoNoTransformationConstantName, ${entity.getRequiredPropertyNameList(true,false)});
>     }
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#create(int, ${entity.getRequiredPropertyTypeList(true, false)})
>      */
>     public Object create(
>         final int transform,
> #foreach($property in $requiredProperties)
>         $property.getterSetterTypeName $property.name#if($velocityCount != $requiredProperties.size()),#else)#end
> #end
>     {
>         $entity.fullyQualifiedEntityName entity = new ${entity.fullyQualifiedEntityImplementationName}();
> #foreach ($property in $requiredProperties)
>         entity.${property.setterName}($property.name);
> #end
>         return this.create(transform, entity);
>     }
> #end
> #end
> #end
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#update($entity.fullyQualifiedEntityName)
>      */
>     public void update($entity.fullyQualifiedEntityName $argumentName)
>     {
>         if ($argumentName == null)
>         {
>             throw new IllegalArgumentException(
>                 "${entity.name}.update - '$argumentName' can not be null");
>         }
>         this.getHibernateTemplate().update($argumentName);
>     }
> #if ($hibernateUtils.xmlPersistenceActive)
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#update(org.dom4j.Element)
>      */
>     public void update(final org.dom4j.Element $argumentName)
>     {
>         if ($argumentName == null)
>         {
>             throw new IllegalArgumentException(
>                 "${entity.name}.update - '$argumentName' can not be null");
>         }
>         this.getHibernateTemplate().execute(
>                 new org.springframework.orm.hibernate3.HibernateCallback()
>                 {
>                     public Object doInHibernate(org.hibernate.Session hibernateSession)
>                         throws org.hibernate.HibernateException
>                     {
>                         org.hibernate.Session xmlSession = hibernateSession.getSession(org.hibernate.EntityMode.DOM4J);
>                         xmlSession.update("$entity.fullyQualifiedEntityImplementationName", $argumentName);
>                         return null;
>                     }
>                 },
>                 true);
>     }
> #end
>     /**
>      * @see ${rootDaoType}#update($entityCollectionType)
>      */
>     public void update(final $entityCollectionType entities)
>     {
>         if (entities == null)
>         {
>             throw new IllegalArgumentException(
>                 "${entity.name}.update - 'entities' can not be null");
>         }
>         this.getHibernateTemplate().execute(
>             new ${hibernateUtils.springHibernatePackage}.HibernateCallback()
>             {
>                 public Object doInHibernate(${hibernateUtils.basePackage}.Session session)
>                     throws ${hibernateUtils.basePackage}.HibernateException
>                 {
>                     for (java.util.Iterator entityIterator = entities.iterator(); entityIterator.hasNext();)
>                     {
>                         update(($entity.fullyQualifiedEntityName)entityIterator.next());
>                     }
>                     return null;
>                 }
>             },
>             true);
>     }
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#remove($entity.fullyQualifiedEntityName)
>      */
>     public void remove($entity.fullyQualifiedEntityName $argumentName)
>     {
>         if ($argumentName == null)
>         {
>             throw new IllegalArgumentException(
>                 "${entity.name}.remove - '$argumentName' can not be null");
>         }
>         this.getHibernateTemplate().delete($argumentName);
>     }
> #if ($hibernateUtils.xmlPersistenceActive)
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#remove(org.dom4j.Element)
>      */
>     public void remove(final org.dom4j.Element $argumentName)
>     {
>         if ($argumentName == null)
>         {
>             throw new IllegalArgumentException(
>                 "${entity.name}.remove - '$argumentName' can not be null");
>         }
>         this.getHibernateTemplate().execute(
>                 new org.springframework.orm.hibernate3.HibernateCallback()
>                 {
>                     public Object doInHibernate(org.hibernate.Session hibernateSession)
>                         throws org.hibernate.HibernateException
>                     {
>                         org.hibernate.Session xmlSession = hibernateSession.getSession(org.hibernate.EntityMode.DOM4J);
>                         xmlSession.delete($argumentName);
>                         return null;
>                     }
>                 },
>                 true);
>     }
> #end
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#remove($identifier.type.fullyQualifiedName)
>      */
>     public void remove($identifier.type.fullyQualifiedName $identifier.name)
>     {
> #set ($argument = $identifier.name)
> #if($identifier.type.primitive)
> #set ($argument = "new ${identifier.type.wrapperName}(${identifier.name})")
> #else
>         if ($argument == null)
>         {
>             throw new IllegalArgumentException(
>                 "${entity.name}.remove - '$identifier.name' can not be null");
>         }
> #end
> #set ($loadCall = "this.load($identifier.name)")
> #if ($entity.generalization)
> #set ($loadCall = "($entity.fullyQualifiedEntityName)${loadCall}")
> #end
>         $entity.fullyQualifiedEntityName entity = $loadCall;
>         if (entity != null)
>         {
>             this.remove(entity);
>         }
>     }
>     /**
>      * @see ${rootDaoType}#remove($entityCollectionType)
>      */
>     public void remove($entityCollectionType entities)
>     {
>         if (entities == null)
>         {
>             throw new IllegalArgumentException(
>                 "${entity.name}.remove - 'entities' can not be null");
>         }
>         this.getHibernateTemplate().deleteAll(entities);
>     }
> #foreach ($finder in $entity.getQueryOperations(true))
> #set ($returnType = $finder.returnType.fullyQualifiedName)
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#$finder.getSignature(false)
>      */
>     $finder.visibility $returnType $finder.signature
> #if ($finder.exceptionsPresent)
>         throws $finder.exceptionList
> #end
>     {
> #set ($finderCall = "this.${finder.name}($entity.daoNoTransformationConstantName#if(!$finder.arguments.empty), ${finder.argumentNames}#end);")
> #if (!$finder.returnType.collectionType)
> #set ($finderCall = "($returnType)$finderCall")
> #end
>         return $finderCall
>     }
> #if(!$finder.criteriaFinder)
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#${finder.name}(java.lang.String#if(!$finder.arguments.empty), ${finder.argumentTypeNames}#end)
>      */
>     $finder.visibility $returnType ${finder.name}(final java.lang.String queryString#if(!$finder.arguments.empty), ${finder.getTypedArgumentList('final')}#end)
> #if ($finder.exceptionsPresent)
>         throws $finder.exceptionList
> #end
>     {
> #set ($finderCall = "this.${finder.name}($entity.daoNoTransformationConstantName, queryString#if(!$finder.arguments.empty), ${finder.argumentNames}#end);")
> #if (!$finder.returnType.collectionType)
> #set ($finderCall = "($returnType)$finderCall")
> #end
>         return $finderCall
>     }
> #if (!$finder.returnType.collectionType)
> #set ($returnType = "Object")
> #end
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#${finder.name}(int#if(!$finder.arguments.empty), ${finder.argumentTypeNames}#end)
>      */
>     $finder.visibility $returnType ${finder.name}(final int transform#if(!$finder.arguments.empty), ${finder.getTypedArgumentList('final')}#end)
> #if ($finder.exceptionsPresent)
>         throws $finder.exceptionList
> #end
>     {
>         return this.${finder.name}(transform, "$finder.getQuery($entity)"#if(!$finder.arguments.empty), ${finder.argumentNames}#end);
>     }
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#${finder.name}(int, java.lang.String#if(!$finder.arguments.empty), ${finder.argumentTypeNames}#end)
>      */
>     $finder.visibility $returnType ${finder.name}(final int transform, final java.lang.String queryString#if(!$finder.arguments.empty), ${finder.getTypedArgumentList('final')}#end)
> #if ($finder.exceptionsPresent)
>         throws $finder.exceptionList
> #end
>     {
>         try
>         {
>             ${hibernateUtils.basePackage}.Query queryObject = super.getSession(false).createQuery(queryString);
> #foreach($argument in $finder.arguments)
> #set ($count = $velocityCount - 1)
> #set ($argumentValue = $argument.name)
> #if($argument.type.primitive)
> #set ($argumentValue = "new ${argument.type.wrapperName}($argument.name)")
> #elseif ($argument.type.enumeration)
> #set ($argumentValue = "${argument.name}.getValue()")
> #end
> #set ($setParameterOperation = "setParameter")
> #if ($argument.type.collectionType || $argument.type.arrayType)
> #set ($setParameterOperation = "${setParameterOperation}List")
> #end
> #if ($finder.useNamedParameters)
>             queryObject.${setParameterOperation}("$argument.name", $argumentValue);
> #else
>             queryObject.${setParameterOperation}($count, $argumentValue);
> #end
> #end
> #if ($finder.returnType.setType || !$finder.returnType.collectionType)
>             java.util.Set results = new java.util.LinkedHashSet(queryObject.list());
> #else
>             java.util.List results = queryObject.list();
> #end
> #if (!$finder.returnType.collectionType)
>             Object result = null;
>             if (results != null)
>             {
>                 if (results.size() > 1)
>                 {
>                     throw new org.springframework.dao.InvalidDataAccessResourceUsageException(
>                         "More than one instance of '${finder.returnType.fullyQualifiedName}"
>                             + "' was found when executing query --> '" + queryString + "'");
>                 }
>                 else if (results.size() == 1)
>                 {
>                     result = ($entity.fullyQualifiedName)results.iterator().next();
>                 }
>             }
>             result = transformEntity(transform, ($entity.fullyQualifiedName)result);
>             return result;
> #else
>             transformEntities(transform, results);
>             return results;
> #end
>         }
>         catch (${hibernateUtils.basePackage}.HibernateException ex)
>         {
>             throw super.convertHibernateAccessException(ex);
>         }
>     }
> #else
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#${finder.name}(int, java.lang.String#if(!$finder.arguments.empty), ${finder.argumentTypeNames}#end)
>      */
>     $finder.visibility $returnType ${finder.name}(final int transform#if(!$finder.arguments.empty), ${finder.getTypedArgumentList('final')}#end)
> #if ($finder.exceptionsPresent)
>         throws $finder.exceptionList
> #end
>     {
> #set($criteriaArgument = $finder.criteriaArgument)
> #set($criteriaArgumentName = $criteriaArgument.name)
>         try
>         {
>             ${springTypesPackage}.${criteriaSearchBaseName} criteriaSearch = new ${springTypesPackage}.${criteriaSearchBaseName}(super.getSession(false), ${entity.fullyQualifiedEntityImplementationName}.class);
>             criteriaSearch.getConfiguration().setFirstResult(${criteriaArgumentName}.getFirstResult());
>             criteriaSearch.getConfiguration().setFetchSize(${criteriaArgumentName}.getFetchSize());
>             criteriaSearch.getConfiguration().setMaximumResultSize(${criteriaArgumentName}.getMaximumResultSize());
> #set($criteriaClass = $criteriaArgument.type)
> #foreach($criteriaAttribute in $criteriaClass.attributes)
> #if($criteriaAttribute.matchModePresent)
> #set($matchModeArgument = ", ${hibernateUtils.criterionPackage}.MatchMode.${criteriaAttribute.matchModeConstant}")
> #else
> #set($matchModeArgument = "")
> #end
> #if($criteriaAttribute.nullable)
> #set($nullableArgument = ", true")
> #else
> #set($nullableArgument = "")
> #end
> #if($criteriaAttribute.comparatorPresent)
> #set($comparatorArgument = ", ${springTypesPackage}.${criteriaSearchBaseName}Parameter.${criteriaAttribute.comparatorConstant}")
> #else
> #set($comparatorArgument = "")
> #end
> #set ($parameterName = "parameter${velocityCount}")
>             ${springTypesPackage}.${criteriaSearchBaseName}Parameter $parameterName =
>                 new ${springTypesPackage}.${criteriaSearchBaseName}Parameter(
>                     ${criteriaArgumentName}.${criteriaAttribute.getterName}(),
>                     "${criteriaAttribute.attributeName}"${nullableArgument}${comparatorArgument}${matchModeArgument});
> #if($criteriaAttribute.orderable)
>             ${parameterName}.setOrderDirection(${springTypesPackage}.${criteriaSearchBaseName}Parameter.$criteriaAttribute.orderDirection);
>             ${parameterName}.setOrderRelevance($criteriaAttribute.orderRelevance);
> #end
>             criteriaSearch.addParameter($parameterName);
> #end
> #if ($finder.returnType.setType)
>             java.util.Set results = criteriaSearch.executeAsSet();
> #else
>             java.util.List results = criteriaSearch.executeAsList();
> #end
>             transformEntities(transform, results);
>             return results;
>         }
>         catch (${hibernateUtils.basePackage}.HibernateException ex)
>         {
>             throw super.convertHibernateAccessException(ex);
>         }
>     }
> #end
> #end
> #foreach ($operation in $entity.daoBusinessOperations)
> #set ($returnType = $operation.returnType)
> #set ($signature = $operation.signature)
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#${operation.getSignature(false)}
>      */
>     $operation.visibility $returnType.fullyQualifiedName ${operation.name}(${operation.getTypedArgumentList('final')})
> #if ($operation.exceptionsPresent)
>         throws $operation.exceptionList
> #end
>     {
> #if ($requiredCheckEnabled)
> #foreach ($argument in $operation.arguments)
> #if ($argument.required && !$argument.type.primitive)
>         if ($argument.name == null)
>         {
>             throw new IllegalArgumentException(
>                 "${entity.fullyQualifiedDaoName}.${operation.signature} - '${argument.name}' can not be null");
>         }
> #end
> #end
> #end
>         try
>         {
> #set ($call = "this.${operation.implementationCall};")
> #if ($operation.returnTypePresent)
>             return $call
> #else
>             $call
> #end
>         }
> #foreach($exception in $operation.exceptions)
>         catch ($exception.fullyQualifiedName ex)
>         {
>             throw ex;
>         }
> #end
>         catch (Throwable th)
>         {
>             throw new java.lang.RuntimeException(
>             "Error performing '${entity.fullyQualifiedDaoName}.${operation.signature}' --> " + th,
>             th);
>         }
>     }
>      /**
>       * Performs the core logic for {@link #${operation.getSignature(false)}}
>       */
>     protected abstract $operation.returnType.fullyQualifiedName $operation.implementationSignature
>         throws java.lang.Exception;
> #end
>     /**
>      * Allows transformation of entities into value objects
>      * (or something else for that matter), when the <code>transform</code>
>      * flag is set to one of the constants defined in <code>$entity.fullyQualifiedDaoName</code>, please note
>      * that the {@link #$entity.daoNoTransformationConstantName} constant denotes no transformation, so the entity itself
>      * will be returned.
> #if (!$entity.valueObjectReferences.empty)
>      * <p/>
>      * This method will return instances of these types:
>      * <ul>
>      *   <li>{@link $entity.fullyQualifiedName} - {@link #$entity.daoNoTransformationConstantName}</li>
> #foreach ($valueObjectRef in $entity.valueObjectReferences)
> #set ($targetElement = $valueObjectRef.targetElement)
>      *   <li>{@link $targetElement.fullyQualifiedName} - {@link ${valueObjectRef.transformationConstantName}}</li>
> #end
>      * </ul>
> #end
>      *
>      * If the integer argument value is unknown {@link #${entity.daoNoTransformationConstantName}} is assumed.
>      *
>      * @param transform one of the constants declared in {@link $entity.fullyQualifiedDaoName}
>      * @param entity an entity that was found
>      * @return the transformed entity (i.e. new value object, etc)
>      * @see #transformEntities(int,java.util.Collection)
>      */
>     protected Object transformEntity(final int transform, final $entity.fullyQualifiedName entity)
>     {
>         Object target = null;
>         if (entity != null)
>         {
>             switch (transform)
>             {
> #foreach ($valueObjectRef in $entity.allValueObjectReferences)
> ##
> ## When not using daoInheritance, we _must_ refer to the TransformationConstantNames defined in our own interface (and
> ## not, as is the case for dao inheritance, to those defined in the super-dao's interface).
> ##
> #if ($daoInheritance)
>                 case ${valueObjectRef.sourceElement.fullyQualifiedDaoName}.${valueObjectRef.transformationConstantName} :
> #else
>                 case ${valueObjectRef.transformationConstantName} :
> #end
>                     target = ${valueObjectRef.transformationMethodName}(entity);
>                     break;
> #end
>                 case $entity.daoNoTransformationConstantName : // fall-through
>                 default:
>                     target = entity;
>             }
>         }
>         return target;
>     }
>     /**
>      * Transforms a collection of entities using the
>      * {@link #transformEntity(int,$entity.fullyQualifiedName)}
>      * method. This method does not instantiate a new collection.
>      * <p/>
>      * This method is to be used internally only.
>      *
>      * @param transform one of the constants declared in <code>$entity.fullyQualifiedDaoName</code>
>      * @param entities the collection of entities to transform
>      * @return the same collection as the argument, but this time containing the transformed entities
>      * @see #transformEntity(int,$entity.fullyQualifiedName)
>      */
>     protected void transformEntities(final int transform, final java.util.Collection entities)
>     {
>         switch (transform)
>         {
> #foreach ($valueObjectRef in $entity.allValueObjectReferences)
> ##
> ## When not using daoInheritance, we _must_ refer to our TransformationConstantNames (see comment above).
> ##
> #if ($daoInheritance)
>             case ${valueObjectRef.sourceElement.fullyQualifiedDaoName}.${valueObjectRef.transformationConstantName} :
> #else
>             case ${valueObjectRef.transformationConstantName} :
> #end
>                 ${valueObjectRef.transformationToCollectionMethodName}(entities);
>                 break;
> #end
>             case $entity.daoNoTransformationConstantName : // fall-through
>                 default:
>                 // do nothing;
>         }
>     }
> ##
> ## When daoInheritance is disabled we need to generated the transformations for _all_ of our value object
> ## references (and not only "ours" as is the case when daoInheritance is enabled).
> ##
> #if ($daoInheritance)
> #set ($valueObjectReferences = $entity.valueObjectReferences)
> #else
> #set ($valueObjectReferences = $entity.allValueObjectReferences)
> #end
> ##
> #foreach ($valueObjectRef in $valueObjectReferences)
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#${valueObjectRef.transformationToCollectionMethodName}(java.util.Collection)
>      */
>     public final void ${valueObjectRef.transformationToCollectionMethodName}(java.util.Collection entities)
>     {
>         if (entities != null)
>         {
>             org.apache.commons.collections.CollectionUtils.transform(entities, ${valueObjectRef.transformationAnonymousName});
>         }
>     }
>     /**
>      * Default implementation for transforming the results of a report query into a value object. This
>      * implementation exists for convenience reasons only. It needs only be overridden in the
>      * {@link $entity.daoImplementationName} class if you intend to use reporting queries.
>      * @see ${entity.fullyQualifiedDaoName}#${valueObjectRef.transformationMethodName}($entity.fullyQualifiedName)
>      */
>     protected $valueObjectRef.targetElement.fullyQualifiedName ${valueObjectRef.transformationMethodName}(Object[] row)
>     {
>         $valueObjectRef.targetElement.fullyQualifiedName target = null;
>         if (row != null)
>         {
>             final int numberOfObjects = row.length;
>             for (int ctr = 0; ctr < numberOfObjects; ctr++)
>             {
>                 final Object object = row[ctr];
>                 if (object instanceof $entity.fullyQualifiedEntityName)
>                 {
>                     target = this.${valueObjectRef.transformationMethodName}(($entity.fullyQualifiedEntityName)object);
>                     break;
>                 }
>             }
>         }
>         return target;
>     }
>     /**
>      * This anonymous transformer is designed to transform entities or report query results
>      * (which result in an array of objects) to {@link ${valueObjectRef.targetElement.fullyQualifiedName}}
>      * using the Jakarta Commons-Collections Transformation API.
>      */
>     private org.apache.commons.collections.Transformer $valueObjectRef.transformationAnonymousName =
>         new org.apache.commons.collections.Transformer()
>         {
>             public Object transform(Object input)
>             {
>                 Object result = null;
>                 if (input instanceof $entity.fullyQualifiedEntityName)
>                 {
>                     result = ${valueObjectRef.transformationMethodName}(($entity.fullyQualifiedEntityName)input);
>                 }
>                 else if (input instanceof Object[])
>                 {
>                     result = ${valueObjectRef.transformationMethodName}((Object[])input);
>                 }
>                 return result;
>             }
>         };
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#${valueObjectRef.transformationToEntityCollectionMethodName}(java.util.Collection)
>      */
>     public final void ${valueObjectRef.transformationToEntityCollectionMethodName}(java.util.Collection instances)
>     {
>         if (instances != null)
>         {
>             for (final java.util.Iterator iterator = instances.iterator(); iterator.hasNext();)
>             {
>                 // - remove an objects that are null or not of the correct instance
>                 if (!(iterator.next() instanceof $valueObjectRef.targetElement.fullyQualifiedName))
>                 {
>                     iterator.remove();
>                 }
>             }
>             org.apache.commons.collections.CollectionUtils.transform(instances, $valueObjectRef.valueObjectToEntityTransformerName);
>         }
>     }
>     private final org.apache.commons.collections.Transformer $valueObjectRef.valueObjectToEntityTransformerName =
>         new org.apache.commons.collections.Transformer()
>         {
>             public Object transform(Object input)
>             {
>                 return ${valueObjectRef.transformationToEntityMethodName}(($valueObjectRef.targetElement.fullyQualifiedName)input);
>             }
>         };
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#${valueObjectRef.transformationMethodName}($entity.fullyQualifiedEntityName, $valueObjectRef.targetElement.fullyQualifiedName)
>      */
>     public void ${valueObjectRef.transformationMethodName}(
>         $entity.fullyQualifiedEntityName source, 
>         $valueObjectRef.targetElement.fullyQualifiedName target)
>     {
> #set ($entityProperties = $entity.allProperties)
> #foreach ($property in $valueObjectRef.targetElement.allProperties)
> #* *##foreach ($entityProperty in $entityProperties)
> #*    *##if ($property.name.equals($entityProperty.name))
> #*        *##set ($entityPropertyGetterValue = false)
> #*        *##set ($entityPropertyGetterValue = $converter.typeConvert($entityProperty.type.fullyQualifiedName, "source.${entityProperty.getterName}()", $property.type.fullyQualifiedName))
> #*        *##if ($entityPropertyGetterValue)
>         target.${property.setterName}($entityPropertyGetterValue);
> #*        *##else
>         // No conversion for target.${property.name} (can't convert source.${entityProperty.getterName}():${entityProperty.type.fullyQualifiedName} to $property.type.fullyQualifiedName)
> #*        *##end
> #*    *##end
> #* *##end
> #end
>     }
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#${valueObjectRef.transformationMethodName}($entity.fullyQualifiedName)
>      */
>     public $valueObjectRef.targetElement.fullyQualifiedName ${valueObjectRef.transformationMethodName}(final $entity.fullyQualifiedName entity)
>     {
>         final $valueObjectRef.targetElement.fullyQualifiedName target = new ${valueObjectRef.targetElement.fullyQualifiedName}();
>         this.${valueObjectRef.transformationMethodName}(entity, target);
>         return target;
>     }
>     
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#${valueObjectRef.transformationToEntityMethodName}($valueObjectRef.targetElement.fullyQualifiedName, $entity.fullyQualifiedEntityName)
>      */
>     public void ${valueObjectRef.transformationToEntityMethodName}(
>         $valueObjectRef.targetElement.fullyQualifiedName source,
>         $entity.fullyQualifiedEntityName target,
>         boolean copyIfNull)
>     {
> #set ($entityAttributes = $entity.getAttributes(true, $entity.usingAssignedIdentifier))
> #foreach ($entityProperty in $entityAttributes)
> #* *##if (!$entityProperty.readOnly)
> #*    *##foreach ($property in $valueObjectRef.targetElement.allProperties)
> #*        *##if ($property.name.equals($entityProperty.name))
> #*            *##set ($propertyGetterValue = false)
> #*            *##set ($propertyGetterValue = $converter.typeConvert($property.type.fullyQualifiedName, "source.${property.getterName}()", $entityProperty.type.fullyQualifiedName))
> #*            *##if ($propertyGetterValue)
>         if (copyIfNull || source.${property.getterName}() != $property.type.javaNullString)
>         {
>             target.${entityProperty.setterName}($propertyGetterValue);
>         }
> #*            *##else
>         // No conversion for target.${entityProperty.name} (can't convert source.${property.getterName}():${property.type.fullyQualifiedName} to $entityProperty.type.fullyQualifiedName)
> #*            *##end        
> #*        *##end
> #*    *##end
> #**##end
> #end
>     }
>     
> #end
> }
> ************************************************ SpringHibernateDaoImpl.vsl ************************************************
> #set ($generatedFile = "${entity.packagePath}/${entity.daoImplementationName}.java")
> // license-header java merge-point
> #if ($entity.daoImplementationRequired)
> /**
>  * This is only generated once! It will never be overwritten.
>  * You can (and have to!) safely modify it by hand.
>  */
> #else
> //
> // Attention: Generated code! Do not modify by hand!
> // Generated by: SpringHibernateDaoImpl.vsl in andromda-spring-cartridge.
> //
> #end
> #if ($stringUtils.isNotBlank($entity.packageName))
> package $entity.packageName;
> #end
> ##
> #set ($daoInheritance = $entity.generalization && $daoInheritanceEnabled)
> ##
> /**
>  * @see $entity.fullyQualifiedName
>  */
> public class $entity.daoImplementationName
>     extends $entity.fullyQualifiedDaoBaseName
> {
> #foreach ($operation in $entity.daoBusinessOperations)
> #set ($returnType = $operation.returnType)
> #set ($returnObject = "returnValue")
> #set ($signature = $operation.implementationSignature)
>     /**
>      * @see ${entity.fullyQualifiedDaoName}#${operation.getSignature(false)}
>      */
>     protected $returnType.fullyQualifiedName $signature
> #if ($operation.exceptionsPresent)
>         throws $operation.exceptionList
> #end
>     {
>         // ${toDoTag} implement $operation.visibility $returnType.fullyQualifiedName $signature
> #if ($operation.returnTypePresent)
>         return $operati...
 
[truncated message content]