From 69bc2691e504d406e8fe0c55d365a7d31ed1ae0a Mon Sep 17 00:00:00 2001 From: bsorrentino Date: Sat, 30 Dec 2017 23:54:15 +0100 Subject: [PATCH 1/2] update sample --- jjs/src/main/ts/jdk8-types.js | 3 +- jjs/src/main/ts/jdk8-types.ts | 14 ++++- jjs/src/main/ts/jdk8.d.ts | 106 ++++++++++++++++------------------ jjs/src/main/ts/main.js | 4 +- jjs/src/main/ts/main.ts | 7 ++- 5 files changed, 70 insertions(+), 64 deletions(-) diff --git a/jjs/src/main/ts/jdk8-types.js b/jjs/src/main/ts/jdk8-types.js index 9013b70..0ce432e 100644 --- a/jjs/src/main/ts/jdk8-types.js +++ b/jjs/src/main/ts/jdk8-types.js @@ -1,3 +1,4 @@ "use strict"; +/// Object.defineProperty(exports, "__esModule", { value: true }); -exports.ArrayList = Java.type("java.util.ArrayList"); +exports.Stream = Java.type("java.util.stream.Stream"); diff --git a/jjs/src/main/ts/jdk8-types.ts b/jjs/src/main/ts/jdk8-types.ts index 099a8e8..6bffcd6 100644 --- a/jjs/src/main/ts/jdk8-types.ts +++ b/jjs/src/main/ts/jdk8-types.ts @@ -1,6 +1,14 @@ +/// -interface ArrayListStatic { - new():java.util.ArrayList; + +interface StreamStatic { + + concat( arg0:java.util.stream.Stream, arg1:java.util.stream.Stream ):java.util.stream.Stream; + empty( ):java.util.stream.Stream; + generate( arg0:Supplier ):java.util.stream.Stream; + iterate( arg0:any /* java.lang.Object */, arg1:UnaryOperator ):java.util.stream.Stream; + of( arg0:[any] /* [Ljava.lang.Object; */ ):java.util.stream.Stream; + of( arg0:any /* java.lang.Object */ ):java.util.stream.Stream; } -export var ArrayList: ArrayListStatic = Java.type( "java.util.ArrayList"); +export const Stream: StreamStatic = Java.type("java.util.stream.Stream"); diff --git a/jjs/src/main/ts/jdk8.d.ts b/jjs/src/main/ts/jdk8.d.ts index 1a42d09..ea8b7c3 100644 --- a/jjs/src/main/ts/jdk8.d.ts +++ b/jjs/src/main/ts/jdk8.d.ts @@ -23,14 +23,6 @@ interface Consumer /*extends Function*/ { ( v:T ):void; //accept(t:T):void } -interface ConsumerConstructor { - new( args: T): Consumer; - ( args: T): Consumer; - readonly prototype: Function; -} - -declare const Consumer : ConsumerConstructor; - interface UnaryOperator/* extends Function*/ { andThen?( arg0:any /* java.util.function.Function */ ):any /* java.util.function.Function */; @@ -93,21 +85,7 @@ declare namespace java.io { interface Serializable {} } -declare namespace java.util.stream { - interface StreamConstructor{ - builder( ):Stream.Builder; - concat( arg0:Stream,arg1:Stream ):Stream; - empty( ):Stream; - generate( arg0:Supplier ):Stream; - iterate( seed:T,arg1:UnaryOperator ):Stream; - of( arg0:Array ):Stream; - of( arg0:T ):Stream; - - } - - export const Stream : java.util.stream.StreamConstructor; -} declare namespace java.lang { interface Iterable { @@ -186,25 +164,10 @@ class String/* extends ObjectString implements java.io.Serializable, Comparable< startsWith( arg0:string ):boolean; startsWith( arg0:string, arg1:int ):boolean; static checkBounds( arg0:bytearray, arg1:int, arg2:int ):void; - static copyValueOf( arg0:chararray ):string; - static copyValueOf( arg0:chararray, arg1:int, arg2:int ):string; - static format( arg0:any /* java.util.Locale */, arg1:string, arg2:[any] /* [Ljava.lang.Object; */ ):string; - static format( arg0:string, arg1:[any] /* [Ljava.lang.Object; */ ):string; static indexOf( arg0:chararray, arg1:int, arg2:int, arg3:chararray, arg4:int, arg5:int, arg6:int ):int; static indexOf( arg0:chararray, arg1:int, arg2:int, arg3:string, arg4:int ):int; - static join( arg0:CharSequence, arg1:Iterable ):string; - static join( arg0:CharSequence, arg1:[any] /* [Ljava.lang.CharSequence; */ ):string; static lastIndexOf( arg0:chararray, arg1:int, arg2:int, arg3:chararray, arg4:int, arg5:int, arg6:int ):int; static lastIndexOf( arg0:chararray, arg1:int, arg2:int, arg3:string, arg4:int ):int; - static valueOf( arg0:any /* char */ ):string; - static valueOf( arg0:any /* java.lang.Object */ ):string; - static valueOf( arg0:boolean ):string; - static valueOf( arg0:chararray ):string; - static valueOf( arg0:chararray, arg1:int, arg2:int ):string; - static valueOf( arg0:double ):string; - static valueOf( arg0:float ):string; - static valueOf( arg0:int ):string; - static valueOf( arg0:long ):string; subSequence( arg0:int, arg1:int ):CharSequence; substring( arg0:int ):string; substring( arg0:int, arg1:int ):string; @@ -218,6 +181,55 @@ class String/* extends ObjectString implements java.io.Serializable, Comparable< } // end String +} // end namespace java.lang +declare namespace java.lang { + +class System/* extends Object*/ { + + equals( arg0:any /* java.lang.Object */ ):boolean; + hashCode( ):int; + static arraycopy( arg0:any /* java.lang.Object */, arg1:int, arg2:any /* java.lang.Object */, arg3:int, arg4:int ):void; + static checkIO( ):void; + static checkKey( arg0:string ):void; + static clearProperty( arg0:string ):string; + static console( ):any /* java.io.Console */; + static currentTimeMillis( ):long; + static exit( arg0:int ):void; + static gc( ):void; + static getProperties( ):any /* java.util.Properties */; + static getProperty( arg0:string ):string; + static getProperty( arg0:string, arg1:string ):string; + static getSecurityManager( ):any /* java.lang.SecurityManager */; + static getenv( arg0:string ):string; + static getenv( ):java.util.Map; + static identityHashCode( arg0:any /* java.lang.Object */ ):int; + static inheritedChannel( ):any /* java.nio.channels.Channel */; + static initProperties( arg0:any /* java.util.Properties */ ):any /* java.util.Properties */; + static initializeSystemClass( ):void; + static lineSeparator( ):string; + static load( arg0:string ):void; + static loadLibrary( arg0:string ):void; + static mapLibraryName( arg0:string ):string; + static nanoTime( ):long; + static newPrintStream( arg0:any /* java.io.FileOutputStream */, arg1:string ):any /* java.io.PrintStream */; + static registerNatives( ):void; + static runFinalization( ):void; + static runFinalizersOnExit( arg0:boolean ):void; + static setErr( arg0:any /* java.io.PrintStream */ ):void; + static setErr0( arg0:any /* java.io.PrintStream */ ):void; + static setIn( arg0:any /* java.io.InputStream */ ):void; + static setIn0( arg0:any /* java.io.InputStream */ ):void; + static setJavaLangAccess( ):void; + static setOut( arg0:any /* java.io.PrintStream */ ):void; + static setOut0( arg0:any /* java.io.PrintStream */ ):void; + static setProperties( arg0:any /* java.util.Properties */ ):void; + static setProperty( arg0:string, arg1:string ):string; + static setSecurityManager( arg0:any /* java.lang.SecurityManager */ ):void; + static setSecurityManager0( arg0:any /* java.lang.SecurityManager */ ):void; + toString( ):string; + +} // end System + } // end namespace java.lang declare namespace java.util.stream { @@ -240,12 +252,6 @@ declare namespace java.util.stream { interface Stream/*Stream extends BaseStream*/ { // static builder( ):any /* java.util.stream.Stream$Builder */; - // static concat( arg0:Stream, arg1:Stream ):Stream; - // static empty( ):Stream; - // static generate( arg0:Supplier ):Stream; - // static iterate( arg0:any /* java.lang.Object */, arg1:UnaryOperator ):Stream; - // static of( arg0:[any] /* [Ljava.lang.Object; */ ):Stream; - // static of( arg0:any /* java.lang.Object */ ):Stream; allMatch( arg0:Predicate ):boolean; anyMatch( arg0:Predicate ):boolean; close( ):void; @@ -318,15 +324,6 @@ declare namespace java.util { interface Comparator { - // static comparing( arg0:any /* java.util.function.Function */ ):Comparator; - // static comparing( arg0:any /* java.util.function.Function */, arg1:Comparator ):Comparator; - // static comparingDouble( arg0:any /* java.util.function.ToDoubleFunction */ ):Comparator; - // static comparingInt( arg0:any /* java.util.function.ToIntFunction */ ):Comparator; - // static comparingLong( arg0:any /* java.util.function.ToLongFunction */ ):Comparator; - // static naturalOrder( ):Comparator; - // static nullsFirst( arg0:Comparator ):Comparator; - // static nullsLast( arg0:Comparator ):Comparator; - // static reverseOrder( ):Comparator; compare( arg0:any /* java.lang.Object */, arg1:any /* java.lang.Object */ ):int; equals( arg0:any /* java.lang.Object */ ):boolean; reversed( ):Comparator; @@ -858,9 +855,6 @@ class Optional/* extends java.lang.Object*/ { orElse( arg0:any /* java.lang.Object */ ):any /* java.lang.Object */; orElseGet( arg0:Supplier ):any /* java.lang.Object */; orElseThrow( arg0:Supplier ):any /* java.lang.Object */; - static empty( ):Optional; - static of( arg0:any /* java.lang.Object */ ):Optional; - static ofNullable( arg0:any /* java.lang.Object */ ):Optional; toString( ):string; } // end Optional @@ -1016,8 +1010,6 @@ declare namespace java.nio.file { hashCode( ):int; name( ):string; ordinal( ):int; - static valueOf( arg0:string ):AccessMode; - static valueOf( arg0:java.lang.Class, arg1:string ):any /* java.lang.Enum */; static values( ):[any] /* [Ljava.nio.file.AccessMode; */; toString( ):string; diff --git a/jjs/src/main/ts/main.js b/jjs/src/main/ts/main.js index 819f6e7..cb71bb6 100644 --- a/jjs/src/main/ts/main.js +++ b/jjs/src/main/ts/main.js @@ -4,12 +4,14 @@ var colors = require("colors/safe"); var mustache = require("mustache"); var jdk8_types_1 = require("./jdk8-types"); var b = "hello jjs"; -var list = new jdk8_types_1.ArrayList(); var a = java.util.Arrays.asList(["item1", "item2", "item3"]); print(colors.red(b)); a.stream().forEach(function (e) { print(colors.green(e)); }); +jdk8_types_1.Stream.of("").forEach(function (e) { + print(colors.green(e)); +}); var template = "Email addresses of: {{contact.name}}:\n{{#contact.emails}}\n- {{.}}\n{{/contact.emails}}\n"; var result = mustache.render(template, { contact: { name: "bsorrentino", emails: [ diff --git a/jjs/src/main/ts/main.ts b/jjs/src/main/ts/main.ts index ddfd5ac..d9f05c9 100644 --- a/jjs/src/main/ts/main.ts +++ b/jjs/src/main/ts/main.ts @@ -2,11 +2,10 @@ import * as colors from "colors/safe"; import mustache = require("mustache"); -import {ArrayList} from "./jdk8-types"; +import {Stream} from "./jdk8-types"; let b = "hello jjs"; -let list = new ArrayList(); let a = java.util.Arrays.asList( [ "item1", "item2", "item3"] ); @@ -16,6 +15,10 @@ a.stream().forEach( (e) => { print( colors.green(e) ); }); +Stream.of( "" ).forEach( (e) => { + print( colors.green(e) ); +}); + let template = `Email addresses of: {{contact.name}}: {{#contact.emails}} From 58c44a856dcc7b26e487574ca95e4af214555f87 Mon Sep 17 00:00:00 2001 From: bsorrentino Date: Sat, 30 Dec 2017 23:54:53 +0100 Subject: [PATCH 2/2] export factory method --- .../org/bsc/java2ts/jdk8/package-info.java | 2 +- .../org/bsc/processor/TypescriptHelper.java | 54 ++-- .../bsc/processor/TypescriptProcessor.java | 265 ++++++++++++------ processor/src/main/resources/headerD.ts | 69 +---- processor/src/main/resources/headerT.ts | 2 - 5 files changed, 215 insertions(+), 177 deletions(-) diff --git a/jdk8/src/main/java/org/bsc/java2ts/jdk8/package-info.java b/jdk8/src/main/java/org/bsc/java2ts/jdk8/package-info.java index 246960f..50fd0b3 100644 --- a/jdk8/src/main/java/org/bsc/java2ts/jdk8/package-info.java +++ b/jdk8/src/main/java/org/bsc/java2ts/jdk8/package-info.java @@ -14,7 +14,7 @@ @Type(java.util.stream.BaseStream.class), - @Type(java.util.stream.Stream.class), + @Type(value=java.util.stream.Stream.class,export=true), @Type(java.util.Iterator.class), @Type(java.util.Comparator.class), diff --git a/processor/src/main/java/org/bsc/processor/TypescriptHelper.java b/processor/src/main/java/org/bsc/processor/TypescriptHelper.java index 1b4a743..b8dcb7c 100644 --- a/processor/src/main/java/org/bsc/processor/TypescriptHelper.java +++ b/processor/src/main/java/org/bsc/processor/TypescriptHelper.java @@ -34,8 +34,7 @@ static String getClassDecl( Class type, final StringBuilder inherited = new StringBuilder(); if( type.isInterface() ) { - statement.append( "interface "); - + statement.append( "interface "); } else { @@ -47,7 +46,7 @@ static String getClassDecl( Class type, if( superclass!=null ) { inherited .append( " extends ") - .append( getName(superclass, type) ) + .append( getName(superclass, type, true) ) ; } } @@ -57,7 +56,7 @@ static String getClassDecl( Class type, if(interfaces.length > 0 ) { final String ifc = Arrays.stream(interfaces) - .map( (c) -> getName(c,type) ) + .map( (c) -> getName(c,type, true) ) .collect( Collectors.joining(", ")) ; inherited @@ -150,25 +149,26 @@ static String getName( Type type, Class declaringClass ) throws ClassNotFound * @param declaringClass * @return */ - static String getName( Class type, Class declaringClass ) { - final Package currentNS = declaringClass.getPackage(); - - final java.util.List dc_parameters_list = - Arrays.stream(declaringClass.getTypeParameters()) - .map( (tp) -> tp.getName()) - .collect(Collectors.toList()); + static String getName( Class type, Class declaringClass, boolean packageResolution ) { - final java.util.List type_parameters_list = - Arrays.stream(type.getTypeParameters()) - .map( (tp) -> (dc_parameters_list.contains(tp.getName()) ) ? tp.getName() : "any" ) - .collect(Collectors.toList()); - - final java.util.List parameters = - dc_parameters_list.size() == type_parameters_list.size() ? dc_parameters_list : type_parameters_list ; - - boolean isFunctionaInterface = ( type.isInterface() && type.isAnnotationPresent(FunctionalInterface.class)); - - return new StringBuilder() + final java.util.List dc_parameters_list = + Arrays.stream(declaringClass.getTypeParameters()) + .map( (tp) -> tp.getName()) + .collect(Collectors.toList()); + + final java.util.List type_parameters_list = + Arrays.stream(type.getTypeParameters()) + .map( (tp) -> (dc_parameters_list.contains(tp.getName()) ) ? tp.getName() : "any" ) + .collect(Collectors.toList()); + + final java.util.List parameters = + dc_parameters_list.size() == type_parameters_list.size() ? dc_parameters_list : type_parameters_list ; + + boolean isFunctionaInterface = ( type.isInterface() && type.isAnnotationPresent(FunctionalInterface.class)); + + final Package currentNS = (packageResolution) ? declaringClass.getPackage() : null; + + return new StringBuilder() .append( type.getPackage().equals(currentNS) || isFunctionaInterface ? type.getSimpleName() : @@ -178,15 +178,19 @@ static String getName( Class type, Class declaringClass ) { .toString(); } - /** * * @param type * @param declaringClass * @param declaredClassMap + * @param packageResolution * @return */ - static String convertJavaToTS( Class type, Class declaringClass, java.util.Map> declaredClassMap ) { + static String convertJavaToTS( Class type, + Class declaringClass, + java.util.Map> declaredClassMap, + boolean packageResolution ) + { if( type == null ) return "any"; @@ -205,7 +209,7 @@ static String convertJavaToTS( Class type, Class declaringClass, java.util if( type.isArray()) return format("[any] /* %s */",type.getName()); if( declaredClassMap.containsKey(type.getName()) ) { - return getName(type,declaringClass); + return getName(type, declaringClass, packageResolution); } return format("any /* %s */",type.getName()); diff --git a/processor/src/main/java/org/bsc/processor/TypescriptProcessor.java b/processor/src/main/java/org/bsc/processor/TypescriptProcessor.java index 55e42a2..a106194 100644 --- a/processor/src/main/java/org/bsc/processor/TypescriptProcessor.java +++ b/processor/src/main/java/org/bsc/processor/TypescriptProcessor.java @@ -79,31 +79,6 @@ public class TypescriptProcessor extends AbstractProcessorEx { java.util.stream.Stream.class, java.util.Optional.class ); - - /** - * - * @param w - * @param t - */ - private void addDeclaration( java.io.Writer w, TSType t, boolean isRhinoCompatible ) { - if( !t.isExport() ) return; - - Class type = t.getValue(); - - info( "export type [%s]", type.getName() ); - - try { - if( isRhinoCompatible ) { - w.append( String.format( "export const %s:%s\t\t=\t%s;\n", type.getSimpleName(), type.getName(), type.getName())); - } - else { - w.append( String.format( "export const %s:%s\t\t=\tJava.type( \"%s\" );\n", type.getSimpleName(), type.getName(), type.getName())); - } - } catch (IOException e) { - error( "error adding [%s]", t.getValue()); - } - - } /** * @@ -120,7 +95,7 @@ private java.io.Writer openFile( Path file, String header ) throws IOException { final java.io.Writer w = out.openWriter(); - try(final java.io.InputStream is = getClass().getClassLoader().getResourceAsStream("headerD.ts") ) { + try(final java.io.InputStream is = getClass().getClassLoader().getResourceAsStream(header) ) { int c; while( (c = is.read()) != -1 ) w.write(c); } @@ -134,23 +109,20 @@ private java.io.Writer openFile( Path file, String header ) throws IOException { @Override public boolean process( Context processingContext ) throws Exception { - final String targetDefinitionFile = processingContext.getOptionMap().getOrDefault("ts.outfile", "out"); + final String targetDefinitionFile = processingContext.getOptionMap().getOrDefault("ts.outfile", "out"); //final String compatibility = processingContext.getOptionMap().getOrDefault("compatibility", "nashorn"); try( final java.io.Writer wD = openFile( Paths.get(targetDefinitionFile.concat(".d.ts")), "headerD.ts" ); - /* final java.io.Writer wT = openFile( Paths.get(targetDefinitionFile.concat(".ts")), "headerT.ts" ); */ + final java.io.Writer wT = openFile( Paths.get(targetDefinitionFile.concat("-types.ts")), "headerT.ts" ); ) { - - + final List types = enumerateDeclaredPackageAndClass( processingContext ); final List> classes = types.stream() - //.peek( t -> addDeclaration(wT, t, compatibility.equalsIgnoreCase("rhino")) ) .map( t -> t.getValue() ) .collect( Collectors.toList()); - - + // // Check for Required classes // @@ -159,7 +131,8 @@ public boolean process( Context processingContext ) throws Exception { .forEach( c -> classes.add(c) ); - final java.util.Map> declaredClasses = classes.stream().collect( Collectors.toMap( clazz -> clazz.getName() , clazz -> clazz )); + final java.util.Map> declaredClasses = + classes.stream().collect( Collectors.toMap( clazz -> clazz.getName() , clazz -> clazz )); PREDEFINED_CLASSES.forEach( clazz -> declaredClasses.put( clazz.getName(), clazz) ); @@ -174,6 +147,18 @@ public boolean process( Context processingContext ) throws Exception { } } ); + types.stream() + .filter( t -> t.isExport() ) + .map( t -> t.getValue() ) + .map( clazz -> processStatic( clazz, declaredClasses)) + .forEach( s -> { + try { + wT.append( s ); + } catch (IOException e) { + error( "error adding [%s]", s); + } + } ); + } // end try-with-resources return true; @@ -186,7 +171,9 @@ public boolean process( Context processingContext ) throws Exception { * @param declaredClassMap * @return */ - private String getPropertyDecl( Class declaringClass, PropertyDescriptor pd, java.util.Map> declaredClassMap ) { + private String getPropertyDecl( Class declaringClass, + PropertyDescriptor pd, + java.util.Map> declaredClassMap ) { final StringBuilder sb = new StringBuilder(); @@ -230,12 +217,94 @@ private String getPropertyDecl( Class declaringClass, PropertyDescriptor pd, final String tsType = convertJavaToTS( pd.getPropertyType(), declaringClass, - declaredClassMap); + declaredClassMap, + true); return sb.append(tsType) .toString(); } + /** + * + * @param m + * @param declaringClass + * @param declaredClassMap + * @return + */ + private String getMethodParametersDecl( Method m, + Class declaringClass, + java.util.Map> declaredClassMap, + boolean packageResolution ) + { + final Class returnType = m.getReturnType(); + + final Parameter[] params = m.getParameters(); + + final String params_string = + Arrays.stream(params) + .map( (tp) -> + String.format( "%s:%s", + tp.getName(), + convertJavaToTS(tp.getType(),declaringClass,declaredClassMap, packageResolution) ) ) + .collect(Collectors.joining(", ")) + ; + + final String tsType = + convertJavaToTS( returnType, + declaringClass, + declaredClassMap, + packageResolution); + + return new StringBuilder() + .append("( ") + .append(params_string) + .append(" ):") + .append(tsType) + .toString(); + } + + /** + * + * @param sb + * @param m + */ + private void appendStaticMethodTypeParameters( final StringBuilder sb, final Method m ) { + final TypeVariable[] return_type_parameters = m.getReturnType().getTypeParameters(); + + if( return_type_parameters.length > 0 ) { + + final String pp = + Arrays.asList( return_type_parameters ) + .stream() + .map( t -> t.getName() ) + .collect(Collectors.joining(",", "<", ">")) ; + + sb.append( pp ); + + } + } + + /** + * + * @param m + * @param declaringClass + * @param declaredClassMap + * @return + */ + private String getFactoryMethodDecl( final Method m, Class declaringClass, java.util.Map> declaredClassMap ) { + + final StringBuilder sb = new StringBuilder(); + + sb.append(m.getName()); + + appendStaticMethodTypeParameters(sb, m); + + sb.append( getMethodParametersDecl(m, declaringClass, declaredClassMap, false) ); + + return sb.toString(); + + } + /** * * @param m @@ -244,7 +313,6 @@ private String getPropertyDecl( Class declaringClass, PropertyDescriptor pd, * @return */ private String getMethodDecl( final Method m, Class declaringClass, java.util.Map> declaredClassMap ) { - final Class returnType = m.getReturnType(); final StringBuilder sb = new StringBuilder(); @@ -255,19 +323,8 @@ private String getMethodDecl( final Method m, Class declaringClass, java.util } sb.append("static ").append(m.getName()); - - - final TypeVariable[] return_type_parameters = m.getReturnType().getTypeParameters(); - - if( return_type_parameters.length > 0 ) { - - sb.append( - Arrays.asList( return_type_parameters ) - .stream() - .map( t -> t.getName() ) - .collect(Collectors.joining(",", "<", ">")) ); - - } + + appendStaticMethodTypeParameters(sb, m); } else { @@ -277,27 +334,9 @@ private String getMethodDecl( final Method m, Class declaringClass, java.util } //if( m.getDeclaringClass().isInterface()) sb.append('?'); - sb.append("( "); - - final Parameter[] params = m.getParameters(); - - final String params_string = - Arrays.stream(params) - .map( (tp) -> - String.format( "%s:%s", - tp.getName(), - convertJavaToTS(tp.getType(),declaringClass,declaredClassMap) ) ) - .collect(Collectors.joining(", ")) - ; - - final String tsType = convertJavaToTS( returnType, - declaringClass, - declaredClassMap); + sb.append( getMethodParametersDecl(m, declaringClass, declaredClassMap, true) ); - return sb.append(params_string) - .append(" ):") - .append(tsType) - .toString(); + return sb.toString(); } @@ -393,6 +432,66 @@ private void processEnum( StringBuilder sb, Class type, java.util.Map type, java.util.Map> declaredClassMap ) { + + final StringBuilder sb = new StringBuilder(); + + final java.util.Set methodSet = + getMethods( type ) + .stream() + .filter( this::isFactoryMethod ) + .collect( Collectors.toCollection(() -> new java.util.LinkedHashSet() )); + + if( !methodSet.isEmpty() ) { + + sb.append("interface ") + .append( type.getSimpleName() ) + .append("Static {\n\n") + ; + + methodSet.stream() + .map( md -> getFactoryMethodDecl(md, type, declaredClassMap) ) + .sorted().forEach( (decl) -> + sb.append( '\t' ) + .append(decl) + .append( ENDL )) + ; + } + + sb.append( "}\n\n" ) + .append("export const ") + .append(type.getSimpleName()) + .append(": ") + .append(type.getSimpleName()) + .append("Static = Java.type(\"") + .append( type.getName() ) + .append("\")") + .append( ENDL ) + .append("\n\n") + ; + + return sb.toString(); + } + + /** * * @param bi @@ -410,21 +509,19 @@ private String processClass( BeanInfo bi, java.util.Map> decla final java.util.Set methodSet = getMethods( type ) .stream() - .filter( (md) -> { // Remove setter and getter - return !Arrays.asList(pds).stream().anyMatch( (pd) -> { - final Method rm = pd.getReadMethod(); - final Method wm = pd.getWriteMethod(); - return (md.equals(rm) || md.equals(wm)); - }); - }) + .filter( md -> !isFactoryMethod(md) ) .filter( (md) -> { - final String name = md.getName(); - - return !( name.contains("$") || // remove unnamed - name.equals("wait") || - name.equals("notify") || - name.equals("notifyAll") ); - }) + final String name = md.getName(); + return !( name.contains("$") || // remove unnamed + name.equals("wait") || + name.equals("notify") || + name.equals("notifyAll") ); + }) + .filter( md -> // Remove setter and getter + !Arrays.asList(pds) + .stream() + .anyMatch( pd -> (md.equals(pd.getReadMethod()) || md.equals(pd.getWriteMethod())) ) + ) //.peek( (md ) -> System.out.printf( "==> CLASS [%s] - METHOD\t[%s]\n",type.getSimpleName(),md.getName())) .collect( Collectors.toCollection(() -> new java.util.LinkedHashSet() )); diff --git a/processor/src/main/resources/headerD.ts b/processor/src/main/resources/headerD.ts index c9a95c0..90bf7a3 100644 --- a/processor/src/main/resources/headerD.ts +++ b/processor/src/main/resources/headerD.ts @@ -14,58 +14,13 @@ type bytearray = [char]; type Runnable = () => void; -interface Supplier { - ():T; //get():T -} - -interface Consumer /*extends Function*/ { - andThen?( arg0:Consumer ):Consumer; - ( v:T ):void; //accept(t:T):void -} +type Supplier = () => T; -interface ConsumerConstructor { - new( args: T): Consumer; - ( args: T): Consumer; - readonly prototype: Function; -} +type Consumer = ( v:T) => void; -declare const Consumer : ConsumerConstructor; +type UnaryOperator = ( v:T ) => T ; -interface UnaryOperator/* extends Function*/ { - - andThen?( arg0:any /* java.util.function.Function */ ):any /* java.util.function.Function */; - compose?( arg0:any /* java.util.function.Function */ ):any /* java.util.function.Function */; - ( v:T ):T //apply(t:T):T - -} - -interface UnaryOperatorConstructor { - new( args: T): UnaryOperator; - ( args: T): UnaryOperator; - /*static */identity( ):UnaryOperator; - readonly prototype: Function; -} - -declare const UnaryOperator : UnaryOperatorConstructor; - -interface Predicate { - - and?( arg0:Predicate ):Predicate; - negate?():Predicate; - or?( arg0:Predicate ):Predicate; - ( v:T ):boolean //test( arg0:T /* java.lang.Object */ ):boolean; - -} - -interface PredicateConstructor { - new( args: T): UnaryOperator; - ( args: T): UnaryOperator; - - /*static*/ isEqual( arg0:any /* java.lang.Object */ ):Predicate; - -} - -declare const Predicate : PredicateConstructor; +type Predicate = ( v:T ) => boolean; declare namespace java.lang { @@ -92,19 +47,3 @@ declare namespace java.io { interface Closeable {} interface Serializable {} } - -declare namespace java.util.stream { - - interface StreamConstructor{ - builder( ):Stream.Builder; - concat( arg0:Stream,arg1:Stream ):Stream; - empty( ):Stream; - generate( arg0:Supplier ):Stream; - iterate( seed:T,arg1:UnaryOperator ):Stream; - of( arg0:Array ):Stream; - of( arg0:T ):Stream; - - } - - export const Stream : java.util.stream.StreamConstructor; -} diff --git a/processor/src/main/resources/headerT.ts b/processor/src/main/resources/headerT.ts index 8b8094d..82e96ad 100644 --- a/processor/src/main/resources/headerT.ts +++ b/processor/src/main/resources/headerT.ts @@ -1,3 +1 @@ /// - -