Lib-utils-ts NPM

!! 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<T>(): Class<T> : see
equals( object: Object ): boolean

Static :

isNull() : boolean : obj can be null or undefined
nonNull(obj:Object):boolean : check if an element is null
requireNotNull<T>( 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<T>(): Constructor<T> : see

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<string>
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<T>): boolean

Static :

asList<T>( value: T[] ) : ArrayList<T>
newList( ... value: T[] ) : ArrayList<T>
list( ... value: T[] ) : ArrayList<T>
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\<T>

Interface : constructor<T>
Class : public class Constructor extends Function implements constructor<T>

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<? extends Object>( ...args : Object[] ) :T

class foo{
    public value:string;

    constructor( value:string ){
        this.value = value;
    }

    public getValue( ):string{ /*...*/ }
}

let a: foo = new foo(125); // Ok

let b: Constructor<foo> = new Constructor(foo);
let c: foo = b.newInstance( 125 ); // OK
console.log( c.getValue( ) ); // 125

let d:  Constructor<foo> =  foo.class();
let e: foo = d.newInstance( 255 );
console.log( e.getValue() );

let f: foo = foo.class<foo>().newInstance(80);
console.log( f.getValue() );

Another example :

let str : Constructor<String> = new Constructor<String>(String);

console.log( str.newInstance("hello").toUpperCase() )

ClassLoader\<T>

Old class was been FunctionA, it was been deprecated

Interface : classLoader<T>, Function
Class : class ClassLoader<T> extends Constructor<T> implements classLoader<T>, Function

constructor :

( name: string, constructor: Function ) : FunctionA

Interface functionA<T> :

setPrototype(proto: Function | Object): ClassLoader<T>
setPrototype(proto: Function | Object): ClassLoader<T>
instance(...argArray: Object[]): T

Usage :

interface MyInterfaces{
    getValue():string
}

let fc : ClassLoader<MyInterfaces> = new ClassLoader(function(s){      
    this.value= s||"success";
});

fc.setPrototype({
    getValue: function(){ return this.value; }
});

fc.instance("Hello world !").getValue();
fc.class<MyInterfaces>().newInstance().getValue();

class\<T extends Object>( ) : Constructor\<T>

Object.class().newInstance(); // Object

Number.class().newInstance(255); // Object

String.class<String>().newInstance("foo").equals("bar"); // with generic

(<MyObj>MyObj.class().newInstance()); // cast

Class\<T>

Interface : classInterface
Class : class Class<T extends Object> implements classInterface<T>

getEntries( ): [any, string ][]
getType( ):string
getKeys( ): string[]
getInstance( ):T
cast( other: Object ):T
notNullProperties( ) : MapType<string, Object>
newInstance( ...args : Object[] ) :T
getResourcesAsStream( name: string): InputStreamReader

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

import {Constructor} from "./Class"; 

interface IMyInter{
    value:string,
    getValue( ):string    
}

Class.forName<IMyInter>("src.package.Class").newInstance(12).getValue();

Comparator\<T>

Interface : comparator<T>
Class : class Comparator<T> implements comparator<T>

Method :

compare(o1: T, o2: T ): number : To override
reversed?( ) : Compartor<T>
equals?(o:Object):boolean
thenComparing?( comparator: comparator<T> ): comparator<T>

