static { ClassScanner.setReflectionsScanning(true); ParserFactory.registerParser( new Parser() { @Override public EJValue parse(final String input) { return JSONDecoder.decode(input); } }); ServerMappingContext sContext; try { if (!MarshallingGenUtil.isUseStaticMarshallers()) { sContext = loadDynamicMarshallers(); } else { try { sContext = loadPrecompiledMarshallers(); } catch (Throwable t) { log.debug("failed to load static marshallers", t); log.warn("static marshallers were not found."); if (MarshallingGenUtil.isForceStaticMarshallers()) { throw new IOException( "Enforcing static marshallers but failed to load generated server marshallers", t); } sContext = loadDynamicMarshallers(); } finally { ClassScanner.setReflectionsScanning(false); } } } catch (Throwable t) { t.printStackTrace(); log.error(t.getMessage()); throw new RuntimeException("critical problem loading the marshallers", t); } context = sContext; }
private void arrayDemarshallCode( MetaClass toMap, int dim, AnonymousClassStructureBuilder anonBuilder) { Object[] dimParms = new Object[dim]; dimParms[0] = Stmt.loadVariable("a0").invoke("size"); final MetaClass arrayType = toMap.asArrayOf(dim); MetaClass outerType = toMap.getOuterComponentType(); if (!outerType.isArray() && outerType.isPrimitive()) { outerType = outerType.asBoxed(); } Statement outerAccessorStatement = loadVariable("newArray", loadVariable("i")) .assignValue(Cast.to(outerType, loadVariable("a0").invoke("get", loadVariable("i")))); // /** // * Special case for handling char elements. // */ // if (outerType.getFullyQualifiedName().equals(Character.class.getName())) { // outerAccessorStatement = // loadVariable("newArray", loadVariable("i")) // .assignValue( // Stmt.nestedCall(Cast.to(String.class, // loadVariable("a0").invoke("get", loadVariable("i")))) // .invoke("charAt", 0)); // } final BlockBuilder<?> dmBuilder = anonBuilder .privateMethod(arrayType, "_demarshall" + dim) .parameters(List.class, MarshallingSession.class) .body(); dmBuilder.append( Stmt.declareVariable(arrayType) .named("newArray") .initializeWith(Stmt.newArray(toMap, dimParms))); dmBuilder .append( autoForLoop("i", Stmt.loadVariable("newArray").loadField("length")) .append( dim == 1 ? outerAccessorStatement : loadVariable("newArray", loadVariable("i")) .assignValue( Stmt.invokeStatic( anonBuilder.getClassDefinition(), "_demarshall" + (dim - 1), Cast.to( List.class, Stmt.loadVariable("a0") .invoke("get", Stmt.loadVariable("i"))), Stmt.loadVariable("a1")))) .finish()) .append(Stmt.loadVariable("newArray").returnValue()); dmBuilder.finish(); final BlockBuilder<?> mBuilder = anonBuilder .privateMethod(String.class, "_marshall" + dim) .parameters(arrayType, MarshallingSession.class) .body(); mBuilder .append( Stmt.declareVariable(StringBuilder.class) .named("sb") .initializeWith(Stmt.newObject(StringBuilder.class).withParameters("["))) .append( autoForLoop("i", Stmt.loadVariable("a0").loadField("length")) .append( Stmt.if_(Bool.greaterThan(Stmt.loadVariable("i"), 0)) .append(Stmt.loadVariable("sb").invoke("append", ",")) .finish()) .append( Stmt.loadVariable("sb") .invoke( "append", dim == 1 ? Stmt.loadVariable(MarshallingGenUtil.getVarName(outerType)) .invoke( "marshall", Stmt.loadVariable("a0", Stmt.loadVariable("i")), Stmt.loadVariable("a1")) : Stmt.invokeStatic( anonBuilder.getClassDefinition(), "_marshall" + (dim - 1), Stmt.loadVariable("a0", Stmt.loadVariable("i")), loadVariable("a1")))) .finish()) .append(Stmt.loadVariable("sb").invoke("append", "]").invoke("toString").returnValue()) .finish(); if (dim > 1) { arrayDemarshallCode(toMap, dim - 1, anonBuilder); } }
public static Class<? extends MarshallerFactory> getGeneratedMarshallerFactoryForServer() { final String packageName = MarshallersGenerator.SERVER_MARSHALLER_PACKAGE_NAME; final String className = MarshallersGenerator.SERVER_MARSHALLER_CLASS_NAME; try { log.debug("searching for marshaller class: " + packageName + "." + className); final String classResource = packageName.replaceAll("\\.", "/") + "/" + className + ".class"; final Set<String> locations = new HashSet<String>(); // look for the class in every classloader we can think of. For example, current thread // classloading works in Jetty but not JBoss AS 7. locations.addAll( urlToFile(Thread.currentThread().getContextClassLoader().getResources(classResource))); locations.addAll( urlToFile(ServerMarshallUtil.class.getClassLoader().getResources(classResource))); locations.addAll(urlToFile(ClassLoader.getSystemResources(classResource))); File newest = null; for (String url : locations) { final File file = ClassChangeUtil.getFileIfExists(url); if (file != null && (newest == null || file.lastModified() > newest.lastModified())) { newest = file; } } if (locations.size() > 1) { log.warn( "*** MULTIPLE VERSIONS OF " + packageName + "." + className + " FOUND IN CLASSPATH: " + "Attempted to guess the newest one based on file dates. But you should clean your output directories"); for (String loc : locations) { log.warn(" Ambiguous version -> " + loc); } } if (newest == null) { try { // maybe we're in an appserver with a VFS, so try to load anyways. return Thread.currentThread() .getContextClassLoader() .loadClass(packageName + "." + className) .asSubclass(MarshallerFactory.class); } catch (ClassNotFoundException e) { log.warn("could not locate marshaller class."); if (!MarshallingGenUtil.isForceStaticMarshallers()) { return null; } else { log.info("couldn't find marshaller class, attempting to generate ..."); } } } else { return ClassChangeUtil.loadClassDefinition( newest.getAbsolutePath(), packageName, className); } } catch (IOException e) { e.printStackTrace(); log.warn("could not read marshaller classes: " + e); } final String classStr = MarshallerGeneratorFactory.getFor(MarshallerOutputTarget.Java) .generate(packageName, className); final File directory = new File( RebindUtils.getTempDirectory() + "/errai.gen/classes/" + packageName.replaceAll("\\.", "/")); final File sourceFile = new File(directory.getAbsolutePath() + File.separator + className + ".java"); try { if (directory.exists()) { for (File file : directory.listFiles()) { file.delete(); } directory.delete(); } directory.mkdirs(); final FileOutputStream outputStream = new FileOutputStream(sourceFile); outputStream.write(classStr.getBytes("UTF-8")); outputStream.flush(); outputStream.close(); String compiledClassPath = ClassChangeUtil.compileClass( directory.getAbsolutePath(), packageName, className, directory.getAbsolutePath()); return ClassChangeUtil.loadClassDefinition(compiledClassPath, packageName, className); } catch (IOException e) { throw new RuntimeException("failed to generate class ", e); } }
private void appendPageShowMethod( AnonymousClassStructureBuilder pageImplBuilder, MetaClass pageClass, Class<? extends Annotation> annotation, boolean addPrivateAccessors) { BlockBuilder<?> method = pageImplBuilder .publicMethod( void.class, createMethodNameFromAnnotation(annotation), Parameter.of(pageClass, "widget"), Parameter.of(HistoryToken.class, "state")) .body(); int idx = 0; method.append(Stmt.declareFinalVariable("pageState", Map.class, new HashMap<String, Object>())); for (MetaField field : pageClass.getFieldsAnnotatedWith(PageState.class)) { PageState psAnno = field.getAnnotation(PageState.class); String fieldName = field.getName(); String queryParamName = psAnno.value(); if (queryParamName == null || queryParamName.trim().isEmpty()) { queryParamName = fieldName; } if (addPrivateAccessors) { PrivateAccessUtil.addPrivateAccessStubs( PrivateAccessType.Write, "jsni", pageImplBuilder, field, new Modifier[] {}); } String injectorName = PrivateAccessUtil.getPrivateFieldInjectorName(field); MetaClass erasedFieldType = field.getType().getErased(); if (erasedFieldType.isAssignableTo(Collection.class)) { MetaClass elementType = MarshallingGenUtil.getConcreteCollectionElementType(field.getType()); if (elementType == null) { throw new UnsupportedOperationException( "Found a @PageState field with a Collection type but without a concrete type parameter. " + "Collection-typed @PageState fields must specify a concrete type parameter."); } if (erasedFieldType.equals(MetaClassFactory.get(Set.class))) { method.append(Stmt.declareVariable(fieldName, Stmt.newObject(HashSet.class))); } else if (erasedFieldType.equals(MetaClassFactory.get(List.class)) || erasedFieldType.equals(MetaClassFactory.get(Collection.class))) { method.append(Stmt.declareVariable(fieldName, Stmt.newObject(ArrayList.class))); } else { throw new UnsupportedOperationException( "Found a @PageState field which is a collection of type " + erasedFieldType.getFullyQualifiedName() + ". For collection-valued fields, only the exact types java.util.Collection, java.util.Set, and " + "java.util.List are supported at this time."); } // for (String fv{idx} : state.get({fieldName})) method.append( Stmt.loadVariable("state") .invoke("getState") .invoke("get", queryParamName) .foreach("elem", Object.class) .append( Stmt.declareVariable( "fv" + idx, Stmt.castTo(String.class, Stmt.loadVariable("elem")))) .append( Stmt.loadVariable(fieldName) .invoke( "add", paramFromStringStatement(elementType, Stmt.loadVariable("fv" + idx)))) .append( Stmt.loadVariable("pageState") .invoke("put", fieldName, Stmt.loadVariable(fieldName))) .finish()); method.append( Stmt.loadVariable("this") .invoke(injectorName, Stmt.loadVariable("widget"), Stmt.loadVariable(fieldName))); } else { method.append( Stmt.declareFinalVariable( "fv" + idx, Collection.class, Stmt.loadVariable("state").invoke("getState").invoke("get", queryParamName))); method.append( If.cond( Bool.or( Bool.isNull(Stmt.loadVariable("fv" + idx)), Stmt.loadVariable("fv" + idx).invoke("isEmpty"))) .append( Stmt.loadVariable("this") .invoke( injectorName, Stmt.loadVariable("widget"), defaultValueStatement(erasedFieldType))) .finish() .else_() .append( Stmt.loadVariable("this") .invoke( injectorName, Stmt.loadVariable("widget"), paramFromStringStatement( erasedFieldType, Stmt.loadVariable("fv" + idx).invoke("iterator").invoke("next")))) .append( Stmt.loadVariable("pageState") .invoke( "put", fieldName, Stmt.loadVariable("fv" + idx).invoke("iterator").invoke("next"))) .finish()); } idx++; } if (addPrivateAccessors) { method.append( Stmt.invokeStatic( CDI.class, "fireEvent", Stmt.newObject(NavigationEvent.class) .withParameters( Stmt.newObject(PageRequest.class) .withParameters( getPageName(pageClass), Stmt.loadVariable("pageState"))))); } checkMethodAndAddPrivateAccessors( pageImplBuilder, method, pageClass, annotation, HistoryToken.class, "state"); method.finish(); }