# !! Big Refactoring !! Framework not operational. - clone realease 2.0.0-stable - clone master => 2.0.0-stable - Stream feature is disable in develop branch # Utils-ts ads : Lucas and Eric both are developer. Lucas use lib-utils-ts :registered:, and on the other hand Eric use basic javascript in his web browser. Development codes of Luca's are clean and structured, Lucas wins much precious times and can eat a little cake with a cup of tea :cowboy_hat_face::tea:. When with him Eric is a labyrinth developer, his code look like foam ball, result he is lost and upset :confused:. Lucas use power of the stream object, He optimizes his code and boost these performances. Actually, Eric read a big book how Javascript bêta work ed. 1995 for dummies, that grandfather gave him, but he has a lot of trouble understanding subtlety of javascript in all these pages :sweat:. Today Lucas has wins the better coding champion league of the world :sunglasses:, Eric resign finally oneself to give up and pass to HTML :disappointed:. Don't be like Eric make rather like Lucas and use `lib-utils-ts` :registered:. A career may be played on a byt\(e\), Let's reveal together the power of your development. \( * \) You come from to Java, you want improve your javascript structure, learn object language easily with little framework below, it implements some Java7 & 8 classes like ArrayList, Properties, lombok. \:P :sweat_smile: This framework has been created only for Typescript projects, it's possible to use it for javascript project but is not really adapted for this, cause generics is not support by the native javascript. Dev : :star::star::star::star::star: # Why When i have start to my job, I had to work with the Java, but Java is was't been my favorite language buts with time i learned to love it. in the beginning develop sometimes it was really hard ... after, i had to work with Typescript, JS a language i master it really well, but its language too permissive not enaugth strcutured. And i had discover Typescript who allows to strucutred Js developpment in real. In first i have decide to implement a speudo code of Stream in typescript JS, more later, I have decide to implement some elements to Java. that allows to learn Java easly without compilation error. navigation betwenn the a permissive language & typed lanuage that is allows too to see how Java work. I try to be iso Java but sometimes its not possibles ## Set up `npm i lib-utils-ts` # Native Extension Importation : `import "lib-utils-ts/src/globalUtils"` For enabled this framework you need to import globalUtils to you root project, This import provides access to the methods of these native objects that have been extended `Object`, `FunctionA`, `Number`, `String`, `Date`, `Boolean`. And so many others : #### Object Instanced Object : + `getClass(): Class` : [see](https://github.com/devGnode/lib-utils-ts#classt) + `equals( object: Object ): boolean` Static : + `isNull() : boolean` : obj can be null or undefined + `nonNull(obj:Object):boolean` : check if an element is null + `requireNotNull( other: T, message?: string ) :T ` - NullPointerException + `compare( o1:Object, o2: Object ): number` + `equals( o1: Object, o2: Object ): number` + `deepEquals( o1: Object, o2:Object ):boolean` + `typeof(o:Object):PrimitiveType` #### FunctionA + `class(): Constructor` : [see](https://github.com/devGnode/lib-utils-ts#constructort) ##### Number + `equals( value : number ) : boolean ` + `compareTo( other : number ): number` + `isPrime( ): boolean` Static : + `of( value: Object) : number` + `compare( o1: number, o2: number ): number` #### String + `quals( value :string ) : boolean` + `equalsIgnoreCase( value : string ): boolean` + `contains( value: string ) : boolean` + `isEmpty( ) : boolean` + `regExp( regExp : RegExp, callback : FunctionA ) : string` + `repeatString( char : String, loop : number ) : string` + `format( ... args : any[] ) : string` + `exec( regExp : RegExp ) : String[]` + `explodeAsList( ) : ArrayList` + `orDefault( value : string ): string` + `compareTo( other : string ): number` Static : + `compare(o1:String ,o2:String):number` #### Date + `plusDays( days : number ) : Date` + `lessDays( days : number) : Date` + `plusYears( years : number ): Date` + `lessYears( years : number ) :Date ` + `dateFormat( pattern : string ) : Date` + `elapsedTime( date : Date ) : number` Static : + `dateFormat( pattern : string ) : Date` + `compare(o1:Date ,o2:Date):number` #### Array + `equals(o: Array): boolean` Static : + `asList( value: T[] ) : ArrayList` + `newList( ... value: T[] ) : ArrayList` + `list( ... value: T[] ) : ArrayList` + `sum( ) : number` #### Boolean + `state( expectTrue : any, orElse : any ) : any` + `equals( value: boolean ) : boolean` + `compareTo(obj: boolean): number` Static : + `of( value: Object) : Boolean` + `compare(o1:boolean,o2:boolean):number` # Interfaces Importation : `import "lib-utils-ts/src/Interfaces"` You will find all the interfaces in this file. All interfaces name are in lowerCase # Framework ## Constructor\ - Interface : `constructor` - Class : `public class Constructor extends Function implements constructor` As in javascript an object is also a function, these class depict a next future instanced object - `getName( ):string` - `getType( ):string` - `getEntries( ): [any, string ][]` - `getKeys( ): string[]` - `cast( other: Object ):T` - `newInstance( ...args : Object[] ) :T` - `getResourcesAsStream( name: string): InputStreamReader` Fix : - `< 1.3.1` class `MyObj` . getType → MyObj - `>= 1.3.1` class `MyObj` . getType → Object Static : - `forname( ...args : Object[] ) :T` ````typescript class foo{ public value:string; constructor( value:string ){ this.value = value; } public getValue( ):string{ /*...*/ } } let a: foo = new foo(125); // Ok let b: Constructor = new Constructor(foo); let c: foo = b.newInstance( 125 ); // OK console.log( c.getValue( ) ); // 125 let d: Constructor = foo.class(); let e: foo = d.newInstance( 255 ); console.log( e.getValue() ); let f: foo = foo.class().newInstance(80); console.log( f.getValue() ); ```` Another example : ````typescript let str : Constructor = new Constructor(String); console.log( str.newInstance("hello").toUpperCase() ) ```` ## ClassLoader\ Old class was been FunctionA, it was been deprecated - Interface : `classLoader, Function` - Class : `class ClassLoader extends Constructor implements classLoader, Function` constructor : - ( name: string, constructor: Function ) : FunctionA Interface `functionA` : - `setPrototype(proto: Function | Object): ClassLoader` - `setPrototype(proto: Function | Object): ClassLoader` - `instance(...argArray: Object[]): T` Usage : ````typescript interface MyInterfaces{ getValue():string } let fc : ClassLoader = new ClassLoader(function(s){ this.value= s||"success"; }); fc.setPrototype({ getValue: function(){ return this.value; } }); fc.instance("Hello world !").getValue(); fc.class().newInstance().getValue(); ```` - class\( ) : Constructor\ ````typescript Object.class().newInstance(); // Object Number.class().newInstance(255); // Object String.class().newInstance("foo").equals("bar"); // with generic (MyObj.class().newInstance()); // cast ```` ## Class\ - Interface : `classInterface` - Class : `class Class implements classInterface` - `getEntries( ): [any, string ][]` - `getType( ):string` - `getKeys( ): string[]` - `getInstance( ):T` - `cast( other: Object ):T` - `notNullProperties( ) : MapType` - `newInstance( ...args : Object[] ) :T` - `getResourcesAsStream( name: string): InputStreamReader` ````typescript class foo{ public value:string; constructor( value:string ){ this.value = value; } public getValue( ):string{ return this.value; } } let a: foo = new foo(125); // Ok a.getClass().getType( ); // => foo ```` Class forname : Package pattern `package.name.src.Class` replace all `/` or `\\` character by `.` dot character in your package path. If your Class file contain several class, the package pattern will look like: `packe.name.src.Class/pointer` ````typescript import {Constructor} from "./Class"; interface IMyInter{ value:string, getValue( ):string } Class.forName("src.package.Class").newInstance(12).getValue(); ```` ## Comparator\ - Interface : ` comparator` - Class : `class Comparator implements comparator` Method : - `compare(o1: T, o2: T ): number` : To override - `reversed?( ) : Compartor` - `equals?(o:Object):boolean` - `thenComparing?( comparator: comparator ): comparator` ````typescript class Test extends Comparator /** implements comparator*/{ public compare = (o1: Developer, o2: Developer): number =>{ return o1.getAge().compareTo( o2.getAge() ) //return o1.getAge() - o2.getAge(); //return o1.getSalary().compareTo(o2.getSalary()) } } ```` static - `nullsFirst( comparator: comparator ): Comparator` - `nullsLast( comparator: comparator ): Comparator` - `naturalOrder>( ): Comparator` - `comparing>( comparatorFn: comparatorFn ): Comparator` - `comparingA>( comparatorFn: comparatorFn, comparator: comparator ): Comparator` ## Comparators\ - Class : `static abstract class Comparators` Method static : - `Reversed implements comparator` : Object to instanced - `NaturalOrder implements comparator>` : Instanced Object - `NullComparators implements comparator` : Object to instanced ## Consumer\ - Interface : ` IConsumer` - Class : `Consumer implements IConsumer` - Class : `IntConsumer implements IConsumer` - Class : `BiConsumer implements biConsumer` Method to implemented for consumer: - `accept:consumerFn` type of `consumerFn` is a simple function `(value:T) => void` ````typescript // let consumer: Consumer = Consumer.of(value=>console.log(value)); consumer.accept("Accepted"); // let consumer1: Consumer = new Consumer(); consumer1.accept = value=>console.log(value); consumer1.accept("Accepted"); // class Test implements IConsumer{ accept = value=>console.log(value); } new Test().accept("Accepted"); ```` Method to implemented for biconsumer: - `accept:biConsumerFn`; type `biConsumerFn` is a function `(o:T,v:U) => void` ````typescript let consumer: BiConsumer = BiConsumer.of((o:string[],value:string)=> o.push(value) ), tab:string[] = []; consumer.accept( tab,"Accepted"); let consumer1: BiConsumer = new BiConsumer(); consumer1.accept = (o:string[],value:string)=> o.push(value); consumer1.accept(tab, "Accepted-1"); class Test implements biConsumer{ accept = (o:string[],value:string)=> o.push(value) } new Test().accept(tab, "Accepted-2"); ```` ## Enum - Class : `abstract class Enum` Static method : - `valueOf(value:string):T` - `equals(o:Object):boolean` Decorator : \@ - `args( ...args:Object[] ):any` ````typescript class TestDevice extends Enum{ @Enum.args("cellphone",200,300) static IOS:TestDevice; @Enum.args("desktop",1080,720) static WINDOW:TestDevice; private readonly device:string; private readonly width:number; private readonly height:number; private constructor(device:string, width: number, height:number) { super(); this.device = device; this.width = width; this.height= height; } public getDevice():string{return this.device;} public getWidth():number{ return this.width; } public getHeight():number{ return this.height; } } /*** * */ let window: TestDevice = TestDevice.valueOf("WINDOW"); let ios: TestDevice = TestDevice.valueOf("IOS"); ```` ## Define Method static : Public static Collections - `static sort>( list : List ): void` - `static sortA( list : List, comparator: comparator ): void` - `static swap( list: List,i : int, j: int ): void` - `static shuffle( list: List, rand: Random ): void` - `static replaceAll( list: List, oldVal : T, newVal: T ): void` - `static reverseOrder>():Comparator` ##### Usage ````typescript import {comparable} from "lib-utils-ts/src/Interface" class Test implements comparable{ public n: number = 0; public str:string; constructor(n:number,value:string) {this.n = n; this.str=value;} public compareTo(o: Test): number { return this.n - o.n; } } let l: List = new ArrayList(); l.add(new Test(55,"aaa")); l.add(new Test(5,"aa")); l.add(new Test(1,"z")); l.add(new Test(125,"zzzzzzzz")); l.add(new Test(0,"def")); l.add(new Test(56,"lkjhg")); l.add(new Test(2,"lkmlpolo")); l.add(new Test(255,"aztgrbcekielflflf")); Collections.sort(l); console.log(l.stream().toArray()); ```` output ````log Test { s: 0, str: 'def' }, Test { s: 1, str: 'z' }, Test { s: 5, str: 'aa' }, Test { s: 55, str: 'aaa' }, Test { s: 2, str: 'lkmlpolo' }, Test { s: 56, str: 'lkjhg' }, Test { s: 125, str: 'zzzzzzzz' }, Test { s: 255, str: 'aztgrbcekielflflf' } ```` ````typescript import {comparable} from "lib-utils-ts/src/Interface" class Test implements comparable{ public n: number = 0; public str:string; constructor(n:number,value:string) {this.n = n; this.str=value;} public compareTo(o: Test): number { return this.str.compareTo( o.str ); } } /* .... */ Collections.sort(l); console.log(l.stream().toArray()); ```` ````log Test { s: 1, str: 'z' }, Test { s: 5, str: 'aa' }, Test { s: 55, str: 'aaa' }, Test { s: 0, str: 'def' }, Test { s: 56, str: 'lkjhg' }, Test { s: 2, str: 'lkmlpolo' }, Test { s: 125, str: 'zzzzzzzz' }, Test { s: 255, str: 'aztgrbcekielflflf' } ```` ## Iterator\ **Methods** - `hasNext() : boolean` - `next() : E` - NoSuchElementException ## ListIterator\ **Method** - `hasPrevious( ) : boolean` - `nextIndex( ) : number` - `previous( ) : E` - NoSuchElementException - `set( e : E ) : void` - `add( e : E ) : void` ```typescript let lit_s : String[] = []; lit_s[0] = "some text 1"; lit_s[1] = "some text 2"; lit_s[2] = "some text 3"; lit_s[3] = "some text 4"; let itr_a : Iterator = new Iterator(lit_s); while( itr_a.hasNext() ){ console.log(" iterator a = "+ itr_a.next());} ``` ```typescript let lit_s : String[] = []; lit_s[0] = "some text 1"; lit_s[1] = "some text 2"; lit_s[2] = "some text 3"; lit_s[3] = "some text 4"; let itr_la : ListIterator = new ListIterator(lit_s); while( itr_la.hasNext() ) { console.log(" iterator value => "+ itr_la.next());} console.log("\n"); while( itr_la.hasPrevious() ){ console.log(" iterator value => "+ itr_la.previous()); console.log(" hasPrevious => "+ itr_la.hasPrevious());} ```` ## Optional\ **Constructor** - `( value : E ) : Optional` **Methods** - `get( ) : E` - `equals( obj : Object ) : boolean` - `isEmpty( ) : boolean` - `isPresent( ) : boolean` - `orElse( other : E ) : E` - `orElseThrow( other : E ) : E` - `filter( predicate : predication) : Optional` - `map( callback : lambaStream ) : Optional` - `mapTo( callback : lambdaType ) : Optional` **Static** : - `of( value : E ) : Optional` - NullPointerException - `ofNullable( value : E ) : Optional` ````typescript let returned : boolean = Optional.ofNullable(null).isEmpty(); console.log("returned value => ", returned ); let value : String = Optional.ofNullable(null).orElse("default value"); console.log("value equals to =>", value); Optional.ofNullable(null).orElseThrow(new Error("Failed error")); // throw ```` ## Predicatation\ public Interface **predicate**\ - `test( value : T ) : boolean` - `and( Predicate : predicate) : predicate` - `or( other : predicate ) : predicate` - `negate(): predicate` Typescript is not java so, fit us : Public class **Predication**<\T\> implements **predicate**\ usage : ````typescript let pobj0 : predicate = new Predication(); let pobj1 : predicate = new Predication(); let pobj2 : predicate = new Predication(); pobj0.test = value => value.startWith("f");< pobj1.test = value => value.endWith("oo"); pobj2.test = value => value.equals("Hello World !"); console.log( pobj0.and(pobj1).test( "f1oo" ) ); // true console.log( pobj0.and(pobj1).test( "Hello World !" ) ); // false console.log( pobj0.and(pobj1).or(pobj2) ).test( "Hello World !" ) ); // true let p: predicate = Predication.of(( value ,key)=> value==="foo"); p.and(pobj1).test(); ```` ````typescript let pobj0 : predicate = new Predication(); let pobj1 : predicate = new Predication(); let pobj2 : predicate = new Predication(); pobj0.test = value => value.startWith("f"); pobj1.test = value => value.endWith("oo"); pobj2.test = value => value.equals("Hello World !"); list.stream().map( pobj0.and(pobj1).or(pobj2) ); ```` - **type** predicateFn\ ````typescript let pfn : predicateFn = value=> value.equals("azertyuiop"); Optional.of("azertyuiop").map(pfn); ```` public **PredicationConstructor**\ - constructor : ( value : T, key\?\: ascii ) \: boolean - `test( value : T ) : boolean` - `and( Predicate : predicate) : predicate` - `or( other : predicate ) : predicate` - `negate(): predicate` ````typescript let p : PredicationConstructor = value => value.equals("azertyuiop"); ```` # List ### Collections - `static sort>( list : List ): void` - `static sortA( list : List, comparator: comparator ): void` - `static swap( list: List,i : int, j: int ): void` - `static shuffle( list: List, rand: Random ): void` - `static replaceAll( list: List, oldVal : T, newVal: T ): void` ### Interface Iterable\ `iterator( ): Iterator` ## Interface Collections\ public interface Collections\ extends Iterable\ - `add( value : E ) : boolean` - `add(...value: E[]): boolean` - `addAll( collection : Collections ) : boolean` - `clear( ) :void` - `contains( o : object ) : boolean` - `containsAll( collection : Collections ) : boolean` - `equals( o : object ) : boolean` - `remove( key : E ) : boolean` - `isEmpty( ) : boolean` - `size( ) :number` - `toArray( ) : array` ## Interface List\ - `get( index : number ) : E` - `indexOf( value : object ) : number` - `lasIndexOf( value : object ) : number` - `set( index : number, element : E): E` - `listIterator( ) : ListIterator` - `subList( from : number, to : number ): List` - `stream( ) : Stream` ## Interface Cloneable\ - `clone( ) : ArrayList` ## AbstractCollection\ public abstract class **AbstractCollection\** implements **Collections\** ## AbstractList\ public abstract class **AbstractList\** extends **AbstractCollection\** implements **List\**,**NativeExportable\** ## ArrayList\ public class **ArrayList\** extends **AbstractList\** implements **Cloneable\**,**List\**,**ArrayListInterfaceA\** **Constructor** - `( value : array ) : ArrayList` **Methods** - `add(...value: E[]): void` - `addAll( collection : Collections ): boolean` - `clear( ) : void` - `contains(o: Object): boolean` - `containsAll(collection: Collections): boolean` - `equals(o: object): boolean` - `get( key : number ) : E` + indexOfBoundException - `isEmpty(): boolean` - `size( ) : number` - `iterator(): Iterator` - `listIterator( index number): ListIterator` - `isEmpty( ) : boolean` - `stream( ) : Stream` - `remove(key: E): boolean` - `indexOf( object : Object ) : number` - `lasIndexOf(value: object): number ` - `set(index: number, element: E): E` - `subList(from: number, to: number): List` - `shift( ) : E ` - `pop( ): E` - `clone( ) : ArrayList` - `toArray(): array` - `of( list : array ): List` ```typescript import {List,List,LinkedList,HashMap} from 'lib-utils-ts'; let boolList : List = new List(); let stringList : List = new List(); let numberList : List = new List(); let objectList : List