Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * #%L
   * EUGene :: Java templates
   * 
   * $Id: JavaBeanTransformer.java 1216 2012-12-10 00:29:12Z tchemit $
   * $HeadURL: http://svn.nuiton.org/svn/eugene/tags/eugene-2.6.1/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaBeanTransformer.java $
   * %%
   * Copyright (C) 2004 - 2012 CodeLutin, Tony Chemit
   * %%
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as 
  * published by the Free Software Foundation, either version 3 of the 
  * License, or (at your option) any later version.
  * 
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Lesser Public License for more details.
  * 
  * You should have received a copy of the GNU General Lesser Public 
  * License along with this program.  If not, see
  * <http://www.gnu.org/licenses/lgpl-3.0.html>.
  * #L%
  */
 package org.nuiton.eugene.java;
 
 
 import java.util.List;
 import java.util.Set;




JavaBeanTransformer generates simple bean with pcs support (and nothing else) according to the JavaBeans 1.1 norm. Since version 2.2.1, it is possible to

Author(s):
tchemit <chemit@codelutin.com>
Since:
2.0.2
Plexus.component:
role="org.nuiton.eugene.Template" role-hint="org.nuiton.eugene.java.JavaBeanTransformer"
 
 
     private static final Log log = LogFactory.getLog(JavaBeanTransformer.class);
 
     @Override
     public void transformFromClass(ObjectModelClass input) {
 
         if (!JavaTemplatesGeneratorUtil.hasBeanStereotype(input)) {
 
             //  not a bean
             return;
         }
 
         ObjectModelClass output = null;
 
         if (canGenerateAbstract(input)) {
 
             // nothing more to do
             output = generateAbstract(input);
         }
 
         if (canGenerateImpl(inputoutput)) {
 
             generateImpl(input);
         }
     }
 
     protected boolean canGenerateAbstract(ObjectModelClass input) {
         boolean b = !isInClassPath(input);
         return b;
     }
 
     protected boolean canGenerateImpl(ObjectModelClass input,
                                       ObjectModelClass abstractOutput) {
         String fqn = input.getQualifiedName() + "Impl";
 
         if (isInClassPath(fqn)) {
 
             // already in class-path
             return false;
         }
        Collection<ObjectModelOperationoperations = input.getOperations();
        if (!operations.isEmpty()) {
            // this input have some specific operations (so Impl can not be generated)
            return false;
        }
        Collection<ObjectModelOperationallOtherOperations =
                input.getAllOtherOperations(true);
        if (!allOtherOperations.isEmpty()) {
            Collection<ObjectModelOperationallExistingOperations =
                    new ArrayList<ObjectModelOperation>(input.getAllSuperclassOperations(true));
            if (abstractOutput!=null) {
                allExistingOperations.addAll(abstractOutput.getOperations());
            }
            for (ObjectModelOperation operation : allOtherOperations) {
                if (!allExistingOperations.contains(operation)) {
                    // found one method not on super classe, so can't generate Impl
                    return false;
                }
            }
        }
        return true;
//        boolean hasOperations = !allOtherOperations.isEmpty() ||
//                                !operations.isEmpty();
//
//        // generate only if no user operations found
//        return !hasOperations;
    }
    protected void createAbstractOperations(ObjectModelClass ouput,
                                            Iterable<ObjectModelOperationoperations) {
        JavaGeneratorUtil.cloneOperations(
                this,
                operations,
                ouput,
                true,
                .
        );
    }
        // test if a super class has bean stereotype
        boolean superClassIsBean = false;
        Collection<ObjectModelClasssuperclasses = input.getSuperclasses();
        if(CollectionUtils.isNotEmpty(superclasses)) {
            for (ObjectModelClass superclass : superclasses) {
                if (JavaTemplatesGeneratorUtil.hasBeanStereotype(superclass)) {
                    superClassIsBean = true;
                    break;
                }
            }
        }
        String superClass = null;
        if (!superClassIsBean) {
            // try to find a super class by tag-value
            superClass =
                    JavaTemplatesGeneratorUtil.getBeanSuperClassTagValue(
                            input);
            if (superClass != null) {
                // will act as if super class is a bean
                superClassIsBean = true;
            }
        }
        ObjectModelClass output =
                createAbstractClass(input.getName(), input.getPackageName());
        if (superClass != null) {
            setSuperClass(outputsuperClass);
        }
        if (.isDebugEnabled()) {
            .debug("will generate " + output.getQualifiedName());
        }
        String i18nPrefix = JavaGeneratorUtil.getI18nPrefixTagValue(input);
        if (!StringUtils.isEmpty(i18nPrefix)) {
            generateI18nBlock(inputoutputi18nPrefix);
        }
        String noPCSTagValue = JavaTemplatesGeneratorUtil.getNoPCSTagValue(input);
        boolean usePCS = StringUtils.isEmpty(noPCSTagValue) ||
                         !"true".equals(noPCSTagValue.trim());
        String noGenerateBooleanGetMethods =
                JavaGeneratorUtil.getDoNotGenerateBooleanGetMethods(input);
        boolean generateBooleanGetMethods =
                StringUtils.isEmpty(noGenerateBooleanGetMethods) ||
                !"true".equals(noGenerateBooleanGetMethods.trim());
        String prefix = getConstantPrefix(input);
        setConstantPrefix(prefix);
        addSuperClass(inputoutput);
        boolean serializableFound = addInterfaces(inputoutput);
        if (superClassIsBean) {
            serializableFound = true;
        }
        addSerializable(inputoutputserializableFound);
        Set<StringconstantNames = addConstantsFromDependency(inputoutput);
        // Get available properties
        List<ObjectModelAttributeproperties = getProperties(input);
        // Add properties constant
        for (ObjectModelAttribute attr : properties) {
            createPropertyConstant(outputattrprefixconstantNames);
        }
        // Add properties field + javabean methods
        for (ObjectModelAttribute attr : properties) {
            createProperty(outputattrusePCSgenerateBooleanGetMethods);
        }
        // Add operations
        createAbstractOperations(outputinput.getOperations());
        if (!superClassIsBean) {
            if (usePCS) {
                // Add property change support
                createPropertyChangeSupport(output);
            }
        }
        boolean hasAMultipleProperty = containsMutiple(properties);
        // Add helper operations
        if (hasAMultipleProperty) {
            if (!superClassIsBean) {
                // add getChild methods
                createGetChildMethod(output);
            }
        }
        return output;
    }
    protected ObjectModelClass generateImpl(ObjectModelClass input) {
        ObjectModelClass resultClassImpl = createClass(
                input.getName() + "Impl",
                input.getPackageName()
        );
        // set the abstract resulClass as the resultClassImpl super class
        setSuperClass(resultClassImplinput.getQualifiedName());
        // add a fix serialVersionUID, since the class has no field nor method
        addConstant(resultClassImpl,
                    .,
                    "long",
                    "1L",
                    .
        );
        return resultClassImpl;
    }
    protected void addSuperClass(ObjectModelClass input,
                                 ObjectModelClass output) {
        // Set superclass
        Iterator<ObjectModelClassj = input.getSuperclasses().iterator();
        if (j.hasNext()) {
            ObjectModelClass p = j.next();
            // We want to set the inheritance to the implementation class of the father
            // Ex for model : A -> B (a inherits B) we want : A -> BImpl -> B
            String qualifiedName = p.getQualifiedName() + "Impl";
            setSuperClass(outputqualifiedName);
        }
    }
New to GrepCode? Check out our FAQ X