📌 Nodepp | Stable Release | V1.2.0 📌

Author: EDBCREPO

README.md

@@ -36,13 +36,14 @@ One of the standout features of Nodepp is its 100% asynchronous architecture, po
 
 ## Build & Run
 ```bash
-🐧: g++ -o main main.cpp -I ./include ; ./main
-🪟: g++ -o main main.cpp -I ./include -lws2_32 ; ./main
+🐧: g++ -o main main.cpp -O3 -I ./include ; ./main
+🪟: g++ -o main main.cpp -O3 -I ./include -lws2_32 ; ./main
 ```
 
 ## Test Unit
 ```bash
-( cd ./test; g++ -o main main.cpp -I../include -lssl -lcrypto ; ./main )
+🐧: ( cd ./test; g++ -o main main.cpp -I../include -lssl -lcrypto -lpthread ; ./main )
+🪟: ( cd ./test; g++ -o main main.cpp -I../include -lssl -lcrypto -lws2_32  ; ./main )
 ```
 
 ## Examples
@@ -61,6 +62,8 @@ void onMain() {
 
 ### HTTP Client
 ```cpp
+//#pragma comment(lib, "Ws2_32.lib") msvc compiler
+
 #include <nodepp/nodepp.h>
 #include <nodepp/http.h>
 
@@ -90,6 +93,8 @@ void onMain(){
 
 ### HTTP Server
 ```cpp
+//#pragma comment(lib, "Ws2_32.lib") msvc compiler
+
 #include <nodepp/nodepp.h>
 #include <nodepp/http.h>
 #include <nodepp/date.h>
@@ -134,7 +139,6 @@ Check out some articles on [Medium](https://medium.com/@EDBCBlog)
 ## Compatibility
 - 🔗: [NodePP for Window | Linux | Mac | Bsd ](https://github.com/NodeppOfficial/nodepp)
 - 🔗: [NodePP for Arduino](https://github.com/NodeppOfficial/nodepp-arduino)
-- 🔗: [Nodepp for ESP32](https://github.com/NodeppOfficial/nodepp-ESPXX)
 - 🔗: [Nodepp for WASM](https://github.com/NodeppOfficial/nodepp-wasm)
 
 ## Official Libraries for Nodepp

examples/35-WS-Client.cpp

@@ -11,8 +11,8 @@ void onMain() {
     auto cin    = fs::std_input();
 
     client.onConnect([=]( ws_t cli ){ 
-        
-        console::log("connected"); 
+
+        console::log("connected", cli.get_peername() );
 
         cli.onData([]( string_t chunk ){ 
             console::log("client:>",chunk); 

examples/36-WS-Server.cpp

@@ -22,7 +22,7 @@ void onMain(){
 
     server.onConnect([=]( ws_t cli ){
 
-        console::log("connected");
+        console::log("connected", cli.get_peername() );
 
         cli.onData([=]( string_t data ){
             console::log( data );

examples/45-TCPClient.cpp

@@ -6,24 +6,31 @@ using namespace nodepp;
 void onMain(){
 
     auto client = tcp::client();
+    auto cin    = fs::std_input();
 
     client.onOpen([=]( socket_t cli ){
+
+        console::log("connected", cli.get_peername() );
 
         cli.onData([=]( string_t data ){
             console::log( data );
         });
 
+        cin.onData([=]( string_t data ){
+            cli.write( data );
+        });
+
         cli.onClose.once([=](){
             console::log("closed");
         });
 
-        cli.write("Hello World!");
         stream::pipe( cli );
+        stream::pipe( cin );
 
     });
 
     client.connect( "localhost", 8000, []( socket_t cli ){
-        console::log("client connected to tcp://localhost:8000");
+        console::log("-> tcp://localhost:8000");
     });
 
 }

examples/46-TCPServer.cpp

@@ -6,23 +6,31 @@ using namespace nodepp;
 void onMain(){
 
     auto server = tcp::server();
+    auto cin    = fs::std_input();
 
     server.onConnect([=]( socket_t cli ){
 
+        console::log("connected", cli.get_peername() );
+
         cli.onData([=]( string_t data ){
             console::log( data );
         });
 
+        cin.onData([=]( string_t data ){
+            cli.write( data );
+        });
+
         cli.onClose.once([=](){
             console::log("closed");
         });
-        
+
         stream::pipe( cli );
+        stream::pipe( cin );
 
     });
 
     server.listen( "localhost", 8000, []( socket_t srv ){
-        console::log("server started at tcp://localhost:8000");
+        console::log("-> tcp://localhost:8000");
     });
 
 }

examples/47-UDPClient.cpp

@@ -6,24 +6,31 @@ using namespace nodepp;
 void onMain(){
 
     auto client = udp::client();
+    auto cin    = fs::std_input();
 
-    client.onOpen([=]( socket_t cli ){
+    client.onConnect([=]( socket_t cli ){
+
+        console::log("connected", cli.get_peername() );
 
         cli.onData([=]( string_t data ){
             console::log( data );
         });
 
+        cin.onData([=]( string_t data ){
+            cli.write( data );
+        });
+
         cli.onClose.once([=](){
             console::log("closed");
         });
 
-        cli.write("Hello World!");
         stream::pipe( cli );
+        stream::pipe( cin );
 
     });
 
     client.connect( "localhost", 8000, []( socket_t cli ){
-        console::log("client connected to udp://localhost:8000");
+        console::log("-> udp://localhost:8000");
     });
 
 }

examples/48-UDPServer.cpp

@@ -6,23 +6,31 @@ using namespace nodepp;
 void onMain(){
 
     auto server = udp::server();
+    auto cin    = fs::std_input();
 
     server.onConnect([=]( socket_t cli ){
 
+        console::log("connected", cli.get_peername() );
+
         cli.onData([=]( string_t data ){
             console::log( data );
         });
 
+        cin.onData([=]( string_t data ){
+            cli.write( data );
+        });
+
         cli.onClose.once([=](){
             console::log("closed");
         });
 
         stream::pipe( cli );
+        stream::pipe( cin );
 
     });
 
     server.listen( "localhost", 8000, []( socket_t srv ){
-        console::log("server started at udp://localhost:8000");
+        console::log("-> udp://localhost:8000");
     });
 
 }

examples/49-TLSClient.cpp

@@ -8,24 +8,31 @@ ssl_t ssl; // ( "./ssl/cert.key", "./ssl/cert.crt" );
 void onMain(){
 
     auto client = tls::client( ssl );
+    auto cin    = fs::std_input();
 
-    client.onOpen([=]( ssocket_t cli ){
+    client.onConnect([=]( ssocket_t cli ){
+
+        console::log("connected", cli.get_peername() );
 
         cli.onData([=]( string_t data ){
             console::log( data );
         });
 
+        cin.onData([=]( string_t data ){
+            cli.write( data );
+        });
+
         cli.onClose.once([=](){
             console::log("closed");
         });
 
-        cli.write("hola mundo");
         stream::pipe( cli );
+        stream::pipe( cin );
 
     });
 
     client.connect( "localhost", 8000, []( socket_t cli ){
-        console::log("client started at tls://localhost:8000");
+        console::log("-> tls://localhost:8000");
     });
 
 }

examples/50-TLSServer.cpp

@@ -8,25 +8,31 @@ ssl_t ssl; // ( "./ssl/cert.key", "./ssl/cert.crt" );
 void onMain(){
 
     auto server = tls::server( ssl );
+    auto cin    = fs::std_input();
 
     server.onConnect([=]( ssocket_t cli ){
 
-        console::log("connected to:", cli.get_fd());
+        console::log("connected", cli.get_peername() );
 
         cli.onData([=]( string_t data ){
             console::log( data );
         });
 
+        cin.onData([=]( string_t data ){
+            cli.write( data );
+        });
+
         cli.onClose.once([=](){
             console::log("closed");
         });
 
         stream::pipe( cli );
+        stream::pipe( cin );
 
     });
 
     server.listen( "localhost", 8000, []( ssocket_t ){
-        console::log("server started at tls://localhost:8000");
+        console::log("-> tls://localhost:8000");
     });
 
 }

include/nodepp/any.h

@@ -26,38 +26,29 @@ public: any_t() noexcept {};
 
     /*─······································································─*/
 
-    uint type_size() const noexcept { return  any_sz.null()?0: *any_sz; }
-    ulong    count() const noexcept { return  any_ptr.count(); }
-    bool     empty() const noexcept { return  any_ptr.null (); }
-    bool has_value() const noexcept { return !any_ptr.null (); }
+    ulong type_size() const noexcept { return  empty() ?0 : any_ptr->size(); }
+    ulong     count() const noexcept { return  any_ptr.count(); } /*--------*/
+    bool      empty() const noexcept { return  any_ptr.null (); } /*--------*/
+    bool  has_value() const noexcept { return !any_ptr.null (); } /*--------*/
+    void       free() const noexcept { /*--*/  any_ptr.free (); } /*--------*/
 
     /*─······································································─*/
 
-    void free() const noexcept { any_ptr.free(); }
-
-    /*─······································································─*/
-
-    void operator=( const char* f ) noexcept { set( string::to_string(f) ); }
-
-    template< class T >
-    void operator=( const T& f ) noexcept { set( f ); }
-
     template< class T >
     T as() const { return get<T>(); }
 
     template< class T >
-    void set( const T& f ) noexcept {
-        any_sz  = new uint(sizeof(T));
-        any_ptr = new any_impl<T>(f);
-    }
+    void set( const T& f ) noexcept { any_ptr = new any_impl<T>(f); }
 
     template< class T >
-    T get() const {
-        char any [ sizeof(T)/sizeof(char) ]; if( !has_value() )
-          { throw except_t("any_t is null"); }  
-        if( *any_sz != sizeof(any)*sizeof(char) )
-          { throw except_t("any_t incompatible sizetype"); }
-        any_ptr->get((void*)&any); return *(T*)(any);
+    T get() const { const ulong size = sizeof(T) / sizeof( char );
+
+        if( !has_value() ) /*----*/ { throw except_t("any_t is null"); } /*---------*/
+        if( type_size()!=sizeof(T) ){ throw except_t("any_t incompatible sizetype"); }
+
+        char any [ size ]; any_ptr->get((void*)&any);
+        return *(T*)(any); /*----------------------*/
+
     }
 
     /*─······································································─*/
@@ -70,8 +61,9 @@ public: any_t() noexcept {};
     class any_base {
     public:
         virtual ~any_base() noexcept {}
-        virtual void get( void* /*unused*/ ) const noexcept {}
-        virtual void set( void* /*unused*/ )       noexcept {}
+        virtual void  get( void* /*unused*/ ) const noexcept {}
+        virtual void  set( void* /*unused*/ ) /*-*/ noexcept {}
+        virtual ulong size() /*------------*/ const noexcept = 0;
     };
 
     /*─······································································─*/
@@ -80,16 +72,16 @@ public: any_t() noexcept {};
     class any_impl : public any_base {
     public:
         any_impl( const T& f ) noexcept : any( f ) {}
-        virtual void get( void* argc ) const noexcept { memcpy( argc, (void*)&any, sizeof(T) ); }
-        virtual void set( void* argc )       noexcept { memcpy( (void*)&any, argc, sizeof(T) ); }
+        virtual ulong size() /*------*/ const noexcept { return sizeof(T); } /*-----------------*/
+        virtual void  get( void* argc ) const noexcept { memcpy( argc, (void*)&any, sizeof(T) ); }
+        virtual void  set( void* argc ) /*-*/ noexcept { memcpy( (void*)&any, argc, sizeof(T) ); }
     private:
         T any;
     };
 
     /*─······································································─*/
 
     ptr_t<any_base> any_ptr;
-    ptr_t<uint>     any_sz;
 
 };}