Skip to content

Commit 89f33e2

Browse files
EDBCREPOEDBCREPO
committed
nodepp v1.4.0_0
1 parent bf13491 commit 89f33e2

File tree

9 files changed

+167
-69
lines changed

9 files changed

+167
-69
lines changed

‎examples/7-workers-2-mainthread.cpp‎

Lines changed: 56 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
#include <nodepp/nodepp.h>
2+
#include <nodepp/worker.h>
3+
#include <nodepp/timer.h>
4+
#include <nodepp/http.h>
5+
#include <nodepp/date.h>
6+
7+
using namespace nodepp;
8+
9+
void server(){
10+
11+
auto server = http::server([=]( http_t cli ){
12+
13+
console::log( cli.path, cli.get_fd() );
14+
15+
cli.write_header( 200, header_t({
16+
{ "content-type", "text/html" }
17+
}));
18+
19+
cli.write( date::fulltime() );
20+
cli.close();
21+
22+
});
23+
24+
server.onError([=]( except_t err ){
25+
console::log( ">>", err.what() );
26+
});
27+
28+
server.listen( "localhost", 8000, [=]( socket_t server ){
29+
console::log("server started at http://localhost:8000");
30+
});
31+
32+
}
33+
34+
void onMain(){
35+
36+
auto krn = process::kernel();
37+
38+
worker::add([=](){
39+
40+
server();
41+
42+
krn.loop_add( coroutine::add( COROUTINE(){
43+
coBegin
44+
45+
while( true ){
46+
console::log( "hello world" );
47+
coDelay(1000); }
48+
49+
coFinish
50+
}) );
51+
52+
krn.wake();
53+
54+
process::wait(); return -1; });
55+
56+
}

‎include/nodepp/coroutine.h‎

Lines changed: 7 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -52,11 +52,13 @@ namespace nodepp { class coroutine_t {
5252
bool is_available() const noexcept { return obj->alive; }
5353

5454
/*─······································································─*/
55-
56-
int emit () const { return next(); } int next() const {
57-
if ( !obj->alive ){ return -1; }
58-
return obj->callback( obj->state, obj->time );
59-
} coEmit() const { return emit(); }
55+
56+
int operator()() const { return emit(); }
57+
58+
int emit() const {
59+
if ( !obj->alive ){ return -1; }
60+
return obj->callback( obj->state, obj->time );
61+
}
6062

6163
}; }
6264

