generatedsleeve.java

package sample.app.client;

import com.google.gwt.core.client.GWT;
import com.harmonic.electra.skel.generated.CSDChassis;

public class ChassisBuilderImpl implements sample.app.client.XmlRead.ChassisBuilder {
  public static interface GEN_ extends com.google.gwt.query.client.builders.XmlBuilder{
  public com.harmonic.electra.skel.generated.CSDChassis.Config getConfig();
  public void setConfig(com.harmonic.electra.skel.generated.CSDChassis.Config value);
  public com.harmonic.electra.skel.generated.CSDChassis.Status getStatus();
  public void setStatus(com.harmonic.electra.skel.generated.CSDChassis.Status value);
  public com.harmonic.electra.skel.generated.CSDChassis.Cards getCards();
  public void setCards(com.harmonic.electra.skel.generated.CSDChassis.Cards value);
  public com.harmonic.electra.skel.generated.CSDChassis.SLs getSLs();
  public void setSLs(com.harmonic.electra.skel.generated.CSDChassis.SLs value);
  public com.harmonic.electra.skel.generated.CSDChassis.Transports getTransports();
  public void setTransports(com.harmonic.electra.skel.generated.CSDChassis.Transports value);
  public com.harmonic.electra.skel.generated.CSDChassis.TransportIns getTransportIns();
  public void setTransportIns(com.harmonic.electra.skel.generated.CSDChassis.TransportIns value);
  public com.harmonic.electra.skel.generated.CSDChassis.Pools getPools();
  public void setPools(com.harmonic.electra.skel.generated.CSDChassis.Pools value);
  public java.lang.String getXmlVersion();
  public void setXmlVersion(java.lang.String value);
  public java.lang.String getAction();
  public void setAction(java.lang.String value);
  public java.lang.String getType();
  public void setType(java.lang.String value);
  public java.lang.String getIndexId();
  public void setIndexId(java.lang.String value);
  public java.lang.String getCodeVersion();
  public void setCodeVersion(java.lang.String value);
  public java.lang.String getUser();
  public void setUser(java.lang.String value);
  };
   public  com.harmonic.electra.skel.generated.CSDChassis deserialize ( Object istream ) { 
  com.harmonic.electra.skel.generated.CSDChassis ret = new com.harmonic.electra.skel.generated.CSDChassis();
   GEN_ proxy =    GWT.create( GEN_.class) ; 
    proxy = proxy.load ( istream ) ;
  ret.setConfig( proxy.getConfig());
  ret.setStatus( proxy.getStatus());
  ret.setCards( proxy.getCards());
  ret.setSLs( proxy.getSLs());
  ret.setTransports( proxy.getTransports());
  ret.setTransportIns( proxy.getTransportIns());
  ret.setPools( proxy.getPools());
  ret.setXmlVersion( proxy.getXmlVersion());
  ret.setAction( proxy.getAction());
  ret.setType( proxy.getType());
  ret.setIndexId( proxy.getIndexId());
  ret.setCodeVersion( proxy.getCodeVersion());
  ret.setUser( proxy.getUser());
return ret;
};
}

generator.java

package sample.app;


import com.google.gwt.core.client.GWT;
import com.google.gwt.core.ext.Generator;
import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.NotFoundException;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.editor.rebind.model.ModelUtils;
import com.google.gwt.query.client.builders.XmlBuilder;
import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
import com.google.gwt.user.rebind.SourceWriter;
import sample.app.client.ClassPair;

