File Coverage

blib/lib/Hypersonic/Event/Kqueue.pm

Criterion	Covered	Total	%
statement	12	41	29.2
branch	0	4	0.0
condition			n/a
subroutine	5	22	22.7
pod	12	18	66.6
total	29	85	34.1

package Hypersonic::Event::Kqueue;

use strict;
use warnings;
use 5.010;

use parent 'Hypersonic::Event::Role';

our $VERSION = '0.15';

sub name { 'kqueue' }

sub available {
    return $^O =~ /^(darwin|freebsd|openbsd|netbsd)$/;
}

sub includes {
    return '#include ';
}

sub defines {
    return <<'C';
#define EV_BACKEND_KQUEUE 1
#ifndef MAX_EVENTS
#define MAX_EVENTS 1024
#endif
C
}

sub event_struct { 'kevent' }

sub extra_cflags  { '' }
sub extra_ldflags { '' }

# Generate: create kqueue and add listen socket
sub gen_create {
    my ($class, $builder, $listen_fd_var) = @_;

    $builder->line('int ev_fd;')
      ->line('struct kevent ev;')
      ->blank
      ->line('ev_fd = kqueue();')
      ->if('ev_fd < 0')
        ->line('croak("kqueue() failed");')
      ->endif
      ->blank
      ->line("EV_SET(&ev, $listen_fd_var, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, NULL);")
      ->if("kevent(ev_fd, &ev, 1, NULL, 0, NULL) < 0")
        ->line('close(ev_fd);')
        ->line('croak("kevent() failed to add listen socket");')
      ->endif;
}

# Generate: add fd to kqueue
sub gen_add {
    my ($class, $builder, $loop_var, $fd_var) = @_;

    $builder->line("EV_SET(&ev, $fd_var, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, NULL);")
      ->line("kevent($loop_var, &ev, 1, NULL, 0, NULL);");
}

# Generate: remove fd from kqueue
sub gen_del {
    my ($class, $builder, $loop_var, $fd_var) = @_;

    $builder->line("EV_SET(&ev, $fd_var, EVFILT_READ, EV_DELETE, 0, 0, NULL);")
      ->line("kevent($loop_var, &ev, 1, NULL, 0, NULL);");
}

# Generate: wait for events with timeout (inside a loop - can use continue/break)
sub gen_wait {
    my ($class, $builder, $loop_var, $events_var, $count_var, $timeout_var) = @_;

    $builder->line('struct timespec ts;')
      ->line("int $count_var;")
      ->blank
      ->line("ts.tv_sec = $timeout_var / 1000;")
      ->line("ts.tv_nsec = ($timeout_var % 1000) * 1000000;")
      ->blank
      ->line("$count_var = kevent($loop_var, NULL, 0, $events_var, MAX_EVENTS, &ts);")
      ->if("$count_var < 0")
        ->if('errno == EINTR')
          ->line('continue;')
        ->endif
        ->line('perror("kevent");')
        ->line('break;')
      ->endif;
}

# Generate: wait for events - single call version (no loop control)
sub gen_wait_once {
    my ($class, $builder, $loop_var, $events_var, $count_var, $timeout_ms) = @_;

    $builder->line('struct timespec ts;')
      ->blank
      ->line("ts.tv_sec = $timeout_ms / 1000;")
      ->line("ts.tv_nsec = ($timeout_ms % 1000) * 1000000;")
      ->blank
      ->line("$count_var = kevent($loop_var, NULL, 0, $events_var, MAX_EVENTS, &ts);")
      ->line("if ($count_var < 0 && errno == EINTR) $count_var = 0;");
}

# Generate: extract fd from event
sub gen_get_fd {
    my ($class, $builder, $events_var, $index_var, $fd_var) = @_;

    $builder->line("int $fd_var;")
      ->line("$fd_var = (int)${events_var}[$index_var].ident;");
}

# ============================================================
# Async Slot Integration Methods (UA Async)
# ============================================================

# Generate: create kqueue without adding any fds
# Note: loop_var must be already declared
sub gen_create_loop {
    my ($class, $builder, $loop_var) = @_;

    $builder->line('struct kevent ev;')
      ->blank
      ->line("$loop_var = kqueue();")
      ->if("$loop_var < 0")
        ->line('croak("kqueue() failed");')
      ->endif;
}

# Generate: add fd with slot as user data
sub gen_add_with_slot {
    my ($class, $builder, $loop_var, $fd_var, $slot_var, $events) = @_;

    my $filter = $events eq 'read' ? 'EVFILT_READ'
               : $events eq 'write' ? 'EVFILT_WRITE'
               : 'EVFILT_READ';  # default to read

    $builder->line('{')
      ->line('    struct kevent _ev;')
      ->line("    EV_SET(&_ev, $fd_var, $filter, EV_ADD | EV_ENABLE | EV_ONESHOT, 0, 0, (void *)(intptr_t)$slot_var);")
      ->line("    kevent($loop_var, &_ev, 1, NULL, 0, NULL);")
      ->line('}');
}

# Generate: extract slot from event udata
sub gen_get_slot {
    my ($class, $builder, $events_var, $index_var, $slot_var) = @_;

    $builder->line("int $slot_var;")
      ->line("$slot_var = (int)(intptr_t)${events_var}[$index_var].udata;");
}

# ============================================================
# Future/Pool Integration Methods
# ============================================================

# Future/Pool integration - add pool notify fd to kqueue
sub gen_add_pool_notify {
    my ($class, $builder, $loop_var, $notify_fd_var) = @_;

    $builder->line("/* Add pool notify fd to kqueue */")
            ->line("EV_SET(&ev, $notify_fd_var, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, NULL);")
            ->line("kevent($loop_var, &ev, 1, NULL, 0, NULL);");
}

# Multi-pool integration - add all pool notify fds to kqueue
sub gen_add_multi_pool_notify {
    my ($class, $builder, $loop_var, $pool_slots_var, $pool_count_var) = @_;

    $builder->line("/* Add all pool notify fds to kqueue */")
            ->line("{ int _pi; int _pool_notify_fd;")
            ->line("for (_pi = 0; _pi < $pool_count_var; _pi++) {")
            ->line("    _pool_notify_fd = pool_get_notify_fd_slot($pool_slots_var\[_pi]);")
            ->line("    if (_pool_notify_fd >= 0) {")
            ->line("        EV_SET(&ev, _pool_notify_fd, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, NULL);")
            ->line("        kevent($loop_var, &ev, 1, NULL, 0, NULL);")
            ->line("    }")
            ->line("} }");
}

1;

__END__