‎include/nodepp/encoder.h‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -257,8 +257,7 @@ namespace nodepp { namespace encoder { namespace base64 {
257257

258258
inline string_t set( const string_t &in ) {
259259

260-
queue_t<char> out; int pos1=0, pos2=-8;
261-
array_t<int> T( 256, -1 );
260+
queue_t<char> out; int pos1=0, pos2=-8; ptr_t<int> T( 256, -1 );
262261

263262
for ( int i=0; i<64; ++i ) T[NODEPP_BASE64[i]] = i;
264263
for ( uchar c: in ) { if ( T[c]==-1 ) break;

‎include/nodepp/macros.h‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -61,10 +61,8 @@ template< class T > T clamp( const T& val, const T& _min, const T& _max ){ retur
6161

6262
/*────────────────────────────────────────────────────────────────────────────*/
6363

64-
#define GENERATOR(NAME) struct NAME : public nodepp::generator_t
65-
#define COROUTINE() [=]( int& _state_, ulong& _time_ )
66-
#define coGenerator(NAME) GENERATOR(NAME)
67-
#define coCoroutine() COROUTINE()
64+
#define GENERATOR(NAME) struct NAME : public nodepp::generator_t
65+
#define COROUTINE() [=]( int& _state_, ulong& _time_ )
6866

6967
/*────────────────────────────────────────────────────────────────────────────*/
7068

‎include/nodepp/nodepp.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -101,6 +101,7 @@ namespace nodepp { namespace process {
101101
/*─······································································─*/
102102

103103
inline array_t<string_t>& arguments() { return NODEPP_ARGMNT(); }
104+
inline kernel_t& /*----*/ kernel () { return NODEPP_EVLOOP(); }
104105

105106
template< class... T >
106107
void error( const T&... msg ){ throw except_t( msg... ); }

‎include/nodepp/posix/kernel.h‎

Lines changed: 29 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -128,35 +128,36 @@ namespace nodepp { class kernel_t {
128128

129129
ulong tasks= obj->ev_queue.size() + obj->probe.get();
130130
ulong TIME = get_timeout();
131-
ulong time = TIME==0 || tasks==0 ? 1 : TIME;
132131

133132
if(!obj->kv_queue.empty() && tasks==0 ){
134133
if( obj.count()==1 ){ return nullptr; }}
134+
if( obj->kv_queue.empty() && tasks==0 ){
135+
if( obj.count()> 1 ){ return nullptr; }}
135136

136137
ptr_t<ETIMER> ts( 0UL, ETIMER() );
137138

138-
ts->tv_sec = time / 1000;
139-
ts->tv_nsec = (time % 1000) * 1000000;
139+
ts->tv_sec = TIME / 1000;
140+
ts->tv_nsec = (TIME % 1000) * 1000000;
140141

141142
return ts; }
142143

143144
int get_delay_ms() const noexcept {
144145
ulong tasks= obj->ev_queue.size() + obj->probe.get();
145-
ulong TIME = get_timeout();
146146
if(!obj->kv_queue.empty() && tasks==0 ){
147147
if( obj.count()==1 ){ return -1; }}
148-
return TIME; }
148+
if( obj->kv_queue.empty() && tasks==0 ){
149+
if( obj.count()> 1 ){ return -1; }}
150+
return get_timeout(); }
149151

150152
protected:
151153

152154
struct NODE {
153-
int pd, ed, idx; bool pl=true;
155+
ulong /*--*/ timeout; int pd, ed, idx; bool pl=true;
156+
uchar batch= NODEPP_MAX_BATCH_SIZE;
154157
loop_t /*------*/ ev_queue;
155158
queue_t<kevent_t> kv_queue;
156159
probe_t /*-----*/ probe;
157-
uchar batch = NODEPP_MAX_BATCH_SIZE;
158160
ptr_t<EPOLLFD> ev;
159-
ulong /*--*/ timeout;
160161
}; ptr_t<NODE> obj;
161162

162163
public:
@@ -210,7 +211,7 @@ namespace nodepp { class kernel_t {
210211
/*─······································································─*/
211212

212213
template< class T, class U, class... W >
213-
ptr_t<task_t> poll_add( T& inp, int flag, U cb, ulong timeout=0, const W&... args ) noexcept {
214+
ptr_t<task_t> poll_add( T& inp, int flag, U cb, ulong timeout=0, const W&... args ) const noexcept {
214215
if( cb( args... )==-1 ){ return nullptr; }
215216

216217
kevent_t kv;
@@ -229,8 +230,6 @@ namespace nodepp { class kernel_t {
229230
task->sign = &obj;
230231

231232
if( task->addr==nullptr ){ if( is_std( kv.fd ) ){
232-
233-
auto clb = type::bind( cb );
234233

235234
return loop_add( coroutine::add( COROUTINE(){
236235
coBegin;
@@ -246,7 +245,7 @@ namespace nodepp { class kernel_t {
246245
return task; }
247246

248247
template< class... T >
249-
ptr_t<task_t> loop_add( const T&... args ) noexcept {
248+
ptr_t<task_t> loop_add( const T&... args ) const noexcept {
250249
return obj->ev_queue.add( args... );
251250
}
252251

@@ -296,10 +295,8 @@ namespace nodepp { class kernel_t {
296295
if( obj->pl ){ obj->idx=epoll_pwait2( obj->pd, &obj->ev, obj->ev.size(),&get_delay_tm(), nullptr ); }
297296
if( obj->idx==-1 && errno==ENOSYS ) { obj->pl = false; }
298297
if(!obj->pl ){ obj->idx=epoll_wait ( obj->pd, &obj->ev, obj->ev.size(), get_delay_ms() ); }
299-
if( obj->idx <= 0 ){ return 1; }
300298
#else
301299
/*----------*/ obj->idx=epoll_wait ( obj->pd, &obj->ev, obj->ev.size(), get_delay_ms() );
302-
if( obj->idx <= 0 ){ return 1; }
303300
#endif
304301

305302
/* EXCECUTION */
@@ -409,7 +406,7 @@ namespace nodepp { class kernel_t {
409406
EV_SET( &event, fd, fl, EV_DELETE, 0, 0, NULL );
410407
kevent( obj->pd, &event, 1, NULL, 0, NULL );
411408

412-
obj->kv_queue.erase(kv); return 0; }
409+
obj->kv_queue.erase(kv); return 1; }
413410

414411
/*─······································································─*/
415412

@@ -450,8 +447,10 @@ namespace nodepp { class kernel_t {
450447
ulong TIME = get_timeout();
451448

452449
if(!obj->kv_queue.empty() && tasks==0 ){
453-
if( obj.count()==1 ){ return nullptr; }}
454-
450+
if( obj.count()==1 ){ return nullptr; }}
451+
if( obj->kv_queue.empty() && tasks==0 ){
452+
if( obj.count()> 1 ){ return nullptr; }}
453+
455454
ptr_t<KTIMER> ts( 0UL, KTIMER() );
456455

457456
ts->tv_sec = TIME / 1000;
@@ -461,26 +460,28 @@ namespace nodepp { class kernel_t {
461460

462461
int get_delay_ms() const noexcept {
463462
ulong tasks= obj->ev_queue.size() + obj->probe.get();
464-
ulong TIME = get_timeout();
465463
if(!obj->kv_queue.empty() && tasks==0 ){
466-
if( obj.count()==1 ){ return -1; }}
467-
return TIME; }
464+
if( obj.count()==1 ){ return -1; }}
465+
if( obj->kv_queue.empty() && tasks==0 ){
466+
if( obj.count()> 1 ){ return -1; }}
467+
return get_timeout(); }
468468

469469
protected:
470470

471471
struct NODE {
472-
ulong /*--*/ timeout; int pd, idx;
472+
ulong /*--*/ timeout; int pd, idx ;
473+
uchar batch= NODEPP_MAX_BATCH_SIZE;
473474
loop_t /*------*/ ev_queue;
474475
queue_t<kevent_t> kv_queue;
475476
probe_t /*-----*/ probe;
476-
uchar batch = NODEPP_MAX_BATCH_SIZE;
477477
ptr_t<KPOLLFD> ev;
478478
}; ptr_t<NODE> obj;
479479

480480
public:
481481

482482
~kernel_t() noexcept {
483-
if( obj.count() > 1 ){ return; } close( obj->pd );
483+
if( obj.count() > 1 ){ return; }
484+
close( obj->pd ); /*----------*/
484485
}
485486

486487
kernel_t() : obj( new NODE() ) {
@@ -524,7 +525,7 @@ namespace nodepp { class kernel_t {
524525
/*─······································································─*/
525526

526527
template< class T, class U, class... W >
527-
ptr_t<task_t> poll_add( T& inp, int flag, U cb, ulong timeout=0, const W&... args ) noexcept {
528+
ptr_t<task_t> poll_add( T& inp, int flag, U cb, ulong timeout=0, const W&... args ) const noexcept {
528529
if( cb( args... )==-1 ){ return nullptr; }
529530

530531
kevent_t kv;
@@ -558,7 +559,7 @@ namespace nodepp { class kernel_t {
558559
return task; }
559560

560561
template< class... T >
561-
ptr_t<task_t> loop_add( const T&... args ) noexcept {
562+
ptr_t<task_t> loop_add( const T&... args ) const noexcept {
562563
return obj->ev_queue.add( args... );
563564
}
564565

@@ -608,7 +609,6 @@ namespace nodepp { class kernel_t {
608609

609610
/* IO DETECTION */
610611
obj->idx=kevent( obj->pd, NULL, 0, &obj->ev, obj->ev.size(), &get_delay_tm() );
611-
if( obj->idx <= 0 ){ return 1; }
612612

613613
/* EXCECUTION */
614614
while( obj->idx > 0 ){ obj->idx--; auto x = obj->ev[ obj->idx ];
@@ -685,8 +685,7 @@ namespace nodepp { class kernel_t {
685685

686686
int get_delay_ms() const noexcept {
687687
ulong tasks= obj->ev_queue.size() + obj->probe.get();
688-
ulong TIME = get_timeout();
689-
return ( tasks==0 ) ? 100 : TIME; }
688+
return ( tasks==0 ) ? 100 : get_timeout(); }
690689

691690
protected:
692691

@@ -727,7 +726,7 @@ namespace nodepp { class kernel_t {
727726
/*─······································································─*/
728727

729728
template< class T, class U, class... W >
730-
ptr_t<task_t> poll_add ( T str, int /*unused*/, U cb, ulong timeout=0, const W&... args ) noexcept {
729+
ptr_t<task_t> poll_add ( T str, int /*unused*/, U cb, ulong timeout=0, const W&... args ) const noexcept {
731730

732731
auto time = type::bind( timeout>0 ? timeout + process::now() : timeout );
733732
auto clb = type::bind( cb );
@@ -746,7 +745,7 @@ namespace nodepp { class kernel_t {
746745
}
747746

748747
template< class T, class... V >
749-
ptr_t<task_t> loop_add ( T cb, const V&... args ) noexcept {
748+
ptr_t<task_t> loop_add ( T cb, const V&... args ) const noexcept {
750749
return obj->ev_queue.add( cb, args... );
751750
}
752751

‎include/nodepp/type.h‎

Lines changed: 12 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -198,7 +198,11 @@ namespace nodepp { namespace type {
198198

199199
/*─······································································─*/
200200

201-
template<typename T> void swap( T& a, T& b ) noexcept { T temp = a; a = b; b = temp; }
201+
template <ulong Index, typename Head, typename... Tail >
202+
struct get_by_index { using type = typename get_by_index< Index - 1 , Tail...>::type; };
203+
204+
template <typename Head, typename... Tail>
205+
struct get_by_index<0, Head, Tail...> { using type = Head; };
202206

203207
/*─······································································─*/
204208

@@ -222,6 +226,11 @@ namespace nodepp { namespace type {
222226

223227
/*─······································································─*/
224228

229+
template< typename... T > struct is_empty : false_type {};
230+
template< /*---------*/ > struct is_empty<> : true_type {};
231+
232+
/*─······································································─*/
233+
225234
template<typename T1, typename T2, typename... Ts> struct max {
226235
using larger_type = typename conditional< (sizeof(T1) > sizeof(T2)), T1, T2>::type;
227236
using type = typename max<larger_type, Ts...>::type;
@@ -321,10 +330,6 @@ namespace nodepp { namespace type {
321330
static constexpr bool value = __is_class(T);
322331
};
323332

324-
template<typename T> struct is_empty {
325-
static constexpr bool value = __is_empty(T);
326-
};
327-
328333
template<typename T> struct is_union {
329334
static constexpr bool value = __is_union(T);
330335
};
@@ -346,6 +351,8 @@ namespace nodepp { namespace type {
346351

347352
namespace nodepp { namespace type {
348353

354+
template<typename T> void swap( T& a, T& b ) noexcept { T temp = a; a = b; b = temp; }
355+
349356
template<typename T> typename remove_reference<T>::type&& move(T&& arg){
350357
return static_cast<typename remove_reference<T>::type&&>( arg );
351358
}

0 commit comments

Comments
 (0)