class Test extends Comparator<Developer> /** implements comparator<Developer>*/{

    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<T>( comparator: comparator<T> ): Comparator<T>
nullsLast<T>( comparator: comparator<T> ): Comparator<T>
naturalOrder<T extends comparable<T>>( ): Comparator<T>
comparing<T,U extends comparable<T>>( comparatorFn: comparatorFn<T,U> ): Comparator<T>
comparingA<T,U extends comparable<T>>( comparatorFn: comparatorFn<T,U>, comparator: comparator<T> ): Comparator<T>

Comparators\<T>

Class : static abstract class Comparators<T>

Method static :

Reversed<T> implements comparator<T> : Object to instanced
NaturalOrder<T> implements comparator<comparable<Object>> : Instanced Object
NullComparators<T> implements comparator<T> : Object to instanced

Consumer\<T>

Interface : IConsumer<T>
Class : Consumer<T> implements IConsumer<T>
Class : IntConsumer implements IConsumer<number>
Class : BiConsumer<T,P> implements biConsumer<T,P>

Method to implemented for consumer:

accept:consumerFn<T> type of consumerFn<T> is a simple function (value:T) => void

//
let consumer: Consumer<string> = Consumer.of(value=>console.log(value));
consumer.accept("Accepted");
//
let consumer1: Consumer<string> = new Consumer();
consumer1.accept = value=>console.log(value);
consumer1.accept("Accepted");
//
class Test implements IConsumer<string>{
    accept = value=>console.log(value);
}
new Test().accept("Accepted");

Method to implemented for biconsumer:

accept:biConsumerFn<T,P>;

type biConsumerFn<T,P> is a function (o:T,v:U) => void

let consumer: BiConsumer<string[],string> = BiConsumer.of((o:string[],value:string)=> o.push(value) ),
tab:string[] = [];

consumer.accept( tab,"Accepted");

let consumer1: BiConsumer<string[],string> = new BiConsumer();
consumer1.accept = (o:string[],value:string)=> o.push(value);
consumer1.accept(tab, "Accepted-1");

class Test implements  biConsumer<string[],string>{
    accept = (o:string[],value:string)=> o.push(value)
}
new Test().accept(tab, "Accepted-2");

Enum

Class : abstract class Enum

Static method :

valueOf<T>(value:string):T
equals(o:Object):boolean

Decorator : \@

args( ...args:Object[] ):any

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<T extends comparable<T>>( list : List<T> ): void
static sortA<T>( list : List<T>, comparator: comparator<T> ): void
static swap<T>( list: List<T>,i : int, j: int ): void
static shuffle<T>( list: List<T>, rand: Random ): void
static replaceAll<T>( list: List<T>, oldVal : T, newVal: T ): void
static reverseOrder<T extends comparable<T>>():Comparator<T>

Usage

import {comparable} from "lib-utils-ts/src/Interface"

class Test implements comparable<Test>{

    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<Test> = 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

  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' }

import {comparable} from "lib-utils-ts/src/Interface"

class Test implements comparable<Test>{

    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());

  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\<E>

Methods

hasNext() : boolean
next() : E
- NoSuchElementException

ListIterator\<E>

Method

hasPrevious( ) : boolean
nextIndex( ) : number
previous( ) : E
- NoSuchElementException
set( e : E ) : void
add( e : E ) : void

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<String> = new Iterator<String>(lit_s);  
while( itr_a.hasNext() ){  
 console.log(" iterator a = "+ itr_a.next());}

  
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<String> = new ListIterator<String>(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\<E>

Constructor

( value : E ) : Optional<E>

Methods

get( ) : E
equals( obj : Object ) : boolean
isEmpty( ) : boolean
isPresent( ) : boolean
orElse( other : E ) : E
orElseThrow( other : E ) : E
filter( predicate : predication<E>) : Optional<E>
map( callback : lambaStream<E> ) : Optional<E>
mapTo( callback : lambdaType<E,U> ) : Optional<U>

Static :

of<T>( value : E ) : Optional<E>
NullPointerException
ofNullable<E>( value : E ) : Optional<E>

  
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\<T>

public Interface predicate\<T>

test( value : T ) : boolean
and( Predicate : predicate<T>) : predicate<T>
or( other : predicate<T> ) : predicate<T>
negate(): predicate<T>

Typescript is not java so, fit us :

Public class Predication<\T> implements predicate\<T>

usage :

let pobj0 : predicate<string> = new Predication();  
let pobj1 : predicate<string> = new Predication();
let pobj2 : predicate<string> = 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<string> = Predication.of(( value ,key)=> value==="foo");

p.and(pobj1).test();

let pobj0 : predicate<string> = new Predication();  
let pobj1 : predicate<string> = new Predication();
let pobj2 : predicate<string> = 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\<T>

let pfn : predicateFn<String> = value=> value.equals("azertyuiop");  
Optional.of("azertyuiop").map(pfn);

public PredicationConstructor\<String>

constructor : ( value : T, key\?\: ascii ) \: boolean
test( value : T ) : boolean
and( Predicate : predicate<T>) : predicate<T>
or( other : predicate<T> ) : predicate<T>
negate(): predicate<T>

let p : PredicationConstructor<String> = value => value.equals("azertyuiop");

List

Collections

static sort<T extends comparable<T>>( list : List<T> ): void
static sortA<T>( list : List<T>, comparator: comparator<T> ): void
static swap<T>( list: List<T>,i : int, j: int ): void
static shuffle<T>( list: List<T>, rand: Random ): void
static replaceAll<T>( list: List<T>, oldVal : T, newVal: T ): void

Interface Iterable\<E>

iterator( ): Iterator<T>

Interface Collections\<E>

public interface Collections\<E> extends Iterable\<E>

add( value : E ) : boolean
add(...value: E[]): boolean
addAll( collection : Collections<E> ) : boolean
clear( ) :void
contains( o : object ) : boolean
containsAll( collection : Collections<E> ) : boolean
equals( o : object ) : boolean
remove( key : E ) : boolean
isEmpty( ) : boolean
size( ) :number
toArray( ) : array<E>

Interface List\<E>

get( index : number ) : E
indexOf( value : object ) : number
lasIndexOf( value : object ) : number
set( index : number, element : E): E
listIterator( ) : ListIterator<E>
subList( from : number, to : number ): List<E>
stream( ) : Stream<E>

Interface Cloneable\<E>

clone( ) : ArrayList<E>

AbstractCollection\<E>

public abstract class AbstractCollection\<E> implements Collections\<E>

AbstractList\<E>

public abstract class AbstractList\<E> extends AbstractCollection\<E> implements List\<E>,NativeExportable\<E>

ArrayList\<E>

public class ArrayList\<E> extends AbstractList\<E> implements Cloneable\<E>,List\<E>,ArrayListInterfaceA\<E>

Constructor

( value : array<E> ) : ArrayList<E>

Methods

add(...value: E[]): void
addAll( collection : Collections<E> ): boolean
clear( ) : void
contains(o: Object): boolean
containsAll(collection: Collections<E>): boolean
equals(o: object): boolean
get( key : number ) : E
- indexOfBoundException
isEmpty(): boolean
size( ) : number
iterator(): Iterator<E>
listIterator( index number): ListIterator<E>
isEmpty( ) : boolean
stream( ) : Stream<E>
remove(key: E): boolean
indexOf( object : Object ) : number
lasIndexOf(value: object): number
set(index: number, element: E): E
subList(from: number, to: number): List<E>
shift( ) : E
pop( ): E
clone( ) : ArrayList<E>
toArray(): array<E>
of<E>( list : array<E> ): List<E>

import {List,List,LinkedList,HashMap} from 'lib-utils-ts';  
  
let boolList : List<Boolean> = new List<Boolean>();  
let stringList : List<String> = new List<String>();  
let numberList : List<Number> = new List<Number>();  
let objectList : List<Object> = new List<Object>();  
  
boolList.add(true);  
// boolList.add("string foo"); --> compilateur error  
  
stringList.add("a simple string");  
// stringList.add(true); --> compilateur error  
  
numberList.add(12);  
//numberList.add("a string"); --> compilateur error  
  
objectList.add({});  
objectList.add([]);  
//objectList.add(true); --> compilateur error  
  
let link : LinkedList<String> = new LinkedList<String>();  
let map : HashMap<Number> = new HashMap<Number>();  
  
link.put("key","value");  
/**...**/  
map.put("id",123456789);  
/**...*/  
  
class Personal{  

 readonly p : number; readonly q : number;

}  
  
let personalList : List<Personal> = new List<Personal>();  
  
personalList.add(new Personal());

Set\<E>

public interface Set\<E> extends Collections\<E>

AbstractSet\<E>

public abstract class AbstractSet\<E> extends AbstractCollection\<E> implements Set\<E>

SetList\<E>

public class SetList\<E> extends AbstractSet\<E>

Constructor

( ) : SetList<E>

Interface Map\<E>

clear( ): void
containsKey( key : K ) : boolean
containsValue( value : V ): boolean
entrySet() : Set<MapEntries<K,V>>
equals( o : Object ) : boolean
get( key : Object ) : V
isEmpty( ) : boolean
keySet( ) : Set<K>
put( key : K, value : V ) : V
remove( o : Object ): V
size( ) : number
valueCollection( ) : Collections<V>
each( callback : streamLambda<V> ): void

MapEntry\<K,V>

public class MapEntry<K,V> implements MapEntries<K,V>

Constructor

(key: K, value: V) : MapEntry

Methods

getKey(): K
getValue(): V

AbstractMap\<K extends string|number,V>

public abstract class AbstractMap\<K extends string|number,V> implements Map\<K,V>

HashMap\<K,V>

public class HashMap\<K extends ListKey,V> extends AbstractMap\<K , V>

Constructor

( ) : HashMap\<K,V>`

Methods

put(key: K, value: V): V
get(key: Object): V
containsKey(key: Object): boolean
containsValue(value : V): boolean
keySet(): Set<K>
entrySet(): Set<MapEntry<K, V>>
equals(o: Object): boolean
remove(o: Object): V
count( ) : number
each(callback : streamLambdaK<V,K>): V
size( ) : number
valueCollection(): Collections<V>
clear() : void
static of<V>( list : {} ):

  
import {HashMap} from 'lib-utils-ts';  
  
let list : HashMap<String,string> = new HashMap({});  
  
list.put("entry0","foo");  
list.put("entry1","bar");  
list.put("entry2","foo"); 

/***
 Iterable
***/

let hMap : HashMap<string, string> = new HashMap({ foo:"123",bar:"4545",});
// let setHMap : Set<MapEntries<string, string>> = ghj.entrySet();
let ItrHMap : Iterator<MapEntry<string, string>> = hMap.entrySet().iterator();

while (ItrHMap.hasNext()){
    let mapentry : MapEntry<string, string>  = ItrHMap.next();

    console.log(mapentry.getKey(),mapentry.getValue());
}

// OR

(<ArrayList<string>>ghj.valueCollection()).stream().each(value=>console.log(value));

Stream\<T>

Public class Stream implements ArrayStream,OptionalMapInterface<T,Stream>

Constructor

( value : Array<T> ) : Stream<T>

Methods

each( callback : streamLambda<T> ): Stream<T>
mapTo<U>( callback : lambdaType<T,U> ): Stream<U>
- indexOfBoundException
map( callback : streamLambda<T> ): Stream<T>
mapToInt( callback : streamLambda<T> ) : Stream<Number>
filter( callback : predication<T> ): Stream<T>
limit( limit : Number ): Stream<T>
findFirst( ) : Optional<T>
findAny( ) : Optional<T>
allMatch( callback : predication<T> ): boolean
anyMatch( callback : predication<T> ): boolean
noneMatch( callback : predication<T> ): boolean
hasPeer(): boolean
count(): number
sum( ) : Optional<Number>
count(): number
sort( comparatorFn: comparator<T>):Stream<T>
sorted( compareFn: (a: T, b: T) => number ) : Stream<T>
min(): Optional<Number>
max() : Optional<Number>
getList( ) : ArrayList<T>
toArray() : array<T>
iterator(): Iterator<T>
listIterator(): ListIterator<T>
of<T>( list : array<T> ): Stream<T>

  
let stream : Stream<String> = new Stream<String>();

mix List & Stream

  
import {List,List,Stream} from 'lib-utils-ts';  
  
let list : List<String> = new List<String>();  
  
list.add("title");  
list.add("some text");  
list.add("some text");  
list.add("");  
  
list = list.stream()  
 .filter(value=>value.length>0) .map(value=>value.equals("some text")) .getList();

  
import {List,List,Stream} from 'lib-utils-ts';  
  
let list : List<String> = new List<String>();  
  
list.add("title");  
list.add("some text");  
list.add("some text");  
list.add("");  
  
let predicate : predicateFn<String> = ( value : String, key ) => value.length>0;

// Accepted
list = list.stream()
    .filter(predicate)
    .mapTo(value=>value.equals("some text"))
    .getList();

//or
list = list.stream()
    .filter(value=>value.length>0)
    .mapTo(value=>value.equals("some text"))
    .getList();

Properties

Interface

public export interface IPropertiesFile\<K extends string|number,V>

setProperty( key : K, value : V ) : void
- NullPointerException : if key is null
getProperty( key: K, defaultValue?: V ) : V
- NullPointerException : if key is null

public interface properties\<V> extends IPropertiesFile\<string, V>

hasKey( key : string ):boolean
load( input : InputStreamReader ) : void
- NullPointerException
- IOException
stringPropertiesName( ) : Set<string>
store( output: OutputStreamWriter ) : void
update( ) : void
- NullPointerException
- IOException

Class

public Abstract class AbstractProperties\<V> implements properties\<V>

public class PropertiesA\<V> extends AbstractProperties\<V>

let prop : PropertiesA<string> = new PropertiesA<string>();
prop.setProperty("foo","bar");

public class Properties extends AbstractProperties\<Object>

let prop : Properties = new Properties();
prop.setProperty("foo","bar");
prop.setProperty("foo",1234);
prop.setProperty("foo",true);

public class PropertiesJson extends AbstractProperties\<Object>

let prop : PropertiesJson = new PropertiesJson();
prop.setProperty("foo","bar");
prop.setProperty("foo",1234);
prop.setProperty("foo",true);
prop.store(new FileWriter("./foo/bar.json"));

:checkered_flag: FLombok

A testing feature, be careful when using this method. make sure you have defined "experimentalDecorators" property to "true" in your tsconfig.json. This functionality may be changed in a future version.

version 0.0.1

FakeLombok is a decorator annotation, for use this

usage getter & setter properties annotation

GETTER( )
SETTER( )

class Test{
    
    @flombok.GETTER( )
    @flombok.SETTER( )
    public fooS :string;
    
    @flombok.GETTER( )
    @flombok.SETTER( )
    protected fooN : number;

    @flombok.GETTER( )
    @flombok.SETTER( )
    protected fooMO : MyObjectInterface;

    public getFooS: flombok.getStringFunc;
    public setFooS: flombok.setStringFunc;

    public getFooN: flombok.getNumberFunc;
    public setFooN: flombok.setNumberFunc;

    public getFooMO: flombok.accessorGetFunc<MyObjectInterface>;
    public setFooMO: flombok.accessorSetFunc<MyObjectInterface>;
}

let test : Test = new Test();

test.setFooS( "bar" );
console.log( test.getFooS( ) ); 

let mo  : MyObjectInterface = test.getFooMO( );

usage enumerable properties/method annotation

ENUMERABLE( enumerable: boolean, defaultValue: any = null )
- For apply this annotation to your class good way to use it is to no define value, but define 'defaultValue' in your annotation
ENUMERABLEFUNC( enumerable: boolean)

class Test{
    
    @flombok.ENUMERABLE( flase, "foo" ) 
    public fooS :string;
    
    @flombok.ENUMERABLE( true, 5 ) 
    protected fooN : number;

    @flombok.ENUMERABLE( flase ) // default null
    protected fooMO : MyObjectInterface;

}

console.log( ( new Test() ).getClass().getEntries() ); // []

RestHttp

Public Interface restHttp :

getProto( ): string
getHeaderAsObject( ) : HashMap<string,any>
getDataAsObject( ) :any
getData( ): string
setData( data : string ) :void
setHeader( header: HashMap<string,any> ):void
request( ) : Promise<Response>
setEncoding( encoding:BufferEncoding):restHttp
getEncoding( ):BufferEncoding
setLoader( pipe:loader): restHttp
getLoader( ):loader

RestHttp & RestHttps

static options( ) : HttpOptions<RestHttp>

import {Response,RestHttp} from "lib-utls-ts/src/net/Http";
import {Cookie} from "lib-utls-ts/src/net/Cookie";

let q : Response = RestHttp.options()
    .widthEndpoint("/end/point")
    .widthHostname("host")
    .get()
    .build()
    .setEncoding("utf-8")
    .request();

let cookie: Cookie = q.getCookies()
            .stream()
            .filter(value=> value.getName().equals("foo"))
            .findFirst()
            .get();

Feature

Old versions are deprecated
2.0.0-stable :
- Fix : Linux/Unix importation, Windows build some files in lowercase ( Stream → stream ), Now every release will be packaged in a Docker alpine:3.12 from a Jenkins pipeline
- Implement job jenkins
2.1.0-stable :
3.0.0 :
- Refactoring ArrayList :
  - AbstractCollection
  - AbstractArrayList
  - ArrayList
- Refactoring Native of the extensions
- Implements Arrays, Collections classes
- Refactoring Optional