/**** * Array */ import {Predication} from "./utils/Predication"; import {Iterator, ListIterator} from "./utils/Iterator"; import {Define} from "./Define"; import {Response} from "./net/Http"; import {Class} from "./Class"; import {Constructor} from "./Constructor"; import {Comparator} from "./Comparator"; import {BiConsumer, Consumer, IntConsumer} from "./Consumer"; import {OptionalInt} from "./utils/OptionalInt"; import {Integer} from "./type/Integer"; import {Method} from "./Reflect/Method"; import {Field} from "./Reflect/Field"; import {Path} from "./file/Path"; import {InputStreamReader} from "./file/InputStreamReader"; import {OutputStream} from "./file/OutputStream"; import {Package} from "./lang/Package"; import {InputStream} from "./file/InputStream"; import {Optional} from "./utils/Optional"; import {ENCODING} from "./file/charset/ENCODING"; import {Annotation} from "./annotation/Annotation"; /** * typeOf */ export type primitiveArray = number[]|string[]|boolean[]|Number[]|String[]|Boolean[] export type PrimitiveTypes = "function" | "object" | "number" | "string" type PrimAscii = number|string export type int = number export type double = number export type ascii = Number|String|PrimAscii export type ListKey = number | string; export type array = T[] | Array | null export type MapType = { [J in K] : V }; /*** * PredicateFn return Boolean * in this version predication * look like to Comparator */ export type predicateFnA = ( value : T, key? : ascii )=> boolean; export type predicateFn = predicateFnA & Function export type predication = predicateFn | Predication | PredicationConstructor export type intPredicate = predication /**/ /**@v3.0.0.*/ /***@v3.0.0*/ export type Func = (...args:A[]) => R /*@comparatorFunc*/ export type comparatorFn> = ( other1: T, other2: T ) => V export type comparatorFnA = ( other1: T, other2: T ) => V /**/ export type consumerFn = ( o: T ) => void export type consumer = IConsumer |consumerFn | Consumer /*@biConsumerFn*/ export type biConsumerFn = (p:T, q:P ) => void; /*@supplierFn*/ export type supplierFn = () => R; export type decoratorSupplierFn = (p:T, q:P )=>R; /*** * Global Extended native object prototype */ declare global { interface String { equals( value : string ) : boolean equalsIgnoreCase( value : string ) : boolean regExp( regExp : RegExp, callback : Function ) : string contains( value : string|RegExp ): boolean format( ... args : any[] ) : string isEmpty( ) : boolean explodeAsList( separator : string|RegExp ) : List exec( regExp : RegExp ) : string[] orDefault( value : string ): string stripSlashes() :string compareTo( another: string ): number toArray():string[] getBytes(charsetTo?:ENCODING, charsetFrom?: ENCODING):string[] } interface StringConstructor{ repeatString(char : string, loop : number ) : string } interface Number { equals( value : number ) : boolean compareTo( another : number ): number compare( x :number, y:number):number isPrime():boolean } interface NumberConstructor{ of( value: Object) : number compare( x:number, y:number):number sum( a:number, b:number):number } interface Date{ plusDays( days : number ) : Date lessDays( days : number ) : Date plusYears( years : number ) : Date lessYears( years : number ) : Date dateFormat( patter : string ) : String elapsedTime( date : Date ) : number compareTo( date: Date ): number } interface DateConstructor { dateFormat( patter : string ) : String } interface Boolean { state( expectTrue : any, orElse : any ) : any compareTo(obj: boolean): number equals( value: boolean ) : boolean } interface BooleanConstructor{ of(value: Object) : boolean compare(o1:boolean,o2:boolean):number } interface ArrayConstructor { asList( value: T[]):List list( ... value : T[] ):List newList( ... value : T[] ):List sum( ): number } interface Array{ equals(o:Array) sum( ): number } interface ObjectConstructor { equals(o1:Object, o2:Object):boolean package(o:Object):void toString( o: Object ): string } interface Object { getClass(): Class equals(o1:Object):boolean compare( o1: Object, o2: Object ) : number hash():number } interface Function { class(): Constructor } } /***@v3.0.0*/ export interface Serial { __serial__?:number } /***@Supplier*/ export interface supplier { get: supplierFn } export interface decoratorSupplier { get:decoratorSupplierFn } /***@objIntConsumer*/ export interface ObjIntConsumer { accept?( t:T, value:number ):void } /***@biConsumer*/ export interface biConsumer { accept?(p:T, q:P ): void } /***@collector*/ export interface collector{ supplier():supplier accumulator():biConsumer finisher( ):Func } /***@spliterator*/ export interface spliterator { /***/ tryAdvance( action: consumer ):boolean /***/ forEachRemaining(action: consumer):void /***/ trySplit():spliterator /***/ estimateSize():number } /***@classLoader*/ export interface classLoader{ /*** */ setMethod(method:Method): classLoader /** */ setField(field:Field):classLoader /*** */ instance(...argArray: Object[]): T setAnnotation(annotation:Annotation):Annotation[] } export interface ClassLoader { getParent():IClassLoader getResourceAsStream(name:string):InputStream loadClass(name:String):Class } export interface IClassLoader extends ClassLoader{ } /*** * */ export interface ObjectStructure { /*** * @getName : return name of Class */ getName():string getFullName():string /**/ isAnonymousClass():boolean /***/ isEnum():boolean /**/ isArray():boolean /**/ isAnnotation():boolean /**/ isPrimitive():boolean /**/ getPackage():Package /***/ getFields(type:number):Field[] /**/ getField(name:string, type:number):Field /***/ getMethod(name:string, type:number):Method /**/ getMethods( ):Method[] /*** * @getType */ getType(): string /*** * @newInstance return new Instance * @args : Object[] */ newInstance(...args: Object[]): T } /*** */ export interface PredicationConstructor extends Function{ /*** */ ( value : T, key? : ascii ) : boolean /*** */ test?( value : T ) : boolean /*** */ and?( Predicate : predicate) : predicate /** */ or?( other : predicate ) : predicate /** */ negate?(): predicate } /**@predicate*/ export interface predicate { /*** */ test : predicateFn /*** */ and?( other : predicate ) : predicate /*** */ or?( other: predicate ): predicate /*** */ negate?( ): predicate } /**** * */ export interface intStream{ mapToObj(supplier: Func):Stream map(supplier:Func): intStream each(consumer: IntConsumer): void limit(value:number):intStream filter(predicate: predicateFn): intStream allMatch(predicate: intPredicate): boolean anyMatch(predicate: intPredicate): boolean noneMatch(predicate: intPredicate):boolean findAny():OptionalInt findFirst(): OptionalInt average(): OptionalInt count():number sum():number min():OptionalInt max():OptionalInt boxed( ):Stream reduce(op:Function):OptionalInt reduceIdentity(identity:number, op:Function):number collect(supplier: supplier, consumer?:ObjIntConsumer, finisher?:BiConsumer): R collector(collector:collector):R } export interface ToTypeFunction { applyAs(type:T):R } /**MOCK*/ export interface Stream { allMatch(predicate:predication):boolean anyMatch(predicate:predication):boolean filter(predicate:predication):Stream noneMatch(predicate:predication):boolean collector(collector:collector):R limit(maxValue:number):Stream reduce(accumulator:Function ):Optional min(comparator:comparator):Optional max(comparator:comparator):Optional findAny( ):optional findFirst():optional flatMap>(mapper: Func): Stream count():number map(mapper:Func):Stream mapToInt(mapper:ToTypeFunction):intStream each(consumer:consumer):void sort( comparator: comparator ):Stream toObjectArray():Object[] toArray():T[] } /**@IntBinaryOperator*/ export interface IntBinaryOperator { applyAsInt(left:number, right:number):number } /**BiFunction*/ export interface BiFunction { apply(a:T, b:U):R; //andThen( func: Func):BiFunction } /***@IConsume*/ export interface IConsumer{ accept:consumerFn } /***@IntConsumerImpl*/ export interface IntConsumerImpl extends IConsumer{} /***@IStreamBuilder*/ export interface IStreamBuilder extends IConsumer{ add(t: T ): void build():R } /***@IntStreamBuilder*/ export interface IntStreamBuilder extends IStreamBuilder{ add(t: number ): IntStreamBuilder } /***@Iterable */ export interface Iterable { iterator( ): iterator forEach?(consumer:consumer):void } /** * @V3.0.0 * @collection * */ export interface collection extends Iterable { /*** */ add( value : E ) : boolean /*** */ addAll( collection : collection ) : boolean /*** */ clear( ) :void /** */ contains( o : Object ) : boolean /*** */ containsAll( collection : collection ) : boolean /*** */ equals( o : Object ) : boolean /*** */ remove( value : E ) : boolean /*** */ removeAll(value: Object):boolean /*** */ retainAll(value: Object):boolean /*** */ removeIf(predicate:predicate):boolean /*** */ isEmpty( ) : boolean /*** */ size( ) :number /*** */ stream(): Stream /*** */ toArray( ) : E[] /*** */ spliterator(from?:number, to?:number):spliterator /*** */ toJson( ) : MapType /*** */ toString():string } /***@Set*/ export interface Set extends collection{} /*** * */ export interface SortedSet extends Set{ comparator():comparator first():E last():E headSet():E spliterator():spliterator subSet(from:E,to:E):SortedSet tailSet():SortedSet } /**@v3.0.0*/ export interface List extends collection { /*** */ get(index:number):E /*** */ set(index:number,value:E):void /*** */ indexOf(o:Object):number //lastIndexOf(Object o) /*** */ replaceAll(oldValue:E, newValue:E):void /*** */ listIterator( ): ListIterator /*** */ sort(comparator?:Comparator):void /*** */ reverse():void /*** */ subList( from:number, to:number ):List /*** */ clone():List } /*** * @comparable * @comparator * @comparatorImpl */ /****/ export interface comparable { compareTo( obj : T ) :number } /**/ export interface comparator { /*** */ compare(o1: T, o2: T ): number /*** */ equals(o:Object):boolean /*** */ reversed?(): comparator reversed?(): comparator /** */ //thenComparing?( comparator: comparator ): comparator //thenComparingFn?>( comparator: comparatorFn ): comparator } /*** * @AComparator : usage as proxy interface for add some method * */ interface IComparator extends comparator{ reversed(): comparator // reversed(): Comparator //thenComparing(comparator: IComparator ):IComparator // thenComparing(comparator: IComparator ):IComparator // thenComparingFn>(comparatorFn: comparatorFn, comparator: comparator ):IComparator } /*** * @Iterator * @iteratorImp * @listIteratorInterface */ /*** * */ export interface IteratorInterface { /*** * */ hasNext( ) : boolean /*** * */ next( ) : E } /*3.0.0.0 Refactor*/ /*@iterator*/ export interface iterator extends IteratorInterface{ /*** * */ forEachRemaining?(consumer:consumer): void remove?():void } export interface listIteratorInterface { /*** */ hasPrevious( ) : boolean /*** */ nextIndex( ) : number /*** */ previousIndex() : number /*** */ previous( ) : E /*** */ set( e : E ) : void /*** */ add( e : E ) : void /*** */ } export interface Map { /*** */ clear( ): void /*** */ containsKey( key : K ) : boolean /*** */ containsValue( value : V ): boolean /*** */ entrySet() : Set> /*** */ equals( o : Object ) : boolean /*** */ get( key : Object ) : V /*** */ isEmpty( ) : boolean /*** */ keySet( ) : Set /*** */ put( key : K, value : V ) : V /*** */ remove( o : Object ): V /*** */ size( ) : number /*** */ valueCollection( ) : collection /*** */ // stream( ) : StreamAble } /*** * */ export interface MapEntries { getKey() : K getValue( ) : V setValue(value:V):V } /*** * */ export interface Enumeration { hasMoreElement( ) :boolean next(): E } /** * */ export interface optional { /**/ equals( obj : Object ) : boolean /**/ get( ) : T /**/ filter( predicate : predication ) : optional /**/ map( callback : Func ) : optional /**/ isEmpty(): boolean /**/ isPresent():boolean /***/ ifPresent(consumer:consumer):void /**/ orElse(other: T) : T /**/ orElseThrow( other : U ) : T /**/ orElseGet(other: supplier ):T /***/ orElseThrowSupplier(supplier :supplier) } /**@deprecated*/ interface OptionalInterface extends optional{} /***@Define*/ export interface define{ /*** * */ isNullable():boolean /*** * */ isNull(): boolean /*** * */ orNull( value : T ): T /*** * */ orElseThrow( exception : Error|TypeError ): T /*** * */ orThrow( exception : Object ): Define /*** * */ getType( ): string /*** * */ valueOf( ): T } /***@Runnable*/ export interface Runnable { run():void } /**@LuhnFormattedText*/ export interface LuhnFormattedText { check():boolean; get():string; } /*** * Properties */ export interface propertiesF{ /*** * * @param key * @param value */ setProperty( key : Object, value : Object ) : void /*** * * @param key * @param defaultValue */ getProperty( key: string, defaultValue?: Object ) : Object } /*** */ export interface properties extends propertiesF{ /*** */ hasKey( key : string ):boolean /*** */ load( input : InputStreamReader ) : void /*** */ stringPropertiesName( ) : Set /*** */ store( output: OutputStream ) : void } /**** * @toDelete */ export interface reader { /*** * */ read( ): string /*** * */ getLines(): List /*** * */ getIterator( ) :Iterator /*** * */ size( ):number /*** * */ reset( ): void } /**** * */ export interface writer { /*** * */ write( l:string): void } /*** * */ export interface fileStream { /*** * */ getPath( ): string /*** * */ getFileName( ):Path } /*** * Interface net/ */ export interface restHttp{ /*** * Get protocol used in string value http or http(s) */ getProto( ): string /*** * get http headers like an object */ /***@toFix*/ getHeaderAsObject( ) : any //HashMap /*** * GetDataAsObject return the response body request like an anonymous * object. This method follow response query. */ getDataAsObject( ) :any /*** * GetData return the response body like a string value. This method follow * response query. */ getData( ): string /*** */ setData( data : string ) :void /*** * */ /***@toFix*/ setHeader( header: /*HashMap*/any ):void /*** * Allow to send the http request */ request( ) : Promise /*** * Allows to define how the block buffer should be encoding to output */ setEncoding( encoding:BufferEncoding):restHttp /*** */ getEncoding( ):BufferEncoding /*** * */ setLoader( pipe:loader): restHttp /*** */ getLoader( ):loader /*** */ withFollowRedirect(state:boolean):restHttp } /*** * */ export interface wrapHeader { build( ) : T } /*** * */ export interface loader{ /*** */ setSizeOf( size:number ): loader /*** */ start( endingMessage : string ): loader /*** */ add( value:number ):void /*** */ end():void /*** */ error( message:string ):void }