# La classe EvLoop

(PECL ev >= 0.2.0)

## Introduction

Représente une boucle d'événements qui est toujours distincte de la boucle par défaut. Contrairement à la boucle par défaut, elle ne peut pas gérer les watchers EvChild.

Lorsqu'on utilise les threads, nous devons créer une boucle par thread, et utiliser la boucle par défaut dans le thread parent.

La boucle d'événements par défaut est initialisée automatiquement par Ev. Elle est accessible via les méthodes de la classe Ev ou via la méthode EvLoop::defaultLoop().

## Synopsis de la classe

final class EvLoop {
/* Propriétés */
public $data;
public $backend;
public $is_default_loop;
public $iteration;
public $pending;
public $io_interval;
public $timeout_interval;
public $depth;
/* Méthodes */
public function __construct(
int `$flags` = ?,
mixed `$data` = NULL ,
float `$io_interval` = 0.0 ,
float `$timeout_interval` = 0.0
)
public function backend(): int
final public function check( string `$callback` , string `$data` = ?, string `$priority` = ?): EvCheck
final public function child(
string `$pid` ,
string `$trace` ,
string `$callback` ,
string `$data` = ?,
string `$priority` = ?
): EvChild
public static function defaultLoop(
int `$flags` = Ev::FLAG_AUTO ,
mixed `$data` = NULL ,
float `$io_interval` = 0. ,
float `$timeout_interval` = 0.
): EvLoop
final public function embed(
string `$other` ,
string `$callback` = ?,
string `$data` = ?,
string `$priority` = ?
): EvEmbed
final public function fork( callable `$callback` , mixed `$data` = `null` , int `$priority` = 0 ): EvFork
final public function idle( callable `$callback` , mixed `$data` = `null` , int `$priority` = 0 ): EvIdle
public function invokePending(): void
final public function io(
mixed `$fd` ,
int `$events` ,
callable `$callback` ,
mixed `$data` = `null` ,
int `$priority` = 0
): EvIo
public function loopFork(): void
public function now(): float
public function nowUpdate(): void
final public function periodic(
float `$offset` ,
float `$interval` ,
callable `$callback` ,
mixed `$data` = `null` ,
int `$priority` = 0
): EvPeriodic
final public function prepare( callable `$callback` , mixed `$data` = `null` , int `$priority` = 0 ): EvPrepare
public function resume(): void
public function run( int `$flags` = 0 ): void
final public function signal(
int `$signum` ,
callable `$callback` ,
mixed `$data` = `null` ,
int `$priority` = 0
): EvSignal
final public function stat(
string `$path` ,
float `$interval` ,
callable `$callback` ,
mixed `$data` = `null` ,
int `$priority` = 0
): EvStat
public function stop( int `$how` = ?): void
public function suspend(): void
final public function timer(
float `$after` ,
float `$repeat` ,
callable `$callback` ,
mixed `$data` = `null` ,
int `$priority` = 0
): EvTimer
public function verify(): void
}

## Propriétés

data
  Données personnalisées à attacher à la boucle
backend
  Lecture seule. Les drapeaux du backend indiquant le backend d'événements en cours d'utilisation.
is_default_loop
  Lecture seule. `true` si c'est la boucle d'événements par défaut.
iteration
  Le compteur d'itération courant de la boucle. Voir la méthode Ev::iteration().
pending
  Le nombre de watchers en attente. `0` indique qu'il n'y a aucun watcher en attente.
io_interval
  Une valeur haute pour io_interval permet à libev de passer plus de temps à collecter les événements EvIo, ainsi, plus d'événements peuvent être gérés par itération, mais cela va augmenter la latence. Les délais d'attente maximum (pour à la fois EvPeriodic et EvTimer) ne seront pas affectés. Le fait de définir cette option à une valeur différente de zéro va introduire un appel à `sleep()` supplémentaire dans la plupart des itérations de la boucle. Le temps de pause assure que libev ne va pas interroger EvIo plus d'une fois pendant cet intervalle, en moyenne. La plupart des programmes peuvent avoir des effets bénéfiques en définissant io_interval à une valeur proche de `0.1`, ce qui est en général suffisant pour les serveurs interactifs (et non destinés aux jeux). Il n'y a généralement aucun sens à définir cette valeur à une valeur inférieure à `0.01`, sachant que l'on s'approche de la granularité au niveau des durées de la plupart des systèmes. Voir aussi les » fonctions contrôlant les boucles d'événements.
timeout_interval
  Une valeur haute pour timeout_interval permet à libev de passer plus de temps à collecter les délais maximaux d'attente, mais a pour conséquence d'accroître la latence, le stress et l'inexactitude (la fonction de rappel du watcher sera appelée plus tard). Les watchers EvIo ne seront pas affectés. Le fait de définir cette valeur à une valeur non nulle ne va introduire aucun surcoût supplémentaire à libev. Voir aussi les » fonctions contrôlant les boucles d'événements.
depth
  La profondeur de la récursion. Voir la méthode Ev::depth().

## Sommaire

- EvLoop::backend — Retourne un entier décrivant le backend utilisé par libev
- EvLoop::check — Crée un objet EvCheck associé avec l'instance de la boucle d'événements courante
- EvLoop::child — Crée un objet EvChild associé avec la boucle d'événements courante
- EvLoop::__construct — Construit un objet de boucle d'événements
- EvLoop::defaultLoop — Retourne ou crée la boucle d'événements par défaut
- EvLoop::embed — Crée une instance de l'observateur EvEmbed associé avec l'objet de l'EvLoop courant
- EvLoop::fork — Crée un objet EvFork watcher associé avec l'instance de la boucle de l'événement courant
- EvLoop::idle — Crée un objet EvIdle watcher associé avec l'instance de la boucle de l'événement courant
- EvLoop::invokePending — Invoque tous les watchers en attente tout en réinitialisant leur état d'attente
- EvLoop::io — Crée un objet EvIo watcher associé avec l'instance de la boucle de l'événement courant
- EvLoop::loopFork — Doit être appelé après un fork
- EvLoop::now — Retourne le "event loop time" courant
- EvLoop::nowUpdate — Établit le temps courant en demandant au kernel, et met à jour le temps retourné par EvLoop::now pendant l'exécution
- EvLoop::periodic — Crée un objet EvPeriodic watcher associé avec l'instance de la boucle d'événement courant
- EvLoop::prepare — Crée un objet EvPrepare watcher associé avec l'instance de la boucle d'événement courant
- EvLoop::resume — Reprend une boucle d'événement précédemment stoppée
- EvLoop::run — Commence à vérifier les événements et à appeler les fonctions de rappel de la boucle
- EvLoop::signal — Crée un objet EvSignal watcher associé avec l'instance de la boucle d'événement courante
- EvLoop::stat — Crée un objet EvStat watcher associé avec l'instance de la boucle d'événement courant
- EvLoop::stop — Stoppe la boucle d'événement
- EvLoop::suspend — Suspend la boucle
- EvLoop::timer — Crée un objet EvTimer watcher associé avec l'instance de la boucle d'événement courant
- EvLoop::verify — Effectue des vérifications de consistance interne (pour le débogage)

`↑` and `↓` to navigate • `Enter` to select • `Esc` to close • `/` to open