basicrenderer.java

hibernate框架例子程序

//$Id: BasicRenderer.java,v 1.16.2.4 2004/05/24 19:04:10 maxcsaucdk Exp $
package net.sf.hibernate.tool.hbm2java;

import java.io.PrintWriter;
import java.io.Serializable;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import net.sf.hibernate.util.StringHelper;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class BasicRenderer extends AbstractRenderer {
	
	static final protected int ORDINARY = 0;
	static final protected int BOUND = 1;
	static final protected int CONSTRAINT = 3;//any constraint properties are bound as well

	private static Log log = LogFactory.getLog(BasicRenderer.class);
	JavaTool javaTool = new JavaTool();
	
 	public void render(String savedToPackage, String savedToClass, ClassMapping classMapping, Map class2classmap, PrintWriter mainwriter) throws Exception {
 		
 		
        genPackageDelaration(savedToPackage, classMapping, mainwriter);
        mainwriter.println();
    
        // switch to another writer to be able to insert the actually
        // used imports when whole class has been rendered. 
        StringWriter strWriter = new StringWriter();
        PrintWriter writer = new PrintWriter(strWriter);
        
    
        // class declaration
        if(classMapping.getMeta("class-description")==null) {
            writer.println("/** @author Hibernate CodeGenerator */");
        } else {
            writer.println("/** \n" + javaTool.toJavaDoc(classMapping.getMetaAsString("class-description"),0)  + "*/");   
        }
        
        String classScope = classMapping.getScope();
        String declarationType = classMapping.getDeclarationType();
        

        classMapping.addImport(Serializable.class);
        //String modifiers = classMapping.getModifiers();
        if(classMapping.shouldBeAbstract() && (classScope.indexOf("abstract")==-1)) {
            writer.print( "abstract " + classScope + " " + declarationType + " " + savedToClass );
        } else {
            writer.print( classScope +  " " + declarationType + " " + savedToClass );    
        }
    
        if(generateConcreteEmptyClasses()) {
        	writer.print(" extends " + getProperty("baseclass-prefix","Base") + classMapping.getName());
        } else {
        	if(javaTool.hasExtends(classMapping)) {
        		writer.print(" extends " + javaTool.getExtends(classMapping));
        	}
        }
        
		if(javaTool.hasImplements(classMapping)) {
			writer.print(" implements " + javaTool.getImplements(classMapping));
		}
        
        writer.println(" {");
        writer.println();
        
        // switch to another writer to be able to insert the 
        // veto- and changeSupport fields
        StringWriter strPropWriter = new StringWriter();
        PrintWriter propWriter = new PrintWriter(strPropWriter);

        String vetoSupport = null, changeSupport = null;
        int fieldTypes = 0;
        
        if(!generateConcreteEmptyClasses()) {
        	if(!classMapping.isInterface()) {
        		/*doFieldNameConstants(classMapping, propWriter);*/
        		doFields(classMapping, class2classmap, propWriter);
        		doConstructors(savedToClass, classMapping, class2classmap, propWriter);
        	}
        	
        	vetoSupport = makeSupportField("vetos", classMapping.getAllFields());
        	changeSupport = makeSupportField("changes", classMapping.getAllFields());    
        	fieldTypes = doFieldAccessors(classMapping, class2classmap, propWriter, vetoSupport, changeSupport);
        	
        	if(!classMapping.isInterface()) {
        		doSupportMethods(fieldTypes, vetoSupport, changeSupport, propWriter);
        		
        		doToString(classMapping, propWriter);
        		
        		doEqualsAndHashCode(savedToClass,classMapping, propWriter);
        		
        	}
        	if(classMapping.getMeta("class-code")!=null) {
        		propWriter.println("// The following is extra code specified in the hbm.xml files");
        		List extras = classMapping.getMeta("class-code");
        		Iterator iter = extras.iterator();
        		while (iter.hasNext()) {
        			String code = iter.next().toString();
        			propWriter.println(code);	
        		}
        		
        		propWriter.println("// end of extra code specified in the hbm.xml files");
        	}
        } else {
        	// only put in constructors when base-generation is active
        	doConstructors(savedToClass, classMapping, class2classmap, propWriter);
        }
        
     	propWriter.println("}");
	      
        //insert change and VetoSupport
        if(!classMapping.isInterface() && generateConcreteEmptyClasses()) {
        	doSupports(fieldTypes, classMapping, vetoSupport, changeSupport, writer);
        }
        
        writer.print(strPropWriter.toString());
        
        
        // finally write the imports
        doImports(classMapping, mainwriter);
        mainwriter.print(strWriter.toString());
        
        
    }

	private String getProperty(String key, String defaultValue) {
		return properties.getProperty(key, defaultValue);
	}

	/**
	 * Method doSupportMethods.
	 * @param fieldTypes
	 * @param vetoSupport
	 * @param changeSupport
	 * @param propWriter
	 */
	private void doSupportMethods(
		int fieldTypes,
		String vetoSupport,
		String changeSupport,
		PrintWriter writer) {
			if((fieldTypes&CONSTRAINT)==CONSTRAINT) {
				writer.println("    public void addVetoableChangeListener( VetoableChangeListener l ) {");
				writer.println("        "+vetoSupport+".addVetoableChangeListener(l);");
				writer.println("    }");
				writer.println("    public void removeVetoableChangeListener( VetoableChangeListener l ) {");
				writer.println("        "+vetoSupport+".removeVetoableChangeListener(l);");
				writer.println("    }");
				writer.println();
			}
			if((fieldTypes&BOUND)==BOUND) {
				writer.println("    public void addPropertyChangeListener( PropertyChangeListener l ) {");
				writer.println("        "+changeSupport+".addPropertyChangeListener(l);");
				writer.println("    }");
				writer.println("    public void removePropertyChangeListener( PropertyChangeListener l ) {");
				writer.println("        "+changeSupport+".removePropertyChangeListener(l);");
				writer.println("    }");
				writer.println();
			}
	}


	/**
	 * Method doSupports.
	 * @param vetoSupport
	 * @param changeSupport
	 * @param writer
	 */
	private void doSupports( int fieldTypes, 
											ClassMapping classMapping,
											String vetoSupport,
											String changeSupport,
											PrintWriter writer) {
			if((fieldTypes&CONSTRAINT)==CONSTRAINT) {
				writer.println( "    private VetoableChangeSupport "+vetoSupport+
					" = new VetoableChangeSupport(this);" );
				classMapping.getImports().add("java.beans.VetoableChangeSupport");
				classMapping.getImports().add("java.beans.PropertyVetoException");
				classMapping.getImports().add("java.beans.VetoableChangeListener");
			}
			if((fieldTypes&BOUND)==BOUND) {
				writer.println( "    private PropertyChangeSupport "+changeSupport+
					" = new PropertyChangeSupport(this);" );
				writer.println();
				classMapping.getImports().add("java.beans.PropertyChangeSupport");
				classMapping.getImports().add("java.beans.PropertyChangeListener");
			}
	}


	public void doConstructors(String savedToClass, ClassMapping classMapping, Map class2classmap, PrintWriter writer) {
		// full constructor
		List allFieldsForFullConstructor = classMapping.getAllFieldsForFullConstructor();
		
		writer.println("    /** full constructor */");
		String fullCons = "    public " + savedToClass + StringHelper.OPEN_PAREN;
		
		fullCons += javaTool.fieldsAsParameters(allFieldsForFullConstructor, classMapping, class2classmap);
		
		writer.println(fullCons + ") {");
		
		if(!generateConcreteEmptyClasses()) {
			//invoke super to initialize superclass...
			List supersConstructorFields = classMapping.getFieldsForSupersFullConstructor();
			if (!supersConstructorFields.isEmpty()) {
				writer.print("        super(");
				for (Iterator fields = supersConstructorFields.iterator(); fields.hasNext();) {
					FieldProperty field = (FieldProperty) fields.next();
					writer.print(field.getFieldName());
					if(fields.hasNext()) {
						writer.print(", ");
					}
				}
				writer.println(");");
			}
			
			// initialisation of localfields
			for(Iterator fields = classMapping.getLocalFieldsForFullConstructor().iterator(); fields.hasNext();) {
				FieldProperty field = (FieldProperty) fields.next();
				if(field.isGeneratedAsProperty()) {
					writer.println("        this." + field.getFieldName() + " = " + field.getFieldName() + ";");
				}
			}
		} else {
			// invoke base class constructor 
			List supersConstructorFields = classMapping.getAllFieldsForFullConstructor();
			if (!supersConstructorFields.isEmpty()) {
				writer.print("        super(");
				for (Iterator fields = supersConstructorFields.iterator(); fields.hasNext();) {
					FieldProperty field = (FieldProperty) fields.next();
					writer.print(field.getFieldName());
					if(fields.hasNext()) {
						writer.print(", ");
					}
				}
				writer.println(");");
			}
		}
		
		writer.println("    }");
		writer.println();
		
		// no args constructor (if fullconstructor had any arguments!)
		if (allFieldsForFullConstructor.size() > 0) {
		    writer.println("    /** default constructor */");
			writer.println("    public " + savedToClass + "() {");
			writer.println("    }");
			writer.println();
		}
		
		// minimal constructor (only if the fullconstructor had any arguments)
		if ((allFieldsForFullConstructor.size() > 0) && classMapping.needsMinimalConstructor()) {
		
		    List allFieldsForMinimalConstructor = classMapping.getAllFieldsForMinimalConstructor();
		    writer.println("    /** minimal constructor */"); 
		
		    String minCons = "    public " + savedToClass + "(";
		    for (Iterator fields = allFieldsForMinimalConstructor.iterator(); fields.hasNext();) {
		        FieldProperty field = (FieldProperty) fields.next();
		        minCons = minCons + JavaTool.shortenType(JavaTool.getTrueTypeName(field, class2classmap), classMapping.getImports()) + " " + field.getFieldName();
		        if (fields.hasNext()) {
		            minCons = minCons + ", ";
		        }
		    }
		
		    writer.println(minCons + ") {");
		    if(!generateConcreteEmptyClasses()) {
		    	// invoke super to initialize superclass...
		    	List supersMinConstructorFields = classMapping.getFieldsForSupersMinimalConstructor();
		    	if (!supersMinConstructorFields.isEmpty()) {
		    		writer.print("      super(");
		    		for (Iterator fields = supersMinConstructorFields.iterator(); fields.hasNext();) {
		    			FieldProperty field = (FieldProperty) fields.next();
		    			writer.print(field.getFieldName());
		    			if(fields.hasNext()) {
		    				writer.print(StringHelper.COMMA_SPACE);
		    			}
		    		}
		    		writer.println(");");
		    	}
		    	
		    	// initialisation of localfields
		    	for (Iterator fields = classMapping.getLocalFieldsForMinimalConstructor().iterator(); fields.hasNext();) {
		    		FieldProperty field = (FieldProperty) fields.next();
		    		if(field.isGeneratedAsProperty()) {
		    			writer.println("        this." + field.getFieldName() + " = " + field.getFieldName() + ";");
		    		}
		    	}
		    } else {
		    	List supersMinConstructorFields = classMapping.getAllFieldsForMinimalConstructor();
			    if (!supersMinConstructorFields.isEmpty()) {
			    	writer.print("      super(");
			    	for (Iterator fields = supersMinConstructorFields.iterator(); fields.hasNext();) {
			    		FieldProperty field = (FieldProperty) fields.next();
			    		writer.print(field.getFieldName());
			    		if(fields.hasNext()) {
			    			writer.print(StringHelper.COMMA_SPACE);
			    		}
			    	}
			    	writer.println(");");
			    }			    	
		    }
		    writer.println("    }");
		    writer.println();
		}