07:30:46  * rendarjoined
07:56:54  * bnoordhuisjoined
08:23:51  * happy-dudequit (Ping timeout: 250 seconds)
08:27:24  * happy-dudejoined
08:37:35  <rendar>if i have 2 uv_loop_t, can i start a I/O request on the second loop, with a request from the first one? e.g. echo-server, i add read fds in the first loop, and write fds t the second loop, when a read I/O request completes from the first loop, i start a new write request in the second loop, with the same uv_req_t object.. OR, every uv_req_t object belongs to a single uv_loop_t and that can't be
08:37:35  <rendar>changed?
08:52:40  <saghul>rendar: each handle belongs to a loop
08:52:51  <saghul>so you have to read and write on that loop
09:01:10  <rendar>saghul: yeah i know that
09:01:20  <rendar>saghul: i was talking about uv_req_t not uv_handle_t
09:01:43  <rendar>saghul: i know that each fd, or handle belongs to a loop, and can't be changed, but what about the uv_req_t objects?
09:16:59  <saghul>rendar: requests are always operating on a handle
09:17:06  <saghul>so the handle rules apply
09:18:05  <rendar>saghul: yeah
09:19:17  * wuqiongquit (Remote host closed the connection)
09:19:24  <rendar>saghul: but since when an I/O operation completes, the uv_req_t doesn't belong to the handle anymore, right? because if the I/O operation is finished, i could also *delete* the uv_req_t, so, if i can delete that, i thought i could be able to pass that uv_req_t to another handle of another loop
09:19:52  * happy-dudequit (Quit: Connection closed for inactivity)
09:26:58  * PerilousApricotjoined
09:28:17  * wuqiongjoined
09:32:16  * PerilousApricotquit (Ping timeout: 264 seconds)
09:40:13  * seishunjoined
09:43:25  <saghul>rendar: only *after* the operation is finished, that is, after the callback was called
09:49:30  * Guest36547quit (Read error: Connection reset by peer)
09:49:48  * kenansulaymanjoined
09:50:11  * kenansulaymanchanged nick to Guest19777
09:51:39  * Guest19777quit (Max SendQ exceeded)
09:52:57  * kenansul-joined
09:58:54  * wuqiongquit (Remote host closed the connection)
10:00:47  * kenansul-quit (Ping timeout: 244 seconds)
10:06:33  * bnoordhuisquit (Ping timeout: 250 seconds)
10:06:39  <rendar>saghul: of course
10:07:19  <rendar>saghul: when on_read() has been called, the I/O operation is finished, so i can reuse that uv_req_t for *another* I/O request, for *another* handle, in *another* loop, right?
10:07:49  <rendar>saghul: because when a request is finished, that uv_req_t would be only a piece of memory, i can use also in another loop, am i right?
10:08:27  <rendar>OR, every uv_loop_t *must* allocate uv_req_t and use them always inside the same loop for their entire allocation?
10:10:19  * kenansul-joined
10:13:33  * kenansul|joined
10:16:48  * kenansul-quit (Ping timeout: 244 seconds)
10:22:47  <rendar>saghul: oh, you mean *after* on_read() calling? otherwise, *after* when on_read() returns?
10:29:28  * [spoiler]quit (Quit: Cheers!)
10:42:15  * [spoiler]joined
10:44:24  <saghul>rendar: you can reuse it in that case
10:45:28  <rendar>saghul: so, after on_read() returned right? e.g. on_read() { // CAN'T reuse it here } // CAN reuse it here
10:46:27  <saghul>I don't recall, but do it that way, just to be on the safe side
10:47:06  <rendar>saghul: i see, thanks
10:47:20  * fierydrakejoined
10:57:42  * Ruyiquit (Read error: Connection reset by peer)
11:00:00  * wuqiongjoined
11:06:38  * wuqiongquit (Ping timeout: 248 seconds)
11:15:12  * davijoined
11:55:07  * petka____joined
11:55:31  * daviquit (Ping timeout: 244 seconds)
12:39:16  * bnoordhuisjoined
13:39:56  * bnoordhuisquit (Ping timeout: 268 seconds)
14:46:04  * bnoordhuisjoined
14:46:37  * s3shsjoined
14:50:48  * bnoordhuisquit (Ping timeout: 250 seconds)
14:51:28  * cremesquit (Ping timeout: 268 seconds)
14:52:09  * Guest85301changed nick to indutny
15:00:40  * PerilousApricotjoined
15:05:17  * PerilousApricotquit (Ping timeout: 260 seconds)
15:10:02  * PerilousApricotjoined
15:10:11  * PerilousApricotquit (Remote host closed the connection)
15:10:21  * PerilousApricotjoined
15:19:08  * bnoordhuisjoined
15:24:57  * mmickoquit (Remote host closed the connection)
15:32:19  * alexforsterjoined
15:37:34  * bnoordhuisquit (Ping timeout: 248 seconds)
15:50:35  * cremesjoined
15:56:17  * Fishrock123joined
16:22:46  * s3shsquit (Quit: Computer has gone to sleep.)
16:44:32  * bnoordhuisjoined
16:49:40  * bnoordhuisquit (Ping timeout: 264 seconds)
17:12:02  * bnoordhuisjoined
17:16:23  * davijoined
17:16:45  * a3fjoined
17:28:32  * samrg472quit (Ping timeout: 250 seconds)
17:31:03  * s3shsjoined
17:50:09  * daviquit (Ping timeout: 246 seconds)
17:50:39  * petka____quit (Quit: Connection closed for inactivity)
17:56:38  * evanlucasquit (Ping timeout: 244 seconds)
18:02:31  * s3shsquit (Quit: Computer has gone to sleep.)
18:02:50  * s3shsjoined
18:13:34  * samrg472joined
18:15:28  * brsonjoined
18:23:44  * Perilous_joined
18:23:55  * s3shsquit (Quit: Computer has gone to sleep.)
18:27:29  * PerilousApricotquit (Ping timeout: 260 seconds)
18:34:59  * davijoined
18:37:22  <rendar>when on_read() callback returns, it means that uv_req_t contains some data that has been read from the socket. now, this data is stored inside a buffer which has been allocated when uv_req_t has been allocated, right? is this buffer a circular buffer? I mean, let's say I have a uv_req_t 'r', and 'r' just read 20 bytes, then i try write 'r' to another socket, and it writes 15 bytes, so 'r' has
18:37:22  <rendar>still 5 bytes left to "flush", can i use 'r' to read again (so it will fill the other 15 bytes) or i have to "flush" all the data read from 'r' before using it again to another read?
18:38:39  * alexforsterquit (Quit: Textual IRC Client: www.textualapp.com)
18:39:15  * alexforsterjoined
18:50:11  * a3fquit (Quit: Zzzzz..)
18:50:36  * a3fjoined
18:52:43  * a3fquit (Client Quit)
18:57:24  * a3fjoined
18:59:45  * s3shsjoined
19:01:13  * bnoordhuisquit (Ping timeout: 244 seconds)
19:04:33  * a3fquit (Quit: Zzzzz..)
19:06:01  * Damn3dquit (Ping timeout: 240 seconds)
19:11:58  * daviquit (Ping timeout: 248 seconds)
19:12:13  * Damn3djoined
19:22:46  * bnoordhuisjoined
19:23:24  * davijoined
19:28:37  * daviquit (Ping timeout: 244 seconds)
19:30:00  * dap_joined
19:33:27  * rendarquit (Ping timeout: 276 seconds)
19:38:52  * rendarjoined
21:01:54  * evanlucasjoined
21:12:00  * evanlucasquit (Max SendQ exceeded)
21:12:37  * evanlucasjoined
22:09:49  * alexforsterquit (Quit: Textual IRC Client: www.textualapp.com)
22:28:37  * Left_Turnquit (Ping timeout: 260 seconds)
22:45:21  * Fishrock123quit (Remote host closed the connection)
22:47:21  * Fishrock123joined
23:38:26  * rendarquit (Quit: std::lower_bound + std::less_equal *works* with a vector without duplicates!)
23:52:17  * seishunquit (Ping timeout: 268 seconds)
23:54:34  * bnoordhuisquit (Ping timeout: 252 seconds)
23:54:53  * Fishrock123quit (Remote host closed the connection)