import javax.xml.bind.annotation.XmlType;
import java.io.PrintWriter;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.LinkedHashMap;
public class BuilderTypeGenerator extends Generator {
    @Override
    public String generate(TreeLogger treeLogger, GeneratorContext context,
                           String requestedClass) throws UnableToCompleteException {
        treeLogger.log(TreeLogger.Type.INFO, "entering generator for " + requestedClass);
        TypeOracle typeOracle = context.getTypeOracle();
        JClassType classType = typeOracle.findType(requestedClass);
        final String pkgName = classType.getPackage().getName();
        String simpleSourceName = classType.getSimpleSourceName();

        ClassSourceFileComposerFactory composerFactory = new ClassSourceFileComposerFactory(pkgName, simpleSourceName + "Impl");
        composerFactory.addImplementedInterface(requestedClass);

        PrintWriter printWriter = context.tryCreate(treeLogger, pkgName, simpleSourceName + "Impl");

        if (printWriter != null) {
            SourceWriter sourceWriter = null;
            try {

                final JClassType[] parameterizationOf = ModelUtils.findParameterizationOf(typeOracle.getType(sample.app.client.BuilderType.class.getCanonicalName()), typeOracle.findType(requestedClass));
                final JClassType jClassType = parameterizationOf[0];
                   composerFactory.addImport(GWT.class.getCanonicalName());
                composerFactory.addImport(jClassType.getQualifiedSourceName());
                final String qualifiedSourceName = jClassType.getQualifiedSourceName();

                //      System.err.println(qualifiedSourceName);

                final ClassPair xmlTypes = getXmlTypes(Class.forName(qualifiedSourceName));

                treeLogger.log(TreeLogger.Type.INFO, "creating printwriter for " + qualifiedSourceName);

                sourceWriter = composerFactory.createSourceWriter(context, printWriter);
//                sourceWriter.println("public ClassPair getBuilder(){");
//                sourceWriter.println("return " + xmlTypeDump + ";");
//                sourceWriter.println("};");

                sourceWriter.println("public static interface GEN_ extends " + XmlBuilder.class.getCanonicalName() + "{");
                JMethod[] methods = jClassType.getMethods();
                for (JMethod method : methods) {
                    String readableDeclaration = method.getReadableDeclaration();
                    sourceWriter.println(readableDeclaration + ";");
                }
                sourceWriter.println("};");
                String pojoName = jClassType.getQualifiedSourceName() ;
                sourceWriter.println(" public  " + pojoName + " deserialize ( Object istream ) { ");
                sourceWriter.println(pojoName + " ret = new " + pojoName + "();");
                String requestedNameFull = classType.getQualifiedSourceName();
                sourceWriter.println(
                        " GEN_ proxy =    GWT.create("+  " GEN_.class) ; ");
                sourceWriter.println("  proxy = proxy.load ( istream ) ;");

                for (JMethod method : methods) {
                    if (method.getName().startsWith("set")) {
                        sourceWriter.println("ret." + method.getName() + "( proxy." + method.getName().replace("set", "get") + "());");

                    }
                }
                printWriter.println("return ret;");
                printWriter.println("};");
            } catch (NotFoundException e) {
                e.printStackTrace();  //todo: verify for a purpose
            } catch (NoSuchFieldException e) {
                e.printStackTrace();  //todo: verify for a purpose
            } catch (ClassNotFoundException e) {
                e.printStackTrace();  //todo: verify for a purpose
            }
            assert sourceWriter != null;
            sourceWriter.commit(treeLogger);
        }
        return composerFactory.getCreatedClassName();
    }


    @SuppressWarnings({"NonJREEmulationClassesInClientCode"})
    static public ClassPair getXmlTypes(Class<?> aClass) throws
            NoSuchFieldException {
        final LinkedHashMap<String, ClassPair> ret = new LinkedHashMap<String, ClassPair>();
        if (aClass.isAnnotationPresent(XmlType.class)) {
            final XmlType annotation = aClass.getAnnotation(XmlType.class);
            final String[] orderedProps = annotation.propOrder();
            for (String prop : orderedProps) {
                Class<?> childClass = aClass.getDeclaredField(prop).getType();
                ret.put(prop, getXmlTypes(childClass));
            }
        }
        return new ClassPair(aClass, ret);
    }

    @SuppressWarnings({"NonJREEmulationClassesInClientCode"})
    public static void printXmlTypes(Class<?> aClass) throws NoSuchFieldException {
        if (!aClass.isAnnotationPresent(XmlType.class)) return;
        System.err.println("for: " + aClass.toString());
        final XmlType annotation = aClass.getAnnotation(XmlType.class);
        final String[] orderedProps = annotation.propOrder();
        for (String prop : orderedProps) {
            final Field declaredField = aClass.getDeclaredField(prop);
            Class<?> childClass = declaredField.getType();
            if (Collection.class.isAssignableFrom(childClass)) {
                final Type genericType = declaredField.getGenericType();
                Class lp = (Class<?>) ((java.lang.reflect.ParameterizedType) genericType).getActualTypeArguments()[0];
                if (!lp.isPrimitive() && !lp.isArray() && !String.class.isAssignableFrom(lp)) {
                    System.err.println("*--: " + prop + " : " + lp.toString());
                    printXmlTypes(lp);
                }
            } else if (childClass.isPrimitive() || childClass.isArray()) {
                System.err.println(" +:" + prop + " : " + childClass);
            } else printXmlTypes(childClass);
        }
    }
}