diff --git a/reference/ev/book.xml b/reference/ev/book.xml index fb6ca126a..4082de8e6 100644 --- a/reference/ev/book.xml +++ b/reference/ev/book.xml @@ -1,7 +1,8 @@ - + + Ev @@ -10,30 +11,32 @@ &reftitle.intro; Esta extensión proporciona una interfaz a la biblioteca - libev - ; un bucle de eventos completísimo de alto rendimiento escrito en C. + libev, un bucle de eventos + de alto rendimiento, escrito en C. ¬e.no-windows.extension; - Libev - es un bucle de eventos: se toma interés en ciertos eventos (como que un descriptor - de fichero sea legible o que expire un tiempo de espera), y se administrarán estas - fuentes de eventos y se proveerá al programa con eventos. + Libev es un bucle de eventos: registra + un interés por ciertos eventos (como un descriptor de fichero + que se vuelve legible, o un tiempo de espera máximo que ocurre), + gestiona las fuentes de estos eventos y proporciona al programa + dichos eventos. - Para hacer esto, se debe tomar más o menos control completo sobre el proceso (o - hilo) ejecutando el gestor de bucles de evetos, y luego comunicar - los eventos mediante un mecanismo de llamada de retorno. + Para lograr esto, toma un control más o menos total + del proceso (o hilo) ejecutando un gestor de bucle + de eventos, luego los comunica mediante un mecanismo de función + de retrollamada. - Se toma interés en ciertos eventos registrando los así llamados testigos de - eventos, y luego entergarlos a libev iniciando el testigo. + El registro de intereses por ciertos eventos se realiza mediante + observadores, luego, devuelve el control a libev iniciando estos + observadores. - Para más detalles consulte la + Para más detalles, consulte la documentación de libev. diff --git a/reference/ev/configure.xml b/reference/ev/configure.xml index 52f1f18d3..ac3e61624 100644 --- a/reference/ev/configure.xml +++ b/reference/ev/configure.xml @@ -1,7 +1,8 @@ - - + + +
&reftitle.install; @@ -10,11 +11,12 @@ &url.pecl.package;ev - Para información sobre la instalación manual, lea el fichero - INSTALL.md - incluido en el paquete fuente. + Para obtener más información sobre la instalación manual, + se recomienda leer el fichero INSTALL.md incluido + en los fuentes del paquete.
+ - - + + La clase Ev @@ -11,8 +10,8 @@
&reftitle.intro; - Ev es una clase estática que proporciona acceso al bucle por omsión y a algunas - operaciones comunes. + La clase Ev es una clase estática que proporciona acceso al bucle por defecto + así como a algunas operaciones comunes.
@@ -249,7 +248,7 @@ &reftitle.constants; - Flags disponibles para crear un bucle: + Flags pasados para crear un bucle: @@ -258,7 +257,7 @@ - El valor del flag por defecto + El valor por defecto de los flags. @@ -268,14 +267,13 @@ - Si este flag es utilizado (o el programa corre setuid o setgid), - libev - no tendrá en cuenta la variable de entorno - LIBEV_FLAGS - . De otro modo (por defecto), - LIBEV_FLAGS - reemplazará los flags completamente si es definido. Útil para evaluación - de performance y para encontrar errores. + Si este flag se utiliza (o si el programa ejecuta + setuid o setgid), libev + no va a mirar la variable de entorno + LIBEV_FLAGS. De lo contrario (comportamiento por defecto), + LIBEV_FLAGS va a sobrescribir completamente el + flag si se encuentra. Útil para pruebas de rendimiento + y para la búsqueda de bugs. @@ -285,14 +283,15 @@ - Permite que libev verifique un fork en cada iteración, en lugar de llamar a - EvLoop::fork - manualmente. Esto funciona al llamar a - getpid() - en cada iteración del bucle, y como tal podrá alentizar el bucle de eventos con - numerosas iteraciones, aunque esto no es usualmente notorio. Este flag no puede - ser reemplazado o especificado mediante la variable de entorno - LIBEV_FLAGS. + Hace que libev verifique si existe un fork en cada iteración, + en lugar de llamar manualmente al método + EvLoop::fork. Este mecanismo funciona + llamando a getpid() en cada iteración de + la bucle, y así, va a ralentizar el bucle de eventos que + poseen muchas iteraciones, pero habitualmente, + este ralentizamiento no es notable. La configuración de este flag + no puede ser sobrescrita o especificada en la variable + de entorno LIBEV_FLAGS. @@ -302,17 +301,14 @@ - Cuando este flag es especificado, - libev - no intentará utilizar la API - inotify - para sus watchers + Cuando este flag está especificado, libev + no va a intentar utilizar la API inotify + para estos watchers ev_stat. - El flag puede ser útil para conservar los descriptores de archivo inotify, - ya que de otro modo cada bucle que utilice watchers - ev_stat - consumen un handle + xlink:href="&url.ev.stat;">ev_stat. + Este flag puede ser útil para conservar los descriptores de + ficheros inotify, sabiendo que de lo contrario, cada bucle utilizando los + watchers ev_stat va a consumir un manejador inotify. @@ -323,21 +319,18 @@ - Cuando este flag es especificado, - libev - intentará utilizar la API - signalfd - para sus watchers + Cuando este flag está especificado, libev + va a intentar utilizar la API signalfd + para estos watchers ev_signal + xlink:href="&url.ev.signal;">ev_signal (y - ev_child - ). Esta API entrega las señales sincrónicamente, lo que la hace más rápida - y puede permitir obtener los datos de señal encolados. - También puede simplificar el manejo de señales mediante hilos, siempre y cuando - las señales sean bloqueadas apropiadamente en los hilos. - Signalfd + ev_child). + Esta API entrega las señales de forma asíncrona, lo que + la hace más rápida, y puede permitir la recuperación de datos + de señales en espera. También puede simplificar la gestión + de señales con hilos, sabiendo que las señales son propiedades bloqueadas + en los hilos. Signalfd no será utilizado por defecto. @@ -348,15 +341,14 @@ - Cuando este flag es especificado, - libev - hará imposible la modificación de la máscara de señal. Esto significa - que será necesario asegurarse que las señales están desbloqueadas antes - de recibirlas. + Cuando este flag está especificado, libev + no va a modificar la máscara de señal. Esto significa + que se debe asegurar que las señales están desbloqueadas + antes de recibirlas. - Este comportamiento es útil para el manejo de señales personalizado, o para - manipular señales solamente en hilos específicos. + Este comportamiento es útil para la gestión personalizada de señales, + o la gestión de señales únicamente en hilos específicos. @@ -364,10 +356,9 @@ - Flags disponibles para - Ev::run - , o - EvLoop::run + Flags a pasar a + Ev::run, + o a EvLoop::run @@ -376,12 +367,13 @@ - Significa que el bucle de eventos buscará nuevos eventos, y manejará - aquellos eventos y cualquier otro evento pendiente, pero no esperará - ni bloqueará el proceso en caso de que no haya eventos, retornando - luego de una iteración del bucle. Esto es útil para obtener nuevos - eventos mientras se realizan cálculos costosos, manteniendo el - programa funcionando. + Significa que el bucle de eventos va a mirar si hay nuevos + eventos presentes, va a gestionar estos nuevos eventos, + y todos los eventos especiales, pero no va a esperar y + bloquear el proceso en el caso de que no haya eventos, + y va a retornar después de una iteración del bucle. A veces + es útil poner en cola y gestionar los nuevos eventos + durante cálculos largos, y esto, para mantener el programa activo. @@ -391,12 +383,13 @@ - Significa que el bucle de eventos buscará nuevos eventos (esperando - si es necesario) y manejará aquellos eventos, y cualquier otro evento - pendiente. Bloqueará el proceso hasta que al menos un evento esté - disponible (que podría ser un evento interno a libev, - por lo que no hay garantía de que un callback registrado por el usuario - sea llamado), y retornará luego de una iteración del bucle. + Significa que el bucle de eventos va a mirar si hay nuevos + eventos presentes (y esperar, si es necesario), y va a gestionarlos, + ellos y los especiales. Va a bloquear el proceso hasta que al + menos un evento llegue (que puede ser un evento interno de libev, + también, no está garantizado que una función de callback registrada por + el usuario sea llamada), y va a retornar después de una iteración + del bucle. @@ -404,9 +397,9 @@ - Flags disponibles para - Ev::stop - , o + Flags pasados a + Ev::stop, + o a EvLoop::stop @@ -416,7 +409,7 @@ - Cancelar la operación break. + Cancela la operación de cancelación. @@ -426,11 +419,9 @@ - Hace que la llamada interior + Retorna la llamada más profunda a Ev::run - (o - EvLoop::run - ) retorne. + (o EvLoop::run). @@ -440,11 +431,9 @@ - Hace que todas las llamadas + Retorna la llamada más cercana a Ev::run - (o - EvLoop::run - ) retornen. + (o EvLoop::run). @@ -452,7 +441,7 @@ - Prioridades Watcher: + Prioridades de Watcher: @@ -461,7 +450,7 @@ - Prioridad mínima disponible. + Prioridad mínima permitida para un watcher. @@ -471,7 +460,7 @@ - Prioridad máxima disponible. + Prioridad máxima permitida para un watcher. @@ -479,7 +468,7 @@ - Máscaras de Bit de los eventos (recibidos): + Máscaras de bytes de eventos (recibidos): @@ -488,9 +477,9 @@ - El descriptor de archivo en el watcher - EvIo - se ha vuelto disponible. + El descriptor de fichero en el watcher + EvIo se ha vuelto accesible + en lectura. @@ -500,9 +489,9 @@ - El descriptor de archivo en el watcher - EvIo - se ha vuelto modificable. + El descriptor de fichero en el watcher + EvIo se ha vuelto accesible + en escritura. @@ -513,7 +502,7 @@ El watcher EvTimer - ha agotado su tiempo. + ha alcanzado su tiempo máximo de espera. @@ -524,7 +513,7 @@ El watcher EvPeriodic - ha agotado su tiempo. + ha alcanzado su tiempo máximo de espera. @@ -546,11 +535,9 @@ - El - pid - especificado en + El pid especificado en EvChild::__construct - ha recibido una alteración de estado. + ha recibido una modificación de estado. @@ -560,9 +547,9 @@ - El path especificado en el watcher - EvStat - ha modificado sus atributos. + La ruta especificada en el watcher + EvStat ha modificado sus + atributos. @@ -572,8 +559,8 @@ - El watcher EvIdle - trabaja cuando no hay nada que hacer con otros watchers. + El watcher EvIdle funciona cuando + no tiene ninguna otra tarea que hacer con los otros watchers. @@ -583,14 +570,12 @@ - Todos los watchers - EvPrepare - son invocados justo antes de que - Ev::run - comience. Así, los watchers - EvPrepare - son los últimos en ser invocados antes de que el bucle de - eventos duerma, o busque nuevos eventos. + Todos los watchers EvPrepare + son llamados justo antes del inicio de + Ev::run. Así, los watchers + EvPrepare son los últimos watchers + en ser llamados antes del reposo del bucle de eventos, + o la puesta en cola de los nuevos eventos. @@ -600,18 +585,15 @@ - Todos los watchers - EvCheck - son encolados justo luego de que - Ev::run - haya obtenido los nuevos eventos, - pero antes de que encole cualquier - callback para los eventos recibidos. - Así, los watchers - EvCheck - serán invocados antes que cualquier otro watcher - de la misma o menor prioridad dentro de la iteración - del bucle de eventos. + Todos los watchers EvCheck + son puestos en cola justo después de que + Ev::run haya recuperado + los nuevos eventos, pero antes, todas las + funciones de callback de todos los eventos recibidos + son puestas en cola. Así, los watchers + EvCheck serán llamados antes que cualquier + otro watcher de misma prioridad o de prioridad más baja + en una iteración del bucle de eventos. @@ -621,9 +603,9 @@ - El bucle embebido especificado en el watcher - EvEmbed - necesita atención. + El bucle de eventos embebido especificado en el + watcher EvEmbed necesita + toda la atención. @@ -633,14 +615,11 @@ - Nunca enviado (o utilizado) por - libev, pero puede - ser libremente utilizado por los usuarios de - libev - para enviar señales a watchers (por ejemplo - a través de - EvWatcher::feed - ). + Aún no enviado (o utilizado) por + libev, pero puede ser + libremente utilizado por los usuarios + libev para señalar los watchers + (i.e. vía el método EvWatcher::feed). @@ -650,17 +629,15 @@ - Un error no especificado ha ocurrido, y el watcher se ha detenido. Esto - puede ocurrir ya sea porque el watcher no haya sido inicializado apropiadamente - debido a que - libev - ha agotado la memoria disponible, porque un descriptor de archivo se encontraba ya cerrado, - o por cualquier otro problema. - Libev - considera estos errores como errores de aplicación. Véase también + Ha ocurrido un error desconocido, el watcher se ha detenido. Esto puede + ocurrir porque el watcher no ha podido ser iniciado correctamente + porque libev ha excedido la memoria asignada, un + descriptor de fichero ha sido cerrado, u otro problema. + Libev considera esto como bugs + de la aplicación. Ver también ANATOMY - OF A WATCHER + xlink:href="http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#ANATOMY_OF_A_WATCHER_CONTENT">la anatomía + de un watcher @@ -677,7 +654,7 @@ - Backend select(2) + select(2) backend @@ -687,7 +664,7 @@ - Backend poll(2) + poll(2) backend @@ -697,10 +674,8 @@ - Backend específico a Linux - epoll(7) - tanto para kernels anteriores o posteriores a la - versión 2.6.9 + Backend epoll(7) específico de Linux + para, a la vez, los kernels antes y después de 2.6.9. @@ -710,16 +685,13 @@ - Backend kqueue - utilizado en la mayoría de los sistemas BSD. - El watcher EvEmbed - puede ser utilizado para embeber un bucle (con e backend - kqueue - ) - dentro de otro. Por ejemplo, uno puede intentar crear un bucle de - eventos con el backend - kqueue - y utilizarlo solamente por sus sockets. + Backend kqueue utilizado en la + mayoría de los sistemas BSD. El watcher EvEmbed + puede ser utilizado para embeber un bucle (con el + backend kqueue) en otro. Actualmente, un bucle puede + intentar crear un bucle de eventos con el backend + kqueue y utilizarlo únicamente para los + sockets. @@ -729,7 +701,7 @@ - Backend Solaris 8. Aún no implementado. + Backend Solaris 8. Actualmente no implementado. @@ -739,7 +711,7 @@ - Mecanismo de puerto Solaris 10 con buena escalabilidad. + Mecanismo de puerto de eventos Solaris con buen rendimiento. @@ -749,15 +721,14 @@ - Intentar todos los backends (incluso los corrompidos). No es - recomendado utilizar este flag explícitamente. En su lugar deberían - utilizarse operaciones Bitwise (por ejemplo - Ev::BACKEND_ALL - & ~ - Ev::BACKEND_KQUEUE - ). Utiliza - Ev::recommendedBackends - , o no especifiques ningún backend en especial. + Prueba todos los backends (incluyendo los corruptos). + No se recomienda utilizarlo explícitamente. + Los operadores de bits deberían ser aplicados aquí + (i.e. Ev::BACKEND_ALL & ~ + Ev::BACKEND_KQUEUE). + Utilice el método + Ev::recommendedBackends o no + especifique ningún backend. @@ -767,13 +738,11 @@ - No es un backend, sino una máscara que permite seleccionar todos - los bits de backends desde el valor - flags - para sacar de la máscara cualquier backend (por ejemplo cuando se modifica - la variable de entorno - LIBEV_FLAGS - ). + No es un backend, sino una máscara para seleccionar todos + los bits de un backend desde el valor de + flags para representar en una + máscara cualquier backend (i.e. al modificar + la variable de entorno LIBEV_FLAGS). @@ -782,39 +751,29 @@ - Durante la fase de inicialización del módulo, - Ev - registtra para el bucle por defecto una llamada a + Para el bucle por defecto, durante la fase de inicialización + del módulo, Ev registra llamadas a ev_loop_fork - a través de - pthread_atfork - (si se encuentra disponible). + xlink:href="&url.ev.loop;">ev_loop_fork + vía pthread_atfork (si está disponible). - Existen métodos que ofrecen acceso al + Hay métodos que proporcionan acceso a la bucle de eventos por defecto - en la clase - Ev - (por ejemplo - Ev::iteration - , - Ev::depth - etc.) Para - bucles personalizados - (creados con - EvLoop::__construct - ) estos valores pueden ser accedidos a través de propiedades y métodos correspondientes - de la clase - EvLoop - . + en la clase Ev + (i.e. Ev::iteration, + Ev::depth, etc.) Para los + bucles personalizados (creados con + EvLoop::__construct), estos + valores pueden ser accesibles vía las propiedades y los + métodos correspondientes de la clase + EvLoop. - La instancia del bucle de eventos por defecto puede ser obtenida a través del método - EvLoop::defaultLoop - . + La instancia del bucle de eventos por defecto puede ser recuperada + vía el método EvLoop::defaultLoop. @@ -824,6 +783,7 @@ &reference.ev.entities.ev; + - - + + Ev::backend - Devuelve un entero que describe el back-end utilizado por libev + Devuelve un integer que describe el backend utilizado por libev &reftitle.description; @@ -19,10 +18,9 @@ - Devuelve un entero que describe el back-end utilizado por - libev - . Véase - Backend flags + Devuelve un integer que describe el backend utilizado por libev. + Ver los + flags de Backend. @@ -32,9 +30,8 @@ &reftitle.returnvalues; - Devuelve un entero (máscara de bits) que describe el back-end utilizado por - libev - . + Devuelve un integer (máscara de bytes) que describe el backend utilizado por + libev. @@ -53,7 +50,7 @@ Ev::supportedBackends - Backend flags + Los flags de Backend diff --git a/reference/ev/ev/depth.xml b/reference/ev/ev/depth.xml index d7abb50ed..90cc7faf2 100644 --- a/reference/ev/ev/depth.xml +++ b/reference/ev/ev/depth.xml @@ -1,11 +1,11 @@ - - + + Ev::depth - Devuelve la profundidad de la recursividad + Retorna la profundidad de recursión &reftitle.description; @@ -18,31 +18,27 @@ - El número de veces - Ev::run - se ha introducido menos el número de veces - Ev::run - fue terminada normalmente, en otras palabras, el nivel de recursividad. fuera de - Ev::run - , este número es - 0 - . En una llamada de retorno, este número es - 1 - , a menos que - Ev::run - fue invocado recursivamente (o desde otro subproceso), en cuyo caso es - mayor. + El número de veces que el método Ev::run + ha sido invocado, menos el número de veces que el método + Ev::run ha finalizado normalmente, en otras + palabras, la profundidad de recursión. Fuera de + Ev::run, este número vale 0. + En una función de retrollamada, este número vale 1, + mientras que el método Ev::run sea invocado + recursivamente (o desde otro hilo), en cuyo caso, será superior. + &reftitle.parameters; &no.function.parameters; + &reftitle.returnvalues; - ev_depth - Devuelve la profundidad de la recursividad del bucle por defecto. + ev_depth retorna la profundidad de recursión + del bucle por omisión. diff --git a/reference/ev/ev/embeddablebackends.xml b/reference/ev/ev/embeddablebackends.xml new file mode 100644 index 000000000..96e462dda --- /dev/null +++ b/reference/ev/ev/embeddablebackends.xml @@ -0,0 +1,115 @@ + + + + + + + + Ev::embeddableBackends + Devuelve el conjunto de backends que pueden ser encapsulados en otros bucles de eventos + + + &reftitle.description; + + final + public + static + int + Ev::embeddableBackends + + + + Devuelve el conjunto de backends que pueden ser encapsulados en otros bucles de eventos. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Devuelve una máscara de octetos que puede contener los + flags de backend + combinados con el operador OR. + + + + &reftitle.examples; + + Encapsula un bucle creado con el backend kqueue en el bucle por defecto + + +]]> + + + + + &reftitle.seealso; + + + EvEmbed + + + Ev::recommendedBackends + + + Ev::supportedBackends + + + Los flags de Backend + + + Los ejemplos + + + + + diff --git a/reference/ev/ev/feedsignal.xml b/reference/ev/ev/feedsignal.xml new file mode 100644 index 000000000..00f7e66c7 --- /dev/null +++ b/reference/ev/ev/feedsignal.xml @@ -0,0 +1,85 @@ + + + + + + + Ev::feedSignal + Simula la recepción de una señal + + + &reftitle.description; + + final + public + static + void + Ev::feedSignal + + int + signum + + + + Simula la recepción de una señal. Es seguro llamar a esta función + en cualquier momento, desde cualquier contexto, incluyendo desde + un gestor de señales, o desde un hilo aleatorio. Su principal + utilización es personalizar el gestor de señales en el proceso. + + + A diferencia del método Ev::feedSignalEvent, + este método funciona según la loop que ha registrado la señal. + + + + &reftitle.parameters; + + + + signum + + + + Número de la señal. Ver la página man de signal(7) + para más detalles. Se pueden utilizar las constantes exportadas + por la extensión pcntl. + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + Ev::feedSignalEvent + + + + + diff --git a/reference/ev/ev/feedsignalevent.xml b/reference/ev/ev/feedsignalevent.xml new file mode 100644 index 000000000..496acf531 --- /dev/null +++ b/reference/ev/ev/feedsignalevent.xml @@ -0,0 +1,81 @@ + + + + + + + + Ev::feedSignalEvent + Simula un evento de señal en el bucle por omisión + + + &reftitle.description; + + final + public + static + void + Ev::feedSignalEvent + + int + signum + + + + Simula un evento de señal en el bucle por omisión. + Ev reaccionará a esta llamada como si la señal especificada por + el argumento signal hubiera ocurrido. + + + + &reftitle.parameters; + + + + signum + + + + Número de la señal. Ver la página man de signal(7) + para más detalles. Ver también las constantes exportadas por + la extensión pcntl. + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + Ev::feedSignal + + + + + diff --git a/reference/ev/ev/iteration.xml b/reference/ev/ev/iteration.xml new file mode 100644 index 000000000..ee9fb3902 --- /dev/null +++ b/reference/ev/ev/iteration.xml @@ -0,0 +1,67 @@ + + + + + + + + Ev::iteration + Devuelve el número de veces que el bucle de eventos por omisión + ha sido solicitado para un nuevo evento + + + &reftitle.description; + + final + public + static + int + Ev::iteration + + + + Devuelve el número de veces que el bucle de eventos por omisión + ha sido solicitado para un nuevo evento. Puede ser útil como + contador de generación. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Devuelve el número de solicitudes del bucle de eventos + por omisión. + + + + &reftitle.seealso; + + + Ev::depth + + + + + diff --git a/reference/ev/ev/now.xml b/reference/ev/ev/now.xml new file mode 100644 index 000000000..48b2fffc9 --- /dev/null +++ b/reference/ev/ev/now.xml @@ -0,0 +1,66 @@ + + + + + + + Ev::now + Devuelve el tiempo de inicio de la última iteración del bucle de eventos por omisión + + + &reftitle.description; + + final + public + static + float + Ev::now + + + + Devuelve el tiempo de inicio de la última iteración del bucle de eventos por omisión. + Es el tiempo en el que se basan los temporizadores (EvTimer y + EvPeriodic), y referirse a este es a menudo más rápido que + llamar al método Ev::time. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Devuelve el número de segundos que representan el tiempo de inicio de la última iteración + del bucle de eventos por omisión. + + + + &reftitle.seealso; + + + Ev::nowUpdate + + + + + diff --git a/reference/ev/ev/nowupdate.xml b/reference/ev/ev/nowupdate.xml new file mode 100644 index 000000000..f367c4d34 --- /dev/null +++ b/reference/ev/ev/nowupdate.xml @@ -0,0 +1,71 @@ + + + + + + + Ev::nowUpdate + Establece el tiempo actual solicitándolo al kernel; actualiza el + tiempo devuelto por Ev::now durante la ejecución + + + &reftitle.description; + + final + public + static + void + Ev::nowUpdate + + + + Establece el tiempo actual solicitándolo al kernel; actualiza el tiempo + devuelto por el método Ev::now durante + la ejecución. Esta es una operación costosa, y se realiza habitualmente + automáticamente en el método Ev::run. + + + Este método es raramente útil, pero cuando las funciones de retrollamada + de evento se ejecutan durante mucho tiempo sin entrar en un bucle de evento, + actualizar libev con el tiempo actual es una buena idea. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + Ev::now + + + + + diff --git a/reference/ev/ev/recommendedbackends.xml b/reference/ev/ev/recommendedbackends.xml new file mode 100644 index 000000000..ea4749993 --- /dev/null +++ b/reference/ev/ev/recommendedbackends.xml @@ -0,0 +1,127 @@ + + + + + + + Ev::recommendedBackends + Devuelve una máscara de octetos de backends recomendados + para la plataforma actual + + + &reftitle.description; + + final + public + static + int + Ev::recommendedBackends + + + + Devuelve un conjunto de todos los backends compilados en este binario de + libev, y también recomendados para esta + plataforma, lo que significa que deberían funcionar para la + mayoría de los tipos de descriptor de ficheros. Este conjunto es generalmente + más pequeño que el devuelto por la función + ev_supported_backends, sabiendo que, por ejemplo, + kqueue está roto en los sistemas BSD + y no será auto-detectado hasta que no sea requerido explícitamente. + Es el conjunto de backends que libev utilizará + cuando ninguno sea solicitado explícitamente. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Devuelve una máscara de octetos que contiene los + flags de backends + combinados utilizando el operador OR. + + + + &reftitle.examples; + + Encapsula un bucle en otro + + +]]> + + + + + &reftitle.seealso; + + + EvEmbed + + + Ev::embeddableBackends + + + Ev::supportedBackends + + + Los flags de Backend + + + Los ejemplos + + + + + diff --git a/reference/ev/ev/resume.xml b/reference/ev/ev/resume.xml new file mode 100644 index 000000000..8c30739a7 --- /dev/null +++ b/reference/ev/ev/resume.xml @@ -0,0 +1,84 @@ + + + + + + + Ev::resume + Reanuda el bucle de eventos por defecto previamente detenido + + + &reftitle.description; + + final + public + static + void + Ev::resume + + + + Los métodos Ev::suspend y + Ev::resume suspenden y reanudan + un bucle. + + + Todos los watchers timer serán suspendidos durante el tiempo entre + la suspensión y la reanudación + y todos los watchers periodic serán + reprogramados (y perderán todos los eventos que hayan ocurrido + durante el tiempo de esta suspensión). + + + Tras la llamada al método Ev::suspend, + no está permitido llamar a una función en el bucle proporcionado + distinto del método Ev::resume. + Además, no está permitido llamar al método + Ev::resume sin una llamada previa al + método Ev::suspend. + + + La llamada a una suspensión/reanudación + tiene como efecto secundario la actualización del tiempo del bucle de eventos + (ver el método Ev::nowUpdate). + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + Ev::suspend + + + + + diff --git a/reference/ev/ev/run.xml b/reference/ev/ev/run.xml new file mode 100644 index 000000000..16b983f64 --- /dev/null +++ b/reference/ev/ev/run.xml @@ -0,0 +1,127 @@ + + + + + + + Ev::run + Inicia la verificación de eventos y llama a las funciones de retrollamada para el bucle por defecto + + + &reftitle.description; + + final + public + static + void + Ev::run + + int + flags + + + + Inicia la verificación de eventos y llama a las funciones de retrollamada + para el bucle por defecto. Retorna cuando una función + de retrollamada llama al método Ev::stop, o cuando + los flags son diferentes de cero (en cuyo caso, el valor retornado + será &true;), o bien cuando no hay más observadores activos que + referencian el bucle (EvWatcher::keepalive vale + &true;), en cuyo caso, el valor retornado será &false;. El valor retornado + puede generalmente ser interpretado como: si &true;, aún hay trabajo por hacer. + + + + &reftitle.parameters; + + + + flags + + + + El parámetro opcional flags + puede ser uno de los siguientes valores: + + + Lista de valores posibles de <parameter>flags</parameter> + + + + + + flags + + Descripción + + + + + + 0 + + El comportamiento por omisión, descrito arriba + + + + Ev::RUN_ONCE + + Bloquea al menos un (pone en espera, pero no bucla más) + + + + Ev::RUN_NOWAIT + + No bloquea en absoluto (recupera/gestiona los eventos + pero no espera) + + + +
+ + + Ver las + constantes de flags de ejecución. + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + Ev::stop + + + EvLoop::run + + + + + diff --git a/reference/ev/ev/sleep.xml b/reference/ev/ev/sleep.xml new file mode 100644 index 000000000..d9e26d43d --- /dev/null +++ b/reference/ev/ev/sleep.xml @@ -0,0 +1,69 @@ + + + + + + + + Ev::sleep + Bloquea el proceso durante un número de segundos proporcionado + + + &reftitle.description; + + final + public + static + void + Ev::sleep + + float + seconds + + + + Bloquea el proceso durante un número de segundos proporcionado. + + + + &reftitle.parameters; + + + + seconds + + + + Número de segundos + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + diff --git a/reference/ev/ev/stop.xml b/reference/ev/ev/stop.xml new file mode 100644 index 000000000..389b899ee --- /dev/null +++ b/reference/ev/ev/stop.xml @@ -0,0 +1,77 @@ + + + + + + + Ev::stop + Detiene el bucle de eventos predeterminado + + + &reftitle.description; + + final + public + static + void + Ev::stop + + int + how + + + + Detiene el bucle de eventos predeterminado. + + + + &reftitle.parameters; + + + + how + + + + Una constante + entre las constantes Ev::BREAK_*. + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + Ev::run + + + + + diff --git a/reference/ev/ev/supportedbackends.xml b/reference/ev/ev/supportedbackends.xml new file mode 100644 index 000000000..41c3cdb5a --- /dev/null +++ b/reference/ev/ev/supportedbackends.xml @@ -0,0 +1,115 @@ + + + + + + + + Ev::supportedBackends + Devuelve el conjunto de backends soportados por la configuración actual de libev + + + &reftitle.description; + + final + public + static + int + Ev::supportedBackends + + + + Devuelve el conjunto de backends soportados por la configuración actual de libev. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Devuelve una máscara de bits que puede contener los + flags de backend + combinados utilizando el operador OR. + + + + &reftitle.examples; + + Bucle integrado creado con el backend kqueue en el bucle por defecto + + +]]> + + + + + &reftitle.seealso; + + + EvEmbed + + + Ev::recommendedBackends + + + Ev::embeddableBackends + + + Los flags de backend + + + Los ejemplos + + + + + diff --git a/reference/ev/ev/suspend.xml b/reference/ev/ev/suspend.xml new file mode 100644 index 000000000..1a32f8e46 --- /dev/null +++ b/reference/ev/ev/suspend.xml @@ -0,0 +1,78 @@ + + + + + + + Ev::suspend + Suspende el bucle de eventos predeterminado + + + &reftitle.description; + + final + public + static + void + Ev::suspend + + + + Los métodos Ev::suspend y + Ev::resume suspenden y reanudan + el bucle predeterminado. + + + Todos los temporizadores de los observadores serán suspendidos entre una + suspensión y una reanudación, + y todos los observadores periódicos + serán actualizados (asimismo, todos los eventos ocurridos durante + esta suspensión se perderán). + + + Tras una llamada al método Ev::suspend, + no está permitido llamar a una función en el bucle proporcionado + distinta del método Ev::resume. Asimismo, + no está permitido llamar al método Ev::resume + sin una llamada previa al método Ev::suspend. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + Ev::resume + + + + + diff --git a/reference/ev/ev/time.xml b/reference/ev/ev/time.xml new file mode 100644 index 000000000..364e3b1c0 --- /dev/null +++ b/reference/ev/ev/time.xml @@ -0,0 +1,64 @@ + + + + + + + + Ev::time + Devuelve el tiempo actual desde la época Unix + + + &reftitle.description; + + final + public + static + float + Ev::time + + + + Devuelve el tiempo actual desde la época Unix. + Se recomienda utilizar el método Ev::now. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Devuelve el tiempo actual, en número de segundos, desde la época Unix. + + + + &reftitle.seealso; + + + Ev::now + + + + + diff --git a/reference/ev/ev/verify.xml b/reference/ev/ev/verify.xml new file mode 100644 index 000000000..940caf488 --- /dev/null +++ b/reference/ev/ev/verify.xml @@ -0,0 +1,56 @@ + + + + + + + Ev::verify + Efectúa verificaciones internas de consistencia (para la depuración) + + + &reftitle.description; + + final + public + static + void + Ev::verify + + + + Efectúa verificaciones internas de consistencia (para la depuración de + libev) y finaliza el programa si se encuentra una estructura + de datos corrompida. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + diff --git a/reference/ev/evcheck.xml b/reference/ev/evcheck.xml new file mode 100644 index 000000000..52bdde32e --- /dev/null +++ b/reference/ev/evcheck.xml @@ -0,0 +1,106 @@ + + + + + La clase EvCheck + EvCheck + + +
+ &reftitle.intro; + + Los observadores EvPrepare y + EvCheck se utilizan habitualmente juntos. + El observador EvPrepare será llamado antes de + los bloques del proceso, mientras que el observador EvCheck + será llamado después. + + + No está permitido llamar al método EvLoop::run + o a un método/función similar que entre en el bucle del evento + actual desde el observador EvPrepare, + o desde el observador EvCheck. Sin embargo, + esto es posible para todos los demás bucles que no sean el actual. + La razón es que no es necesario verificar la recursión + en estos observadores, es decir, la secuencia siguiente será siempre: + EvPrepare -> bloqueo -> EvCheck, + por lo tanto, tener un observador para cada uno no es útil, sabiendo que siempre serán llamados + juntos al llamar al bloqueo. + + + El propósito principal es integrar otros mecanismos de eventos en + la biblioteca libev, con un uso avanzado. + Pueden ser utilizados, por ejemplo, para monitorear los cambios + de variables, implementar observadores personalizados, integrar net-snmp + o una biblioteca adicional, y mucho más. También pueden ser útiles para almacenar en caché datos, y querer mostrarlos después + del bloqueo. + + + Se recomienda proporcionar una prioridad alta a EvCheck + (Ev::MAXPRI) para asegurarse de que se ejecutará + antes que cualquier otro observador en la cola (a diferencia de lo que ocurre con + el observador EvPrepare). + + + Además, los observadores EvCheck no deben + activar/alimentar eventos. Aunque libev + admite esto, pueden ser ejecutados antes de que los otros observadores + EvCheck terminen sus trabajos. + +
+ +
+ &reftitle.classsynopsis; + + + + + EvCheck + + + + + EvCheck + + + extends + EvWatcher + + + + + &InheritedProperties; + + &Methods; + + + &InheritedMethods; + + + +
+ + + &reference.ev.entities.evcheck; + + + diff --git a/reference/ev/evcheck/construct.xml b/reference/ev/evcheck/construct.xml new file mode 100644 index 000000000..a970e4df7 --- /dev/null +++ b/reference/ev/evcheck/construct.xml @@ -0,0 +1,99 @@ + + + + + + EvCheck::__construct + Construye el objeto de observación EvCheck + + + &reftitle.description; + + public + EvCheck::__construct + + callable + callback + + + mixed + data + + + int + priority + + + + Construye el objeto de observación EvCheck. + + + + &reftitle.parameters; + + + + callback + + + + Ver las + retrollamadas de las observaciones. + + + + + + data + + + + Datos personalizados asociados con el observador. + + + + + + priority + + + + Prioridad del observador + + + + + + + + &reftitle.seealso; + + + EvPrepare + + + EvLoop::check + + + + + diff --git a/reference/ev/evcheck/createstopped.xml b/reference/ev/evcheck/createstopped.xml new file mode 100644 index 000000000..7c7e770c7 --- /dev/null +++ b/reference/ev/evcheck/createstopped.xml @@ -0,0 +1,106 @@ + + + + + + + EvCheck::createStopped + Crea una instancia de un observador EvCheck detenido + + + &reftitle.description; + + final + public + static + object + EvCheck::createStopped + + string + callback + + + string + data + + + string + priority + + + + Crea una instancia de un observador EvCheck detenido. + + + + &reftitle.parameters; + + + + callback + + + + Ver las + retrollamadas de los + observadores. + + + + + + data + + + + Datos personalizados para asociar con el observador. + + + + + + priority + + + + Prioridad del observador + + + + + + + &reftitle.returnvalues; + + Devuelve el objeto EvCheck en caso de éxito. + + + + &reftitle.seealso; + + + EvPrepare + + + + + diff --git a/reference/ev/evchild.xml b/reference/ev/evchild.xml new file mode 100644 index 000000000..8018ea8c8 --- /dev/null +++ b/reference/ev/evchild.xml @@ -0,0 +1,139 @@ + + + + + La clase EvChild + EvChild + + +
+ &reftitle.intro; + + Los watchers EvChild se activan cuando el + proceso recibe un SIGCHLD en respuesta a cambios de estado de los hijos (típicamente, cuando un hijo + muere o termina). Está permitido instalar un watcher + EvChild después de que el hijo haya sido forkeado + (lo que implica que ya debe existir), siempre que el bucle + de eventos no haya comenzado (o continuado desde un watcher), es decir, + forkear y luego registrar inmediatamente un watcher para el hijo es + el método correcto, pero forkear y registrar un watcher después de algunas + iteraciones del bucle de eventos o en la próxima invocación + de la función de retrollamada no es el método correcto. + + + Solo está permitido registrar watchers + EvChild en el + bucle por defecto. + +
+ +
+ &reftitle.classsynopsis; + + + + + EvChild + + + + + EvChild + + + extends + EvWatcher + + + + &Properties; + + public + pid + + + public + rpid + + + public + rstatus + + &InheritedProperties; + + &Methods; + + + &InheritedMethods; + + + +
+ +
+ &reftitle.properties; + + + + pid + + + + Solo lectura. + El ID del proceso relacionado + con los watchers, o 0 que significa todos los IDs + de proceso. + + + + + + rpid + + + + Solo lectura. El ID del proceso que ha detectado + un cambio de estado. + + + + + + rstatus + + + + Solo lectura. + El estado de salida del proceso + causado por rpid. + + + + +
+ + + + &reference.ev.entities.evchild; + + + diff --git a/reference/ev/evchild/construct.xml b/reference/ev/evchild/construct.xml new file mode 100644 index 000000000..1f9785560 --- /dev/null +++ b/reference/ev/evchild/construct.xml @@ -0,0 +1,163 @@ + + + + + + EvChild::__construct + Construye el objeto de observación EvChild + + + &reftitle.description; + + public + EvChild::__construct + + int + pid + + + bool + trace + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Construye el objeto observador EvChild. + + + Llama a la retrollamada cuando se recibe un cambio de estado de un proceso + cuyo ID pid (o de cualquier PID + si vale 0) (un cambio de estado ocurre cuando el proceso + termina o es eliminado, o cuando el parámetro trace + vale &true;, cuando el proceso es detenido o continuado). En otras palabras, + cuando el proceso recibe un SIGCHLD, Ev + recuperará todos los estados de salida/espera para todos los hijos + modificados/zombies y llamará a la retrollamada. + + + Es válido instalar un observador en el hijo después de que un + EvChild haya salido, pero antes de que el bucle + de eventos haya iniciado su siguiente iteración. Por ejemplo, + primero, se llama a fork, luego el nuevo proceso + hijo puede salir, y solo entonces, un observador + EvChild es instalado en el padre para el + nuevo PID. + + + Se podrá acceder a los estados de salida/de traza así como a los + pid utilizando las propiedades + rstatus y rpid del objeto observador. + + + El número de observadores PID por PID + no está limitado. Todos serán llamados. + + + El método EvChild::createStopped + no inicia (activa) el nuevo observador creado. + + + + &reftitle.parameters; + + + + pid + + + + Espera los cambios de estado de los procesos PID (o cualquier proceso + si PID vale 0). + + + + + + trace + + + + Si vale &false;, solo activa el observador cuando el proceso + termina. De lo contrario (&true;), activa el observador cuando el + proceso es detenido o continuado. + + + + + + callback + + + + Ver las + retrollamadas de los observadores. + + + + + + data + + + + Datos personalizados asociados con el observador. + + + + + + priority + + + + Retrollamadas del observador + + + + + + + + &reftitle.seealso; + + + EvLoop::child + + + + + diff --git a/reference/ev/evchild/createstopped.xml b/reference/ev/evchild/createstopped.xml new file mode 100644 index 000000000..6fb5ccb80 --- /dev/null +++ b/reference/ev/evchild/createstopped.xml @@ -0,0 +1,141 @@ + + + + + + + EvChild::createStopped + Crea una instancia del observador detenido EvCheck + + + &reftitle.description; + + final + public + static + object + EvChild::createStopped + + int + pid + + + bool + trace + + + callable + callback + + + mixed + data + + + int + priority + + + + Idéntico a EvChild::__construct, + pero no inicia automáticamente el observador. + + + + &reftitle.parameters; + + + + pid + + + + Idéntico al utilizado para + EvChild::__construct + + + + + + trace + + + + Idéntico al utilizado para + EvChild::__construct + + + + + + callback + + + + Ver las funciones + de retrollamada de los observadores. + + + + + + data + + + + Datos personalizados asociados con el observador. + + + + + + priority + + + + Prioridad de + el observador + + + + + + + + &reftitle.returnvalues; + + + + + &reftitle.seealso; + + + EvChild::__construct + + + EvLoop::child + + + + + + diff --git a/reference/ev/evchild/set.xml b/reference/ev/evchild/set.xml new file mode 100644 index 000000000..fdfbcb397 --- /dev/null +++ b/reference/ev/evchild/set.xml @@ -0,0 +1,89 @@ + + + + + + + + EvChild::set + Configura el observador + + + &reftitle.description; + + public + void + EvChild::set + + int + pid + + + bool + trace + + + + + + &reftitle.parameters; + + + + pid + + + + Idéntico al utilizado para + EvChild::__construct + + + + + + trace + + + + Idéntico al utilizado para + EvChild::__construct + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + EvChild::__construct + + + + + diff --git a/reference/ev/evembed.xml b/reference/ev/evembed.xml new file mode 100644 index 000000000..554f86b56 --- /dev/null +++ b/reference/ev/evembed.xml @@ -0,0 +1,120 @@ + + + + + + La clase EvEmbed + EvEmbed + + +
+ &reftitle.intro; + + Utilizado para integrar un bucle de eventos en otro. + +
+ +
+ &reftitle.classsynopsis; + + + + + EvEmbed + + + + + EvEmbed + + + extends + EvWatcher + + + + &Properties; + + public + embed + + &Methods; + + + &InheritedMethods; + + + +
+ +
+ &reftitle.properties; + + + + is_active + + + + + + + + data + + + + + + + + is_pending + + + + + + + + priority + + + + + + + + embed + + + + + + +
+ + + + &reference.ev.entities.evembed; + + + diff --git a/reference/ev/evembed/construct.xml b/reference/ev/evembed/construct.xml new file mode 100644 index 000000000..782a9cb0d --- /dev/null +++ b/reference/ev/evembed/construct.xml @@ -0,0 +1,163 @@ + + + + + + EvEmbed::__construct + Construye un objeto EvEmbed + + + &reftitle.description; + + public + EvEmbed::__construct + + object + other + + + callable + callback + + + mixed + data + + + int + priority + + + + Se trata de un tipo de watcher avanzado que permite integrar un bucle + de eventos en otro (actualmente, solo los eventos IO son + soportados en el bucle interno, otros tipos de watcher no deben + ser utilizados). + + + Ver la + + documentación libev para más detalles. + + + Este watcher es más útil en sistemas + BSD donde kqueue no es utilizado, + para poder manejar un gran número de sockets. Ver el ejemplo a continuación. + + + + &reftitle.parameters; + + + + other + + + + Una instancia de EvLoop. El bucle a integrar; + debe ser encapsulable (ver el método + Ev::embeddableBackends). + + + + + + callback + + + + Ver las + funciones de retrollamada de los Watcher. + + + + + + data + + + + Datos personalizados para asociar con el watcher. + + + + + + priority + + + + Prioridad del Watcher + + + + + + + + &reftitle.examples; + + + Encapsulamiento de un bucle creado con el gestor kqueue en el bucle por omisión + + +]]> + + + + + &reftitle.seealso; + + + Ev::embeddableBackends + + + + + diff --git a/reference/ev/evembed/createstopped.xml b/reference/ev/evembed/createstopped.xml new file mode 100644 index 000000000..75c9ca487 --- /dev/null +++ b/reference/ev/evembed/createstopped.xml @@ -0,0 +1,125 @@ + + + + + + + EvEmbed::createStopped + Crea un objeto EvEmbed watcher detenido + + + &reftitle.description; + + final + public + static + void + EvEmbed::createStopped + + object + other + + + callable + callback + + + mixed + data + + + int + priority + + + + Idéntico al método + EvEmbed::__construct, pero no inicia + automáticamente el watcher. + + + + &reftitle.parameters; + + + + other + + + + Idéntico al argumento del método + EvEmbed::__construct + + + + + + callback + + + + Ver las + retrollamadas de los Watcher. + + + + + + data + + + + Datos personalizados para asociar con el watcher. + + + + + + priority + + + + Prioridad del Watcher + + + + + + + &reftitle.returnvalues; + + Retorna un objeto EvEmbed detenido en caso de éxito. + + + + &reftitle.seealso; + + + EvEmbed::__construct + + + Ev::embeddableBackends + + + + + diff --git a/reference/ev/evembed/set.xml b/reference/ev/evembed/set.xml new file mode 100644 index 000000000..01a8aa855 --- /dev/null +++ b/reference/ev/evembed/set.xml @@ -0,0 +1,69 @@ + + + + + + + + EvEmbed::set + Configura el watcher + + + &reftitle.description; + + public + void + EvEmbed::set + + object + other + + + + Configura el watcher para utilizar el objeto + other del bucle de eventos. + + + + &reftitle.parameters; + + + + other + + + + Idéntico al argumento del método + EvEmbed::__construct + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + diff --git a/reference/ev/evembed/sweep.xml b/reference/ev/evembed/sweep.xml index cd3637ed4..b798486a4 100644 --- a/reference/ev/evembed/sweep.xml +++ b/reference/ev/evembed/sweep.xml @@ -1,11 +1,12 @@ - - + + + EvEmbed::sweep - Realizar un único barrido sin bloqueos sobre el bucle embebido + Barre, una sola vez y de forma no bloqueante, el bucle interno &reftitle.description; @@ -16,8 +17,9 @@ - Realizar un único barrido sin bloqueos sobre el bucle embebido. Funciona de forma - similar a lo siguiente, aunque de una forma más apropiada para bucles embebidos: + Barre, una sola vez y de forma no bloqueante, el bucle interno. + Funciona de la misma manera que lo siguiente, pero de una forma más + apropiada para los bucles internos: + + + + + La clase EvFork + EvFork + + +
+ &reftitle.intro; + + Los observadores Fork son llamados cuando un + fork() ha sido detectado (habitualmente, porque + señalado a libev al llamar al método + EvLoop::fork). La invocación se + realiza antes de que el bucle de eventos bloquee el siguiente + y antes de la llamada de los observadores EvCheck, + y solo en el hijo después del fork. Tenga en cuenta que si alguien + llama a EvLoop::fork en el proceso incorrecto, el gestor de fork será llamado también. + +
+ +
+ &reftitle.classsynopsis; + + + + + EvFork + + + + + EvFork + + + extends + EvWatcher + + + + + &InheritedProperties; + + &Methods; + + + &InheritedMethods; + + + +
+ + + &reference.ev.entities.evfork; + + + diff --git a/reference/ev/evfork/construct.xml b/reference/ev/evfork/construct.xml new file mode 100644 index 000000000..6577f19cd --- /dev/null +++ b/reference/ev/evfork/construct.xml @@ -0,0 +1,104 @@ + + + + + + EvFork::__construct + Construye el objeto observador EvFork + + + &reftitle.description; + + public + EvFork::__construct + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Construye el objeto observador EvFork y arranca el observador automáticamente. + + + + &reftitle.parameters; + + + + callback + + + + Véase también las + funciones de retrollamada para + los observadores. + + + + + + data + + + + Datos personalizados asociados al observador. + + + + + + priority + + + + Prioridad del observador + + + + + + + + &reftitle.seealso; + + + EvLoop::fork + + + EvCheck + + + + + diff --git a/reference/ev/evfork/createstopped.xml b/reference/ev/evfork/createstopped.xml new file mode 100644 index 000000000..d0f480fa1 --- /dev/null +++ b/reference/ev/evfork/createstopped.xml @@ -0,0 +1,107 @@ + + + + + + + EvFork::createStopped + Crea una instancia detenida de la clase observadora EvFork + + + &reftitle.description; + + final + public + static + object + EvFork::createStopped + + string + callback + + + string + data + + + string + priority + + + + Idéntico al método + EvFork::__construct pero + no inicia automáticamente el observador. + + + + &reftitle.parameters; + + + + callback + + + + Ver las + retrollamadas de observadores. + + + + + + data + + + + Datos personalizados asociados con el observador. + + + + + + priority + + + + Prioridad de observador + + + + + + + &reftitle.returnvalues; + + Devuelve un objeto EvFork (detenido) en caso de éxito. + + + + &reftitle.seealso; + + + EvFork::__construct + + + + + diff --git a/reference/ev/evidle.xml b/reference/ev/evidle.xml new file mode 100644 index 000000000..810692b49 --- /dev/null +++ b/reference/ev/evidle.xml @@ -0,0 +1,97 @@ + + + + + La clase EvIdle + EvIdle + + +
+ &reftitle.intro; + + Los observadores EvIdle lanzan los eventos + cuando ningún otro evento con la misma (o superior) prioridad + está pendiente (EvPrepare, EvCheck + y otros observadores EvIdle no cuentan + como eventos). + + + Asimismo, mientras el proceso está gestionando sockets o + tiempos de espera máximos (o incluso señales) de la misma prioridad (o + de prioridad superior), no se lanzará. Pero cuando el proceso + está inactivo (o solo hay observadores con prioridad baja pendientes), los observadores EvIdle serán llamados + una vez por iteración del bucle de eventos - y esto, mientras + no se detengan, o el proceso no reciba más eventos + y se ocupe así de gestionar trabajos con prioridad superior. + + + Además de mantener el proceso no bloqueante (lo cual es útil a veces), + los observadores EvIdle son un buen lugar + para realizar "trabajos en pseudo-segundo plano", + o reprogramar trabajos después de que el bucle de eventos haya gestionado + los eventos excepcionales. + + + El efecto más notable es que, mientras los observadores + idle estén activos, el proceso + no se bloqueará al esperar nuevos + eventos. + +
+ +
+ &reftitle.classsynopsis; + + + + + EvIdle + + + + + EvIdle + + + extends + EvWatcher + + + + + &InheritedProperties; + + &Methods; + + + &InheritedMethods; + + + +
+ + + + &reference.ev.entities.evidle; + + + diff --git a/reference/ev/evidle/construct.xml b/reference/ev/evidle/construct.xml new file mode 100644 index 000000000..684f684d0 --- /dev/null +++ b/reference/ev/evidle/construct.xml @@ -0,0 +1,102 @@ + + + + + + EvIdle::__construct + Construye el objeto observador EvIdle + + + &reftitle.description; + + public + EvIdle::__construct + + callable + callback + + + mixed + data + + + int + priority + + + + Construye el objeto observador EvIdle e inicia automáticamente + el observador. + + + + &reftitle.parameters; + + + + callback + + + + Ver las + funciones de retrollamada de los + observadores. + + + + + + data + + + + Datos personalizados asociados con el observador. + + + + + + priority + + + + Prioridad del observador + + + + + + + + &reftitle.seealso; + + + EvIdle::createStopped + + + EvLoop::idle + + + + + + diff --git a/reference/ev/evidle/createstopped.xml b/reference/ev/evidle/createstopped.xml new file mode 100644 index 000000000..f0b7e6037 --- /dev/null +++ b/reference/ev/evidle/createstopped.xml @@ -0,0 +1,110 @@ + + + + + + + EvIdle::createStopped + Crea una instancia de un objeto observador EvIdle + + + &reftitle.description; + + final + public + static + object + EvIdle::createStopped + + string + callback + + + mixed + data + + + int + priority + + + + Idéntico al método EvIdle::__construct + pero no inicia automáticamente el observador. + + + + &reftitle.parameters; + + + + callback + + + + Ver las + retrollamadas de los + observadores. + + + + + + data + + + + Datos personalizados con el observador. + + + + + + priority + + + + Prioridad del observador + + + + + + + &reftitle.returnvalues; + + Devuelve un objeto EvIdle en caso de éxito. + + + + &reftitle.seealso; + + + EvIdle::__construct + + + EvLoop::idle + + + + + diff --git a/reference/ev/evio.xml b/reference/ev/evio.xml new file mode 100644 index 000000000..594b99a5b --- /dev/null +++ b/reference/ev/evio.xml @@ -0,0 +1,138 @@ + + + + + + La clase EvIo + EvIo + + +
+ &reftitle.intro; + + Los observadores EvIo verifican si un descriptor + de fichero (o un socket, o un flujo que pueda ser convertido en descriptor + de fichero numérico) está disponible para lectura o escritura en cada + iteración del bucle de eventos, o, más precisamente, cuando la + lectura no va a bloquear el proceso, y cuando la escritura va + a permitir escribir datos. Este comportamiento se denomina + nivel de activación porque los eventos se + mantienen mientras persista la condición. Para detener la recepción + de eventos, simplemente se debe detener el observador. + + + El número de eventos de lectura/escritura de los observadores por + fd es ilimitado. Establecer todos los + descriptores de ficheros en modo no bloqueante es generalmente + una buena idea (aunque no es obligatorio). + + + Otra cosa a tener en cuenta es que es muy fácil recibir + notificaciones falsas de sistema listo para lectura, es decir, la función + de retrollamada puede ser llamada con Ev::READ + pero una subsiguiente read() puede bloquearse + debido a que no hay datos. Es muy simple + encontrarse en esta situación. Por lo tanto, se recomienda siempre + utilizar I/O no bloqueante: una read() + adicional que devuelva EAGAIN (o similar) + es preferible a un programa que espera la llegada de datos. + + + Si por alguna razón no es posible ejecutar el + fd en modo no bloqueante, entonces, por separado, + se debe volver a verificar si el descriptor de fichero está realmente listo. + Algunos usuarios utilizan además SIGALRM + y un temporizador de intervalo, solo para asegurarse de que no haya + bloqueos infinitos. + + + Se recomienda siempre utilizar el modo no bloqueante. + +
+ +
+ &reftitle.classsynopsis; + + + + + EvIo + + + + + EvIo + + + extends + EvWatcher + + + + &Properties; + + public + fd + + + public + events + + &InheritedProperties; + + &Methods; + + + &InheritedMethods; + + + +
+ +
+ &reftitle.properties; + + + + fd + + + + + + + + events + + + + + + +
+ + + + &reference.ev.entities.evio; + + + diff --git a/reference/ev/evio/construct.xml b/reference/ev/evio/construct.xml new file mode 100644 index 000000000..99ee16061 --- /dev/null +++ b/reference/ev/evio/construct.xml @@ -0,0 +1,131 @@ + + + + + + EvIo::__construct + Construye un nuevo objeto EvIo + + + &reftitle.description; + + public + EvIo::__construct + + mixed + fd + + + int + events + + + callable + callback + + + mixed + data + + + int + priority + + + + Construye un nuevo objeto EvIo y arranca el observador automáticamente. + + + + &reftitle.parameters; + + + + fd + + + + Puede ser un flujo abierto con la función + fopen o cualquier función similar, + descriptores de ficheros o sockets. + + + + + + events + + + + Ev::READ y/o Ev::WRITE. + Ver las + máscaras de octetos. + + + + + + callback + + + + Ver las + funciones de retrollamada de los observadores. + + + + + + data + + + + Datos personalizados asociados con el observador. + + + + + + priority + + + + Prioridad del observador + + + + + + + + &reftitle.seealso; + + + EvIo::createStopped + + + EvLoop::io + + + + + diff --git a/reference/ev/evio/createstopped.xml b/reference/ev/evio/createstopped.xml new file mode 100644 index 000000000..df924e76e --- /dev/null +++ b/reference/ev/evio/createstopped.xml @@ -0,0 +1,144 @@ + + + + + + + EvIo::createStopped + Crea un objeto observador EvIo detenido + + + &reftitle.description; + + final + public + static + EvIo + EvIo::createStopped + + mixed + fd + + + int + events + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Idéntico al método + EvIo::__construct pero + no inicia automáticamente el observador. + + + + &reftitle.parameters; + + + + fd + + + + Idéntico al método + EvIo::__construct + + + + + + events + + + + Idéntico al método + EvIo::__construct + + + + + + callback + + + + Ver las + funciones de retrollamada de los observadores. + + + + + + data + + + + Datos personalizados asociados con el observador. + + + + + + priority + + + + Prioridad del observador + + + + + + + &reftitle.returnvalues; + + Devuelve un objeto EvIo en caso de éxito. + + + + &reftitle.seealso; + + + EvIo::__construct + + + EvLoop::io + + + + + diff --git a/reference/ev/evio/set.xml b/reference/ev/evio/set.xml new file mode 100644 index 000000000..2cc995fc4 --- /dev/null +++ b/reference/ev/evio/set.xml @@ -0,0 +1,83 @@ + + + + + + + + EvIo::set + Configura el observador + + + &reftitle.description; + + public + void + EvIo::set + + mixed + fd + + + int + events + + + + Configura el observador EvIo. + + + + &reftitle.parameters; + + + + fd + + + + Idéntico al método + EvIo::__construct + + + + + + events + + + + Idéntico al método + EvIo::__construct + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + diff --git a/reference/ev/evloop.xml b/reference/ev/evloop.xml new file mode 100644 index 000000000..4aa4576b6 --- /dev/null +++ b/reference/ev/evloop.xml @@ -0,0 +1,236 @@ + + + + + La clase EvLoop + EvLoop + + +
+ &reftitle.intro; + + Representa un bucle de eventos que siempre es distinto del + bucle por defecto. A diferencia del + bucle por defecto, no puede gestionar los + watchers EvChild. + + + Al utilizar hilos, se debe crear un bucle por hilo, + y utilizar el bucle por defecto en el hilo + padre. + + + El bucle de eventos por defecto es inicializado + automáticamente por Ev. Es accesible a través de los + métodos de la clase Ev o mediante el método + EvLoop::defaultLoop. + +
+ +
+ &reftitle.classsynopsis; + + + + + EvLoop + + + + + final + EvLoop + + + + &Properties; + + public + data + + + public + backend + + + public + is_default_loop + + + public + iteration + + + public + pending + + + public + io_interval + + + public + timeout_interval + + + public + depth + + &Methods; + + + + +
+ +
+ &reftitle.properties; + + + + data + + + + Datos personalizados para adjuntar al bucle + + + + + + backend + + + + Solo lectura. + Los + flags del backend + que indican el backend de eventos en uso. + + + + + + is_default_loop + + + + Solo lectura. + &true; si es el bucle de eventos por defecto. + + + + + + iteration + + + + El contador de iteración actual del bucle. Ver el método + Ev::iteration. + + + + + + pending + + + + El número de watchers pendientes. + 0 indica que no hay watchers pendientes. + + + + + + io_interval + + + + Un valor alto para io_interval permite a + libev pasar más tiempo recolectando + los eventos EvIo, así, más eventos + pueden ser gestionados por iteración, pero esto aumentará la + latencia. Los tiempos de espera máximos (tanto para + EvPeriodic como para EvTimer) + no se verán afectados. Establecer esta opción a un valor + distinto de cero introducirá una llamada adicional a sleep() + en la mayoría de las iteraciones del bucle. + El tiempo de pausa asegura que libev + no consultará EvIo más de una vez + durante este intervalo, en promedio. La mayoría de los programas + pueden beneficiarse estableciendo + io_interval a un valor cercano a + 0.1, lo cual es generalmente suficiente para los + servidores interactivos (y no destinados a juegos). Generalmente + no tiene sentido establecer este valor a menos de + 0.01, ya que se acerca a la + granularidad a nivel de tiempos de la mayoría de los sistemas. + + + Ver también las + + funciones que controlan los bucles de eventos. + + + + + + timeout_interval + + + + Un valor alto para timeout_interval permite a + libev pasar más tiempo recolectando los + tiempos de espera máximos, pero como consecuencia aumenta + la latencia, el estrés y la inexactitud (la función de retrollamada + del watcher será llamada más tarde). Los watchers EvIo + no se verán afectados. Establecer este valor a un valor no + nulo no introducirá ninguna sobrecarga adicional a + libev. Ver también las + + funciones que controlan los bucles de eventos. + + + + + + depth + + + + La profundidad de la recursión. Ver el método + Ev::depth. + + + + +
+ + + + &reference.ev.entities.evloop; + + + diff --git a/reference/ev/evloop/backend.xml b/reference/ev/evloop/backend.xml new file mode 100644 index 000000000..60c81dc4a --- /dev/null +++ b/reference/ev/evloop/backend.xml @@ -0,0 +1,63 @@ + + + + + + + EvLoop::backend + Retorna un integer que describe el backend utilizado por libev + + + &reftitle.description; + + public + int + EvLoop::backend + + + + Idéntico al método Ev::backend, + pero para la instancia del ciclo. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Retorna un integer que describe el backend utilizado por libev. + Ver el método Ev::backend. + + + + &reftitle.seealso; + + + Ev::backend + + + + + + diff --git a/reference/ev/evloop/check.xml b/reference/ev/evloop/check.xml new file mode 100644 index 000000000..ddea11779 --- /dev/null +++ b/reference/ev/evloop/check.xml @@ -0,0 +1,76 @@ + + + + + + + + EvLoop::check + Crea un objeto EvCheck asociado con la instancia del bucle de eventos actual + + + &reftitle.description; + + final + public + EvCheck + EvLoop::check + + string + callback + + + string + data + + + string + priority + + + + Crea un objeto EvCheck asociado con la instancia del bucle de eventos actual. + + + + &reftitle.parameters; + + Todos los argumentos tienen el mismo significado que para el método + EvCheck::__construct. + + + + &reftitle.returnvalues; + + Devuelve un objeto EvCheck en caso de éxito. + + + + &reftitle.seealso; + + + EvCheck::__construct + + + + + diff --git a/reference/ev/evloop/child.xml b/reference/ev/evloop/child.xml new file mode 100644 index 000000000..5fc30111f --- /dev/null +++ b/reference/ev/evloop/child.xml @@ -0,0 +1,84 @@ + + + + + + + + EvLoop::child + Crea un objeto EvChild asociado con el bucle de eventos actual + + + &reftitle.description; + + final + public + EvChild + EvLoop::child + + string + pid + + + string + trace + + + string + callback + + + string + data + + + string + priority + + + + Crea un objeto EvChild asociado con el bucle de eventos actual. + + + + &reftitle.parameters; + + Todos los argumentos tienen el mismo significado que para el método + EvChild::__construct. + + + + &reftitle.returnvalues; + + Devuelve un objeto EvChild en caso de éxito. + + + + &reftitle.seealso; + + + EvChild::__construct + + + + + diff --git a/reference/ev/evloop/construct.xml b/reference/ev/evloop/construct.xml new file mode 100644 index 000000000..3732afb72 --- /dev/null +++ b/reference/ev/evloop/construct.xml @@ -0,0 +1,120 @@ + + + + + + + EvLoop::__construct + Construye un objeto de bucle de eventos + + + &reftitle.description; + + public + EvLoop::__construct + + int + flags + + + mixed + data + NULL + + + float + io_interval + 0.0 + + + float + timeout_interval + 0.0 + + + + Construye el objeto de bucle de eventos. + + + + &reftitle.parameters; + + + + flags + + + + Uno de los + flags de bucle + de eventos + + + + + + data + + + + Datos personalizados para asociar con el bucle. + + + + + + io_interval + + + + Ver la función + io_interval + + + + + + timeout_interval + + + + Ver la función + timeout_interval + + + + + + + + &reftitle.seealso; + + + EvLoop::defaultLoop + + + + + diff --git a/reference/ev/evloop/defaultloop.xml b/reference/ev/evloop/defaultloop.xml new file mode 100644 index 000000000..98c0da599 --- /dev/null +++ b/reference/ev/evloop/defaultloop.xml @@ -0,0 +1,132 @@ + + + + + + + + EvLoop::defaultLoop + Devuelve o crea el bucle de eventos por omisión + + + &reftitle.description; + + public + static + EvLoop + EvLoop::defaultLoop + + int + flags + Ev::FLAG_AUTO + + + mixed + data + NULL + + + float + io_interval + 0. + + + float + timeout_interval + 0. + + + + Si el bucle de eventos por omisión no está creado, el método + EvLoop::defaultLoop lo crea con los parámetros + especificados. De lo contrario, devolverá la instancia del objeto correspondiente + previamente creado ignorando todos los parámetros. + + + + &reftitle.parameters; + + + + flags + + + + Uno de los + flags de bucle de eventos + + + + + + data + + + + Datos personalizados para asociar con el bucle. + + + + + + io_collect_interval + + + + Ver la función + io_interval + + + + + + timeout_collect_interval + + + + Ver la función + timeout_interval + + + + + + + &reftitle.returnvalues; + + Devuelve el objeto EvLoop en caso de éxito. + + + + &reftitle.seealso; + + + EvLoop::__construct + + + + + diff --git a/reference/ev/evloop/embed.xml b/reference/ev/evloop/embed.xml new file mode 100644 index 000000000..c09d717f5 --- /dev/null +++ b/reference/ev/evloop/embed.xml @@ -0,0 +1,81 @@ + + + + + + + EvLoop::embed + Crea una instancia del observador EvEmbed asociado con el objeto EvLoop actual + + + &reftitle.description; + + final + public + EvEmbed + EvLoop::embed + + string + other + + + string + callback + + + string + data + + + string + priority + + + + Crea una instancia del observador + EvEmbed asociado con el objeto + EvLoop actual. + + + + &reftitle.parameters; + + Todos los argumentos tienen el mismo significado que para el método + EvEmbed::__construct. + + + + &reftitle.returnvalues; + + Devuelve el objeto EvEmbed en caso de éxito. + + + + &reftitle.seealso; + + + EvEmbed::__construct + + + + + diff --git a/reference/ev/evloop/fork.xml b/reference/ev/evloop/fork.xml new file mode 100644 index 000000000..ab21b375b --- /dev/null +++ b/reference/ev/evloop/fork.xml @@ -0,0 +1,80 @@ + + + + + + + + EvLoop::fork + Crea un objeto EvFork watcher asociado con la instancia del bucle de eventos actual + + + &reftitle.description; + + final + public + EvFork + EvLoop::fork + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Crea un objeto EvFork watcher asociado con la instancia del bucle de eventos actual + + + + &reftitle.parameters; + + Todos los parámetros tienen el mismo significado que los de la función + EvFork::__construct. + + + + &reftitle.returnvalues; + + Devuelve el objeto EvFork en caso de éxito. + + + + &reftitle.seealso; + + + EvFork::__construct + + + + + diff --git a/reference/ev/evloop/idle.xml b/reference/ev/evloop/idle.xml new file mode 100644 index 000000000..8207302c6 --- /dev/null +++ b/reference/ev/evloop/idle.xml @@ -0,0 +1,82 @@ + + + + + + + + EvLoop::idle + Crea un objeto EvIdle watcher asociado con la instancia del bucle + de eventos actual + + + &reftitle.description; + + final + public + EvIdle + EvLoop::idle + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Crea un objeto EvIdle watcher asociado con la instancia del bucle + de eventos actual + + + + &reftitle.parameters; + + Todos los parámetros tienen el mismo significado que los de la función + EvIdle::__construct + + + + &reftitle.returnvalues; + + Devuelve un objeto EvIdle en caso de éxito. + + + + &reftitle.seealso; + + + EvIdle::__construct + + + + + diff --git a/reference/ev/evloop/invokepending.xml b/reference/ev/evloop/invokepending.xml new file mode 100644 index 000000000..7bd9614d6 --- /dev/null +++ b/reference/ev/evloop/invokepending.xml @@ -0,0 +1,55 @@ + + + + + + + + EvLoop::invokePending + Invoca todos los watchers pendientes mientras sus estados + de cola no sean reinicializados + + + &reftitle.description; + + public + void + EvLoop::invokePending + + + + Invoca todos los watchers pendientes mientras sus estados + de cola no sean reinicializados. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + diff --git a/reference/ev/evloop/io.xml b/reference/ev/evloop/io.xml new file mode 100644 index 000000000..b11fcdc8c --- /dev/null +++ b/reference/ev/evloop/io.xml @@ -0,0 +1,88 @@ + + + + + + + + EvLoop::io + Crea un objeto EvIo watcher asociado con la instancia del bucle de eventos actual + + + &reftitle.description; + + final + public + EvIo + EvLoop::io + + mixed + fd + + + int + events + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Crea un objeto EvIo watcher asociado con la instancia del bucle de eventos actual. + + + + &reftitle.parameters; + + Todos los parámetros tienen el mismo significado que los del método + EvIo::__construct. + + + + &reftitle.returnvalues; + + Devuelve un objeto EvIo en caso de éxito. + + + + &reftitle.seealso; + + + EvIo::__construct + + + + + diff --git a/reference/ev/evloop/loopfork.xml b/reference/ev/evloop/loopfork.xml new file mode 100644 index 000000000..3827a38cd --- /dev/null +++ b/reference/ev/evloop/loopfork.xml @@ -0,0 +1,59 @@ + + + + + + + + EvLoop::loopFork + Debe ser llamado después de un fork + + + &reftitle.description; + + public + void + EvLoop::loopFork + + + + Debe ser llamado después de un fork en el hijo, + y antes de entrar o continuar el bucle de eventos. Una alternativa + es utilizar la constante Ev::FLAG_FORKCHECK + que llama a esta función automáticamente, con una pérdida de + rendimiento (consulte la documentación + libev). + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + diff --git a/reference/ev/evloop/now.xml b/reference/ev/evloop/now.xml new file mode 100644 index 000000000..f5ea4b503 --- /dev/null +++ b/reference/ev/evloop/now.xml @@ -0,0 +1,67 @@ + + + + + + + + EvLoop::now + Devuelve el "event loop time" actual + + + &reftitle.description; + + public + float + EvLoop::now + + + + Devuelve el "event loop time" actual, que es la duración durante + la cual el bucle de eventos recibe eventos y + inicia sus análisis. Este timestamp no cambia mientras las + retrollamadas están en ejecución, y es también el tiempo + base utilizado para los temporizadores relativos. Puede considerarse + como el timestamp del evento en curso (o más exactamente, + el utilizado por libev). + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Devuelve el timestamp del bucle de eventos, en segundos. + + + + &reftitle.seealso; + + + Ev::now + + + + + diff --git a/reference/ev/evloop/nowupdate.xml b/reference/ev/evloop/nowupdate.xml new file mode 100644 index 000000000..a58f8ddd8 --- /dev/null +++ b/reference/ev/evloop/nowupdate.xml @@ -0,0 +1,64 @@ + + + + + + + EvLoop::nowUpdate + Establece el tiempo actual solicitándolo al kernel y actualiza el tiempo devuelto por EvLoop::now durante la ejecución + + + &reftitle.description; + + public + void + EvLoop::nowUpdate + + + + Establece el tiempo actual solicitándolo al kernel y actualiza el tiempo devuelto por EvLoop::now durante la ejecución. + Se trata de una operación costosa en términos de rendimiento que normalmente se ejecuta automáticamente en el método EvLoop::run. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + EvLoop::now + + + Ev::nowUpdate + + + + + diff --git a/reference/ev/evloop/periodic.xml b/reference/ev/evloop/periodic.xml new file mode 100644 index 000000000..44a1a2f01 --- /dev/null +++ b/reference/ev/evloop/periodic.xml @@ -0,0 +1,90 @@ + + + + + + + + EvLoop::periodic + Crea un objeto EvPeriodic watcher asociado con la instancia del + bucle de eventos actual + + + &reftitle.description; + + final + public + EvPeriodic + EvLoop::periodic + + float + offset + + + float + interval + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Crea un objeto EvPeriodic watcher asociado con la instancia del + bucle de eventos actual. + + + + &reftitle.parameters; + + Todos los parámetros tienen el mismo significado que los de la método + EvPeriodic::__construct. + + + + &reftitle.returnvalues; + + Devuelve un objeto EvPeriodic en caso de éxito. + + + + &reftitle.seealso; + + + EvPeriodic::__construct + + + + + diff --git a/reference/ev/evloop/prepare.xml b/reference/ev/evloop/prepare.xml new file mode 100644 index 000000000..e68a22a04 --- /dev/null +++ b/reference/ev/evloop/prepare.xml @@ -0,0 +1,80 @@ + + + + + + + + EvLoop::prepare + Crea un objeto EvPrepare watcher asociado con la instancia del bucle de eventos actual + + + &reftitle.description; + + final + public + EvPrepare + EvLoop::prepare + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Crea un objeto EvPrepare watcher asociado con la instancia del bucle de eventos actual. + + + + &reftitle.parameters; + + Todos los parámetros tienen el mismo significado que los de la función + EvPrepare. + + + + &reftitle.returnvalues; + + Devuelve un objeto EvPrepare en caso de éxito. + + + + &reftitle.seealso; + + + EvPrepare::__construct + + + + + diff --git a/reference/ev/evloop/resume.xml b/reference/ev/evloop/resume.xml new file mode 100644 index 000000000..a0389e99b --- /dev/null +++ b/reference/ev/evloop/resume.xml @@ -0,0 +1,66 @@ + + + + + + + + EvLoop::resume + Reanuda un bucle de eventos previamente detenido + + + &reftitle.description; + + public + void + EvLoop::resume + + + + Los métodos EvLoop::suspend + y EvLoop::resume suspenden y + reanudan un bucle. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + EvLoop::suspend + + + Ev::resume + + + + + diff --git a/reference/ev/evloop/run.xml b/reference/ev/evloop/run.xml new file mode 100644 index 000000000..f3b984ae8 --- /dev/null +++ b/reference/ev/evloop/run.xml @@ -0,0 +1,128 @@ + + + + + + + EvLoop::run + Comienza a verificar los eventos y a llamar a las funciones de retrollamada de la bucle + + + &reftitle.description; + + public + void + EvLoop::run + + int + flags + 0 + + + + Comienza a verificar los eventos y a llamar a las funciones de retrollamada + para la bucle de evento actual. El método se detiene cuando una + función de retrollamada llama al método Ev::stop + o cuando los flags son diferentes de cero (en cuyo caso, el valor + devuelto es &true;) o cuando no hay ningún watcher activo que referencie + la bucle (EvWatcher::keepalive vale &true;), + en cuyo caso, el valor devuelto será &false;. + El valor devuelto puede generalmente ser interpretado como + si &true;, aún hay trabajo por hacer. + + + + &reftitle.parameters; + + + + flags + + + + El argumento opcional flags + puede tomar uno de los valores siguientes: + + + Lista de valores posibles para <parameter>flags</parameter> + + + + + + flags + + Descripción + + + + + + 0 + + El comportamiento por omisión, descrito anteriormente + + + + Ev::RUN_ONCE + + No bloquear más de un evento (espera, pero no bucla) + + + + Ev::RUN_NOWAIT + + Sin bloqueo (recupera, gestiona los eventos, pero no espera) + + + +
+ + + Ver las + constantes de los flags + de ejecución. + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + EvLoop::stop + + + Ev::run + + + + + diff --git a/reference/ev/evloop/signal.xml b/reference/ev/evloop/signal.xml new file mode 100644 index 000000000..ec8c7d175 --- /dev/null +++ b/reference/ev/evloop/signal.xml @@ -0,0 +1,86 @@ + + + + + + + + EvLoop::signal + Crea un objeto EvSignal watcher asociado con la instancia del + bucle de eventos actual + + + &reftitle.description; + + final + public + EvSignal + EvLoop::signal + + int + signum + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Crea un objeto EvSignal watcher asociado con la instancia del + bucle de eventos actual. + + + + &reftitle.parameters; + + Todos los argumentos tienen el mismo significado que los de la método + EvSignal::__construct. + + + + &reftitle.returnvalues; + + Devuelve un objeto EvSignal en caso de éxito. + + + + &reftitle.seealso; + + + EvSignal::__construct + + + + + diff --git a/reference/ev/evloop/stat.xml b/reference/ev/evloop/stat.xml new file mode 100644 index 000000000..843b60630 --- /dev/null +++ b/reference/ev/evloop/stat.xml @@ -0,0 +1,88 @@ + + + + + + + + EvLoop::stat + Crea un objeto EvStat watcher asociado con la instancia del bucle de eventos actual + + + &reftitle.description; + + final + public + EvStat + EvLoop::stat + + string + path + + + float + interval + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Crea un objeto EvStat watcher asociado con la instancia del bucle de eventos actual. + + + + &reftitle.parameters; + + Todos los parámetros tienen el mismo significado que los de la función + EvSignal::__construct. + + + + &reftitle.returnvalues; + + Devuelve un objeto EvStat en caso de éxito. + + + + &reftitle.seealso; + + + EvSignal::__construct + + + + + diff --git a/reference/ev/evloop/stop.xml b/reference/ev/evloop/stop.xml new file mode 100644 index 000000000..76271d067 --- /dev/null +++ b/reference/ev/evloop/stop.xml @@ -0,0 +1,78 @@ + + + + + + + EvLoop::stop + Detiene el bucle de eventos + + + &reftitle.description; + + public + void + EvLoop::stop + + int + how + + + + Detiene el bucle de eventos. + + + + &reftitle.parameters; + + + + how + + + + Una constante + Ev::BREAK_*. + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + EvLoop::run + + + Ev::stop + + + + + diff --git a/reference/ev/evloop/suspend.xml b/reference/ev/evloop/suspend.xml new file mode 100644 index 000000000..d33d72c4d --- /dev/null +++ b/reference/ev/evloop/suspend.xml @@ -0,0 +1,66 @@ + + + + + + + + EvLoop::suspend + Suspende el bucle + + + &reftitle.description; + + public + void + EvLoop::suspend + + + + Los métodos EvLoop::suspend + y EvLoop::resume suspenden + y reanudan un bucle. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + EvLoop::resume + + + Ev::suspend + + + + + diff --git a/reference/ev/evloop/timer.xml b/reference/ev/evloop/timer.xml new file mode 100644 index 000000000..f8d586e7c --- /dev/null +++ b/reference/ev/evloop/timer.xml @@ -0,0 +1,88 @@ + + + + + + + + EvLoop::timer + Crea un objeto EvTimer watcher asociado con la instancia del bucle de eventos actual + + + &reftitle.description; + + final + public + EvTimer + EvLoop::timer + + float + after + + + float + repeat + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Crea un objeto EvTimer watcher asociado con la instancia del bucle de eventos actual. + + + + &reftitle.parameters; + + Todos los argumentos tienen el mismo significado que los de la función + EvTimer::__construct. + + + + &reftitle.returnvalues; + + Devuelve el objeto EvTimer en caso de éxito. + + + + &reftitle.seealso; + + + EvTimer::__construct + + + + + diff --git a/reference/ev/evloop/verify.xml b/reference/ev/evloop/verify.xml new file mode 100644 index 000000000..de6265af6 --- /dev/null +++ b/reference/ev/evloop/verify.xml @@ -0,0 +1,62 @@ + + + + + + + EvLoop::verify + Realiza verificaciones de consistencia interna (para la depuración) + + + &reftitle.description; + + public + void + EvLoop::verify + + + + Realiza verificaciones de consistencia interna (para la depuración + de libev) y detiene el programa si se encuentran estructuras + de datos corruptas. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + Ev::verify + + + + + diff --git a/reference/ev/evperiodic.xml b/reference/ev/evperiodic.xml new file mode 100644 index 000000000..8c876f6d0 --- /dev/null +++ b/reference/ev/evperiodic.xml @@ -0,0 +1,142 @@ + + + + + La clase EvPeriodic + EvPeriodic + + +
+ &reftitle.intro; + + Los observadores periódicos son una especie de temporizadores, pero son muy + versátiles. + + + A diferencia de EvTimer, los observadores + EvPeriodic no se basan en un tiempo real + (o un tiempo relativo, el tiempo físico que transcurre), sino en un tiempo + de reloj (tiempo absoluto, calendario o de reloj). La diferencia es + que un tiempo de reloj puede ser más rápido o más lento que un tiempo + real, y los saltos en el tiempo no son raros (por ejemplo, durante un ajuste). + + + Un observador EvPeriodic puede ser configurado para + ser lanzado después de puntos específicos en el tiempo. Por ejemplo, + si un observador EvPeriodic está configurado para + lanzarse "en 10 segundos" (es decir, + EvLoop::now + 10.0, + es decir, un tiempo absoluto, y no un retraso), y el reloj del sistema + se reinicia a enero del año pasado, + entonces tomará un año o más para lanzar el evento (a diferencia + de EvTimer que se lanzará 10 + segundos después de su inicio, ya que utiliza un retraso máximo relativo). + + + Al igual que con los temporizadores, se garantiza que la función de retrollamada sea + llamada únicamente cuando el punto en el tiempo en el que se supone que debe lanzarse + haya pasado. Si varios temporizadores se vuelven listos al mismo tiempo + durante la misma iteración del bucle, entonces aquellos con valores de retraso + máximo más cercanos serán llamados antes que aquellos con valores de retraso + máximo más lejanos (pero esto ya no es cierto cuando una función de retrollamada + llama recursivamente al método EvLoop::run). + +
+ +
+ &reftitle.classsynopsis; + + + + + EvPeriodic + + + + + EvPeriodic + + + extends + EvWatcher + + + + &Properties; + + public + offset + + + public + interval + + &InheritedProperties; + + &Methods; + + + &InheritedMethods; + + + +
+ +
+ &reftitle.properties; + + + + offset + + + + Al repetirse, contendrá el valor de la posición, de lo contrario, + será el punto absoluto en el tiempo (el valor de la posición + pasado al método EvPeriodic::set, + aunque libev puede modificar este valor + para una mejor estabilidad numérica). + + + + + + interval + + + + El valor del intervalo actual. Puede ser modificado en cualquier momento, + pero los cambios no surten efecto hasta que el temporizador + periódico no se lance, o cuando se llame al método + EvPeriodic::again. + + + + +
+ + + + &reference.ev.entities.evperiodic; + + + diff --git a/reference/ev/evperiodic/again.xml b/reference/ev/evperiodic/again.xml new file mode 100644 index 000000000..7378c6dd8 --- /dev/null +++ b/reference/ev/evperiodic/again.xml @@ -0,0 +1,62 @@ + + + + + + + + EvPeriodic::again + Detiene y reinicia el observador periódico + + + &reftitle.description; + + public + void + EvPeriodic::again + + + + Detiene y reinicia el observador periódico. Esto solo es útil + cuando los atributos han cambiado. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + EvTimer::again + + + + + diff --git a/reference/ev/evperiodic/at.xml b/reference/ev/evperiodic/at.xml new file mode 100644 index 000000000..d35d0be52 --- /dev/null +++ b/reference/ev/evperiodic/at.xml @@ -0,0 +1,57 @@ + + + + + + + EvPeriodic::at + Devuelve el tiempo absoluto en el que este watcher será llamado la próxima vez + + + &reftitle.description; + + public + float + EvPeriodic::at + + + + Devuelve el tiempo absoluto en el que este watcher será llamado la próxima vez. + Esto no es lo mismo que el argumento de posición del método + EvPeriodic::set o el método + EvPeriodic::__construct, pero funciona también en + modo intervalo. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Devuelve el tiempo absoluto en el que este watcher será llamado la próxima vez, + en segundos. + + + + diff --git a/reference/ev/evperiodic/construct.xml b/reference/ev/evperiodic/construct.xml new file mode 100644 index 000000000..c1216b2bc --- /dev/null +++ b/reference/ev/evperiodic/construct.xml @@ -0,0 +1,204 @@ + + + + + + EvPeriodic::__construct + Construye un objeto watcher EvPeriodic + + + &reftitle.description; + + public + EvPeriodic::__construct + + float + offset + + + string + interval + + + callable + reschedule_cb + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Construye un objeto watcher EvPeriodic y lo inicia automáticamente. + El método EvPeriodic::createStopped + crea un watcher periódico detenido. + + + + &reftitle.parameters; + + + + offset + + + + Ver los + modos de operación del watcher periódico + + + + + + interval + + + + Ver los + modos de operación del watcher periódico + + + + + + reschedule_cb + + + + Función de retrollamada Reschedule. Puede pasarse el valor &null;. + Ver los + modos de operación del watcher periódico + + + + + + callback + + + + Ver las + funciones de retrollamada de los Watchers . + + + + + + data + + + + Datos personalizados para asociar con el watcher. + + + + + + priority + + + + Prioridad del Watcher + + + + + + + + &reftitle.examples; + + + Temporizador periódico. Utilizando la retrollamada de replanificación + + + +]]> + + + + Temporizador periódico. Llamado cada 10.5 segundos + + +]]> + + + + Watcher cada hora + + +]]> + + + + + &reftitle.seealso; + + + Los modos de operación del watcher periódico + + + EvTimer + + + EvPeriodic::createStopped + + + + + diff --git a/reference/ev/evperiodic/createstopped.xml b/reference/ev/evperiodic/createstopped.xml new file mode 100644 index 000000000..8cc8ea017 --- /dev/null +++ b/reference/ev/evperiodic/createstopped.xml @@ -0,0 +1,160 @@ + + + + + + + EvPeriodic::createStopped + Crea un watcher EvPeriodic detenido + + + &reftitle.description; + + final + public + static + EvPeriodic + EvPeriodic::createStopped + + float + offset + + + float + interval + + + callable + reschedule_cb + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Crea un objeto EvPeriodic. A diferencia del método + EvPeriodic::__construct, este método + no inicia el watcher automáticamente. + + + + &reftitle.parameters; + + + + offset + + + + Ver + modos de operación del watcher periódico + + + + + + interval + + + + Ver los + modos de operación del watcher periódico + + + + + + reschedule_cb + + + + Función de retrollamada Reschedule. Puede pasarse el valor &null;. + Ver los + modos de operación del watcher periódico + + + + + + callback + + + + Ver las + funciones de retrollamada de los Watchers. + + + + + + data + + + + Datos personalizados para asociar con el watcher. + + + + + + priority + + + + Prioridad del Watcher + + + + + + + &reftitle.returnvalues; + + Devuelve un objeto watcher EvPeriodic en caso de éxito. + + + + &reftitle.seealso; + + + EvPeriodic::__construct + + + EvTimer::createStopped + + + + + diff --git a/reference/ev/evperiodic/set.xml b/reference/ev/evperiodic/set.xml new file mode 100644 index 000000000..66c902e4d --- /dev/null +++ b/reference/ev/evperiodic/set.xml @@ -0,0 +1,86 @@ + + + + + + + EvPeriodic::set + Configura el watcher + + + &reftitle.description; + + public + void + EvPeriodic::set + + float + offset + + + float + interval + + + + (Re-)Configura el watcher EvPeriodic. + + + + &reftitle.parameters; + + + + offset + + + + El mismo significado que para el método + EvPeriodic::__construct. + Ver los + modos de operación del watcher periódico + + + + + + interval + + + + El mismo significado que para el método + EvPeriodic::__construct. + Ver los + modos de operación del watcher periódico + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + diff --git a/reference/ev/evprepare.xml b/reference/ev/evprepare.xml new file mode 100644 index 000000000..e5287a3e4 --- /dev/null +++ b/reference/ev/evprepare.xml @@ -0,0 +1,68 @@ + + + + + + La clase EvPrepare + EvPrepare + + +
+ +
+ +
+ &reftitle.classsynopsis; + + + + + EvPrepare + + + + + EvPrepare + + + extends + EvWatcher + + + + + &InheritedProperties; + + &Methods; + + + &InheritedMethods; + + + +
+ + + &reference.ev.entities.evprepare; + + + diff --git a/reference/ev/evprepare/construct.xml b/reference/ev/evprepare/construct.xml index cdec1affe..bff59096c 100644 --- a/reference/ev/evprepare/construct.xml +++ b/reference/ev/evprepare/construct.xml @@ -1,11 +1,10 @@ - + - EvPrepare::__construct - Construye un objeto observador de EvPrepare + Construye un objeto watcher EvPrepare &reftitle.description; @@ -26,9 +25,10 @@ - Construye un objeto observador de EvPrepare e inicia el observador autmáticamente. - Si fuera necesario un observador detenido, considere el empleo de - EvPrepare::createStopped + Construye un objeto watcher EvPrepare. + Inicia el watcher automáticamente. Si se necesita + un watcher detenido, se debe utilizar el método + EvPrepare::createStopped. @@ -40,9 +40,8 @@ - Ver - Retrollamadas de observadores - . + Ver las + retrollamadas de los Watchers. @@ -52,7 +51,7 @@ - Datos personalizados asociados con el observador. + Datos personalizados para asociar con el watcher. @@ -62,7 +61,7 @@ - Prioridad del observador + Prioridad del Watcher diff --git a/reference/ev/evprepare/createstopped.xml b/reference/ev/evprepare/createstopped.xml index 203225c66..7fe659ec3 100644 --- a/reference/ev/evprepare/createstopped.xml +++ b/reference/ev/evprepare/createstopped.xml @@ -1,12 +1,11 @@ - - + EvPrepare::createStopped - Crea una instancia detenida del watcher (testigo) EvPrepare + Crea una instancia detenida del watcher EvPrepare &reftitle.description; @@ -34,9 +33,9 @@ - Crea una instancia detenida del testigo EvPrepare. A diferencia de - EvPrepare::__construct - , este método no inicia el testigo automáticamente. + Crea una instancia detenida del watcher EvPrepare. A diferencia + del método EvPrepare::__construct, + este método no inicia el watcher automáticamente. @@ -48,9 +47,8 @@ - Ver - Retrollamada del testigo - . + Ver las + funciones de retrollamada de los Watchers. @@ -60,7 +58,7 @@ - Datos personalizados asociados con el testigo. + Datos personalizados para asociar con el watcher. @@ -70,7 +68,7 @@ - Prioridad del testigo + Prioridad del Watcher @@ -79,7 +77,7 @@ &reftitle.returnvalues; - Devuelve el objeto EvPrepare en caso de éxito. + Devuelve un objeto EvPrepare en caso de éxito. diff --git a/reference/ev/evsignal.xml b/reference/ev/evsignal.xml new file mode 100644 index 000000000..80fa9b0c7 --- /dev/null +++ b/reference/ev/evsignal.xml @@ -0,0 +1,117 @@ + + + + + + La clase EvSignal + EvSignal + + +
+ &reftitle.intro; + + Los watchers EvSignal lanzarán un evento + cuando el proceso reciba una señal específica una o varias veces. + A pesar de que las señales sean asíncronas, + libev intentará hacer lo posible para + entregar las señales de forma síncrona, es decir, al igual que cualquier + otro evento. + + + No hay límite para el número de watchers para la misma señal, + pero solo en la misma loop, es decir, se puede vigilar + SIGINT en la loop por defecto, y para + SIGIO en otra loop, pero no está permitido vigilar SIGINT tanto en + la loop por defecto como en otra loop al mismo tiempo. + En este momento, SIGCHLD está permanentemente + vinculado a la loop por defecto. + + + Si es posible y está soportado, libev instalará su + manejador con SA_RESTART (o equivalente) activado, + por lo tanto, las llamadas al sistema no deberían ser interrumpidas. En el caso + de un problema con las llamadas al sistema que se vieran interrumpidas por + señales, todas las señales pueden ser bloqueadas en un watcher + EvCheck y desbloqueadas en un watcher + EvPrepare. + +
+ +
+ &reftitle.classsynopsis; + + + + + EvSignal + + + + + EvSignal + + + extends + EvWatcher + + + + &Properties; + + public + signum + + &InheritedProperties; + + &Methods; + + + &InheritedMethods; + + + +
+ +
+ &reftitle.properties; + + + + signum + + + + El número de la señal. Ver las constantes exportadas por la extensión + pcntl. Ver también la página del manual para + signal(7). + + + + +
+ + + + &reference.ev.entities.evsignal; + + + diff --git a/reference/ev/evsignal/construct.xml b/reference/ev/evsignal/construct.xml index 40b1bfe04..3aba80108 100644 --- a/reference/ev/evsignal/construct.xml +++ b/reference/ev/evsignal/construct.xml @@ -1,11 +1,10 @@ - - - + + EvSignal::__construct - Construye el objeto observador EvSignal + Construye un objeto watcher EvSignal &reftitle.description; @@ -34,8 +33,8 @@ - Construye el objeto observador EvSignal y lo inicia automáticamente. Para un - observador periódico detenido, considere la posibilidad de usar + Construye un objeto watcher EvSignal y lo inicia automáticamente. + Para un watcher periódico detenido, utilice en su lugar el método EvSignal::createStopped. @@ -48,10 +47,8 @@ - Número de señal. Ver las constantes exportadas por - la extensión pcntl. - Ver también - la página principal de + Número de la señal. Consulte las constantes exportadas por la extensión + pcntl. Consulte también la página del manual del sistema signal(7). @@ -62,9 +59,8 @@ - Ver - Las llamadas de los observadores - . + Consulte las + funciones de retrollamada de los Watchers. @@ -74,7 +70,7 @@ - Datos personalizados asociados con el observador. + Datos personalizados para asociar con el watcher. @@ -84,7 +80,7 @@ - Prioridad del observador + Prioridad del Watcher @@ -94,12 +90,12 @@ &reftitle.examples; - Manejar la señal SIGTERM + Gestión de una señal SIGTERM stop(); }); diff --git a/reference/ev/evsignal/createstopped.xml b/reference/ev/evsignal/createstopped.xml new file mode 100644 index 000000000..0f0471690 --- /dev/null +++ b/reference/ev/evsignal/createstopped.xml @@ -0,0 +1,130 @@ + + + + + + + EvSignal::createStopped + Crea un objeto watcher EvSignal detenido + + + &reftitle.description; + + final + public + static + EvSignal + EvSignal::createStopped + + int + signum + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Crea un objeto watcher EvSignal detenido. A diferencia del método + EvSignal::__construct, este método + no inicia automáticamente el watcher. + + + + &reftitle.parameters; + + + + signum + + + + Número de la señal. Ver las constantes exportadas por la extensión + pcntl. Ver también la página del manual del sistema + signal(7). + + + + + + callback + + + + Ver las + funciones de retrollamada de los Watchers. + + + + + + data + + + + Datos personalizados para asociar con el watcher. + + + + + + priority + + + + Prioridad del Watcher + + + + + + + &reftitle.returnvalues; + + Devuelve un objeto EvSignal en caso de éxito. + + + + &reftitle.seealso; + + + EvWatcher::start + + + EvSignal::__construct + + + + + diff --git a/reference/ev/evsignal/set.xml b/reference/ev/evsignal/set.xml index 8af24781f..0b66bc144 100644 --- a/reference/ev/evsignal/set.xml +++ b/reference/ev/evsignal/set.xml @@ -1,12 +1,12 @@ - + EvSignal::set - Configura el testigo + Configura el observador &reftitle.description; @@ -20,7 +20,7 @@ - Configura el testigo. + Configura el observador. @@ -32,8 +32,8 @@ - Señal numérica. La misma que para - EvSignal::__construct + Número de la señal. Idéntico al del constructor + EvSignal::__construct. diff --git a/reference/ev/evstat.xml b/reference/ev/evstat.xml new file mode 100644 index 000000000..a2cbf3a64 --- /dev/null +++ b/reference/ev/evstat.xml @@ -0,0 +1,144 @@ + + + + + La clase EvStat + EvStat + + +
+ &reftitle.intro; + + La clase EvStat supervisa + un fichero del sistema de ficheros para detectar cualquier modificación + de sus atributos. Invoca el comando stat() + en esta ruta, a intervalos regulares (o cuando el sistema operativo notifica una modificación) + y verifica si ha sido modificado desde la última vez, llamando a la + función de retrollamada si es el caso. + + + La ruta no necesita existir: el cambio de "la ruta existe" + a "la ruta no existe" es una modificación de estado como cualquier otra. + La condición "la ruta no existe" está indicada por el valor 0 del + elemento 'nlink' (devolvido por el método + EvStat::attr). + + + La ruta no debe terminar con un slash, ni contener componentes + especiales como '.' o ... + La ruta debe ser absoluta: si es relativa, y el directorio de trabajo + cambia, entonces el comportamiento será indefinido. + + + Dado que no hay una interfaz de notificación de cambios portable, + la implementación portable simplemente invoca el comando + stat() en la ruta para verificar las modificaciones. + Para este caso, un intervalo regular puede ser especificado. Si se especifica, + un intervalo de 0.0 (altamente recomendado) entonces + un valor predeterminado no especificado será utilizado (alrededor de 5 segundos, + y puede ser modificado dinámicamente). libev + también impondrá un intervalo mínimo que actualmente está alrededor + de 0.1, lo cual es ampliamente suficiente. + + + Este tipo de observador no está previsto para un gran número de observadores + EvStat, dado que incluso con las notificaciones + del sistema sobre modificaciones soportadas por el sistema operativo, esto consume muchos + recursos. + +
+ +
+ &reftitle.classsynopsis; + + + + + EvStat + + + + + EvStat + + + extends + EvWatcher + + + + &Properties; + + public + path + + + public + interval + + &InheritedProperties; + + &Methods; + + + &InheritedMethods; + + + +
+ +
+ &reftitle.properties; + + + + interval + + + + Solo lectura. La rapidez con la que + una modificación debe ser detectada; normalmente, debe valer + 0.0 para dejar que libev + elija un buen valor. + + + + + + path + + + + Solo lectura. La ruta hacia el fichero + del cual se desean supervisar las modificaciones de estado. + + + + +
+ + + + &reference.ev.entities.evstat; + + + diff --git a/reference/ev/evstat/attr.xml b/reference/ev/evstat/attr.xml new file mode 100644 index 000000000..96704a5e6 --- /dev/null +++ b/reference/ev/evstat/attr.xml @@ -0,0 +1,189 @@ + + + + + + + + EvStat::attr + Devuelve el valor más reciente detectado por Ev + + + &reftitle.description; + + public + array + EvStat::attr + + + + Devuelve un array de los valores más recientes detectados por Ev. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Devuelve un array de los valores más recientes detectados por Ev + (sin el stat actual): + + Lista de claves del array devuelto por el método <methodname>EvStat::attr</methodname> + + + + Clave + Descripción + + + + + + 'dev' + + ID del dispositivo que contiene el fichero + + + + 'ino' + + número de inodos + + + + 'mode' + + protección + + + + 'nlink' + + número de enlaces duros + + + + 'uid' + + ID del usuario del propietario + + + + 'size' + + tamaño total, en bytes + + + + 'gid' + + ID del grupo del propietario + + + + 'rdev' + + ID del dispositivo (si fichero especial) + + + + 'blksize' + + tamaño del bloque para un sistema de ficheros I/O + + + + 'blocks' + + número de bloques 512B asignados + + + + 'atime' + + Fecha/hora del último acceso + + + + 'ctime' + + Fecha/Hora de la última modificación de estado + + + + 'mtime' + + Fecha/hora de la última modificación + + + +
+ + + Consulte la página del manual sobre stat(2) + para más detalles. + + + + &reftitle.examples; + + Monitoreo de cambios en /var/log/messages + +attr(); + + if ($attr['nlink']) { + printf("Tamaño actual: %ld\n", $attr['size']); + printf("atime actual: %ld\n", $attr['atime']); + printf("mtime actual: %ld\n", $attr['mtime']); + } else { + fprintf(STDERR, "¡El fichero `messages` no está presente!"); + $w->stop(); + } +}); + +Ev::run(); +?> +]]> + + + + + &reftitle.seealso; + + + EvStat::prev + + + EvStat::stat + + + + + diff --git a/reference/ev/evstat/construct.xml b/reference/ev/evstat/construct.xml new file mode 100644 index 000000000..0df61bf30 --- /dev/null +++ b/reference/ev/evstat/construct.xml @@ -0,0 +1,151 @@ + + + + + + EvStat::__construct + Construye un objeto EvStat watcher + + + &reftitle.description; + + public + EvStat::__construct + + string + path + + + float + interval + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Construye un objeto EvStat watcher e inicia el watcher automáticamente. + + + + &reftitle.parameters; + + + + path + + + + La ruta de acceso para la cual se espera una modificación de estado. + + + + + + interval + + + + Intervalo de detección de una modificación; debe valer normalmente + 0.0 para dejar que libev + elija el valor adecuado. + + + + + + callback + + + + Ver las + retrollamadas Watcher. + + + + + + data + + + + Datos personalizados para asociar con el watcher. + + + + + + priority + + + + Las prioridades del Watcher + + + + + + + + &reftitle.examples; + + + Monitoreo de cambios en el directorio /var/log/messages + +attr(); + + if ($attr['nlink']) { + printf("Tamaño actual: %ld\n", $attr['size']); + printf("Hora de último acceso: %ld\n", $attr['atime']); + printf("Hora de última modificación: %ld\n", $attr['mtime']); + } else { + fprintf(STDERR, "¡El fichero `messages` no está presente!"); + $w->stop(); + } +}); + +?> +]]> + + + + + diff --git a/reference/ev/evstat/createstopped.xml b/reference/ev/evstat/createstopped.xml new file mode 100644 index 000000000..e1daf9407 --- /dev/null +++ b/reference/ev/evstat/createstopped.xml @@ -0,0 +1,143 @@ + + + + + + + EvStat::createStopped + Crea un objeto EvStat watcher detenido + + + &reftitle.description; + + final + public + static + void + EvStat::createStopped + + string + path + + + float + interval + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Crea un objeto EvStat watcher, pero no lo inicia automáticamente + (a diferencia del método EvStat::__construct). + + + + &reftitle.parameters; + + + + path + + + + La ruta de acceso para la cual se debe esperar un cambio de estado. + + + + + + interval + + + + Intervalo de detección de la modificación; debe normalmente valer + 0.0 para dejar que libev + elija un buen valor. + + + + + + callback + + + + Ver las + funciones de retrollamada Watcher. + + + + + + data + + + + Datos personalizados para asociar con el watcher. + + + + + + priority + + + + las prioridades del Watcher + + + + + + + &reftitle.returnvalues; + + Devuelve un objeto EvStat watcher detenido en caso de éxito. + + + + &reftitle.seealso; + + + EvStat::__construct + + + EvWatcher::start + + + + + diff --git a/reference/ev/evstat/prev.xml b/reference/ev/evstat/prev.xml new file mode 100644 index 000000000..a253a40dd --- /dev/null +++ b/reference/ev/evstat/prev.xml @@ -0,0 +1,66 @@ + + + + + + + EvStat::prev + Devuelve el conjunto anterior devuelto por EvStat::attr + + + &reftitle.description; + + public + void + EvStat::prev + + + + Idéntico al método EvStat::attr + pero devuelve el conjunto anterior de valores. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Devuelve un array con la misma estructura que el array devuelto por + el método EvStat::attr. El array contendrá + los valores detectados previamente. + + + + &reftitle.seealso; + + + EvStat::attr + + + EvStat::stat + + + + + diff --git a/reference/ev/evstat/set.xml b/reference/ev/evstat/set.xml new file mode 100644 index 000000000..960603abe --- /dev/null +++ b/reference/ev/evstat/set.xml @@ -0,0 +1,83 @@ + + + + + + + + EvStat::set + Configura el watcher + + + &reftitle.description; + + public + void + EvStat::set + + string + path + + + float + interval + + + + Configura el watcher. + + + + &reftitle.parameters; + + + + path + + + + La ruta de acceso para la cual se esperará un cambio de estado. + + + + + + interval + + + + Intervalo de detección de modificaciones; debe normalmente valer + 0.0 para dejar que libev + elija un buen valor. + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + diff --git a/reference/ev/evstat/stat.xml b/reference/ev/evstat/stat.xml new file mode 100644 index 000000000..14a56454b --- /dev/null +++ b/reference/ev/evstat/stat.xml @@ -0,0 +1,66 @@ + + + + + + + EvStat::stat + Inicializa la llamada a stat + + + &reftitle.description; + + public + bool + EvStat::stat + + + + Inicializa la llamada a stat (actualización de la caché interna). + El comando llamará a stat (usando lstat) + en la ruta de acceso especificada path en el observador + y establecerá los valores encontrados. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Devuelve &true; si path existe. De lo contrario, &false;. + + + + &reftitle.seealso; + + + EvStat::attr + + + EvStat::prev + + + + + diff --git a/reference/ev/evtimer.xml b/reference/ev/evtimer.xml new file mode 100644 index 000000000..c3d75f052 --- /dev/null +++ b/reference/ev/evtimer.xml @@ -0,0 +1,150 @@ + + + + + La clase EvTimer + EvTimer + + +
+ &reftitle.intro; + + Los observadores EvTimer son observadores relativamente + simples que generan un evento después de un tiempo especificado y, opcionalmente, + se repiten a intervalos regulares. + + + Los temporizadores se basan en tiempo real, por lo que si un temporizador + programa un evento que finaliza después de una hora y se reinicia el reloj del sistema + a enero del año pasado, volverá a estar fuera de tiempo + después de una hora (aproximadamente). "Aproximadamente" porque la detección de + saltos en el tiempo es difícil y ciertas inexactitudes son inevitables. + + + Se garantiza que la función de retrollamada se llamará solo después de que + expire el tiempo de espera máximo (y no exactamente en ese momento preciso, + por lo que en sistemas con una resolución de reloj baja, puede introducirse + un pequeño retraso). Si varios temporizadores están listos durante la misma + iteración del bucle, el que tenga el valor de tiempo de espera máximo más cercano + se invocará antes que otro con la misma prioridad pero con un valor de tiempo + de espera más lejano (aunque esto ya no es cierto cuando una función de retrollamada + llama recursivamente al método EvLoop::run). + + + El temporizador en sí hará todo lo posible para no derivar, pero si un temporizador + está configurado para ejecutarse cada 10 segundos, entonces + normalmente se ejecutará exactamente cada 10 segundos. + Sin embargo, si el script no puede mantener el temporizador porque tarda más + que sus 10 segundos, el temporizador no podrá ejecutarse + más de una vez por iteración del bucle de eventos. + +
+ +
+ &reftitle.classsynopsis; + + + + + EvTimer + + + + + EvTimer + + + extends + EvWatcher + + + + &Properties; + + public + repeat + + + public + remaining + + &InheritedProperties; + + &Methods; + + + &InheritedMethods; + + + +
+ +
+ &reftitle.properties; + + + + repeat + + + + Si esta propiedad vale 0.0, entonces se detendrá automáticamente + una vez alcanzado el tiempo de espera máximo. Si es positivo, entonces el temporizador + se configurará automáticamente para ejecutarse cada segundo siguiente, hasta que + no se detenga manualmente. + + + + + + remaining + + + + Devuelve el tiempo restante antes de que el temporizador se ejecute. + Si el temporizador está activo, entonces este tiempo será relativo al tiempo + del bucle de eventos actual, de lo contrario, será relativo al valor del + tiempo de espera máximo configurado actualmente. + + + Asimismo, después de instanciar un EvTimer + con un valor de after en + 5.0 y un valor de repeat + en 7.0, remaining devolverá + 5.0. Cuando el temporizador se inicia y pasa un + segundo, remaining devolverá + 4.0. Cuando el temporizador expire y se reinicie, + devolverá aproximadamente 7.0 + (probablemente un poco menos, ya que la invocación de la función de retrollamada + también lleva algo de tiempo), y así sucesivamente. + + + + +
+ + + + &reference.ev.entities.evtimer; + + + diff --git a/reference/ev/evtimer/again.xml b/reference/ev/evtimer/again.xml new file mode 100644 index 000000000..8c8991452 --- /dev/null +++ b/reference/ev/evtimer/again.xml @@ -0,0 +1,82 @@ + + + + + + + + EvTimer::again + Reinicia el watcher Timer + + + &reftitle.description; + + public + void + EvTimer::again + + + + Este método funciona como si el Timer hubiera terminado y reinicia su ciclo. + La semántica exacta es: + + + + + si el Timer está en espera, su estado se limpia. + + + + + si el Timer está en ejecución, pero no debe reiniciarse, entonces se detendrá + (como si hubiera terminado normalmente). + + + + + si el Timer debe reiniciarse, el método lo iniciará si es necesario (con el + valor repeat), o reiniciará el Timer al valor de la + variable repeat. + + + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + EvWatcher::stop + + + + + diff --git a/reference/ev/evtimer/construct.xml b/reference/ev/evtimer/construct.xml new file mode 100644 index 000000000..0052b1927 --- /dev/null +++ b/reference/ev/evtimer/construct.xml @@ -0,0 +1,219 @@ + + + + + + EvTimer::__construct + Construye un objeto EvTimer watcher + + + &reftitle.description; + + public + EvTimer::__construct + + float + after + + + float + repeat + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Construye un objeto EvTimer watcher. + + + + &reftitle.parameters; + + + + after + + + + Configura el tiempo para lanzar el trigger después de + after segundos. + + + + + + repeat + + + + Si este argumento vale 0.0, entonces el watcher + se detendrá automáticamente cuando se alcance el tiempo máximo de espera. Si este argumento es positivo, entonces el timer lanzará automáticamente el trigger cada segundo siguiente, hasta que se detenga manualmente. + + + + + + callback + + + + Ver las + funciones de retrollamada Watcher. + + + + + + data + + + + Datos personalizados asociados con el watcher. + + + + + + priority + + + + Las prioridades del Watcher + + + + + + + + &reftitle.examples; + + timers simples + +stop(); + // Detiene el watcher si llamadas posteriores causan más de 10 iteraciones + Ev::iteration() >= 10 and $w->stop(); +}); + +// Crea un timer detenido. Estará inactivo hasta que no se inicie manualmente +$w_stopped = EvTimer::createStopped(10, 5, function($w) { + echo "Función de retrollamada del timer creado detenido\n"; + + // Detiene el watcher después de 2 iteraciones + Ev::iteration() >= 2 and $w->stop(); +}); + +// Bucle mientras Ev::stop() es llamado o mientras todos los watchers no se detienen +Ev::run(); + +// Inicia y bloquea si está en funcionamiento +$w_stopped->start(); +echo "Ejecución de una sola iteración\n"; +Ev::run(Ev::RUN_ONCE); + +echo "Reinicia el segundo watcher y intenta manejar los mismos eventos, pero no bloquea\n"; +$w2->again(); +Ev::run(Ev::RUN_NOWAIT); + +$w = new EvTimer(10, 0, function() {}); +echo "Ejecución de un bucle bloqueante\n"; +Ev::run(); +echo "FIN\n"; +?> +]]> + + &example.outputs.similar; + + + + + + + &reftitle.seealso; + + + EvTimer::createStopped + + + EvPeriodic + + + ev_timer - repetición de un tiempo de espera máximo + + + Ser inteligente con los tiempos de espera máximo + + + + + diff --git a/reference/ev/evtimer/createstopped.xml b/reference/ev/evtimer/createstopped.xml new file mode 100644 index 000000000..ebbe61b0b --- /dev/null +++ b/reference/ev/evtimer/createstopped.xml @@ -0,0 +1,176 @@ + + + + + + + EvTimer::createStopped + Crea un objeto EvTimer watcher detenido + + + &reftitle.description; + + final + public + static + EvTimer + EvTimer::createStopped + + float + after + + + float + repeat + + + callable + callback + + + mixed + data + &null; + + + int + priority + 0 + + + + Crea un objeto EvTimer watcher detenido. A diferencia del método + EvTimer::__construct, este método no + inicia automáticamente el watcher. + + + + &reftitle.parameters; + + + + after + + + + Configura el tiempo para lanzar un trigger después de + after segundos. + + + + + + repeat + + + + Si este parámetro vale 0.0, entonces el watcher + se detendrá automáticamente una vez alcanzado el tiempo máximo de espera. + Si este parámetro es positivo, entonces el timer lanzará automáticamente + el trigger cada segundo siguiente, hasta que se detenga manualmente. + + + + + + callback + + + + Ver las + funciones de retrollamada Watcher. + + + + + + data + + + + Datos personales asociados al watcher. + + + + + + priority + + + + Las prioridades del Watcher + + + + + + + &reftitle.returnvalues; + + Retorna un objeto EvTimer watcher en caso de éxito. + + + + &reftitle.examples; + + Monitoreo de modificaciones en /var/log/messages. + Detecta actualizaciones olvidadas añadiendo un segundo de demora + +stop(); + + $stat = $w->data; + + // 1 segundo después de la modificación más reciente del fichero + printf("Tamaño actual: %ld\n", $stat->attr()['size']); +}); + +$stat = new EvStat("/var/log/messages", 0., function () use ($timer) { + // Reinicia el watcher timer + $timer->again(); +}); + +$timer->data = $stat; + +Ev::run(); +?> +]]> + + + + + &reftitle.seealso; + + + EvTimer::__construct + + + EvPeriodic + + + + + diff --git a/reference/ev/evtimer/set.xml b/reference/ev/evtimer/set.xml new file mode 100644 index 000000000..f105d91df --- /dev/null +++ b/reference/ev/evtimer/set.xml @@ -0,0 +1,84 @@ + + + + + + + EvTimer::set + Configura el observador + + + &reftitle.description; + + public + void + EvTimer::set + + float + after + + + float + repeat + + + + Configura el observador + + + + &reftitle.parameters; + + + + after + + + + Configura el temporizador del trigger para que se lance después de + after segundos. + + + + + + repeat + + + + Si este argumento vale 0.0, entonces el observador será + automáticamente detenido si se alcanza el tiempo de espera máximo. + Si este argumento es positivo, entonces el temporizador lanzará automáticamente + el trigger en cada segundo siguiente, hasta que no sea detenido manualmente. + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + diff --git a/reference/ev/evwatcher.xml b/reference/ev/evwatcher.xml new file mode 100644 index 000000000..4f268741e --- /dev/null +++ b/reference/ev/evwatcher.xml @@ -0,0 +1,143 @@ + + + + + La clase EvWatcher + EvWatcher + + +
+ &reftitle.intro; + + La clase EvWatcher es una clase base + para todos los watchers (EvCheck, EvChild + etc.). Dado que el constructor de la clase EvWatcher + es abstracto, no se puede + (y no se debe) crear objetos EvWatcher directamente. + +
+ +
+ &reftitle.classsynopsis; + + + + + EvWatcher + + + + + abstract + EvWatcher + + + + &Properties; + + public + is_active + + + public + data + + + public + is_pending + + + public + priority + + &Methods; + + + + +
+ +
+ &reftitle.properties; + + + + is_active + + + + Solo lectura. &true; si el watcher está + activo, &false; en caso contrario. + + + + + + data + + + + Datos de usuario personalizados asociados con el watcher + + + + + + is_pending + + + + Solo lectura. Si el watcher está pendiente, + es decir, si el watcher tiene eventos pendientes, pero su función + de retrollamada aún no ha sido llamada, &false; en caso contrario. Mientras el + watcher esté pendiente (pero no activo), otro no puede + modificar sus prioridades. + + + + + + priority + + + + &integer; + Rango de Ev::MINPRI a Ev::MAXPRI. + Los watchers pendientes con una prioridad alta serán llamados + antes que los watchers con una prioridad baja, pero la prioridad no puede + hacer que un watcher nunca sea ejecutado (excepto para los watchers + EvIdle). + Los watchers EvIdle proporcionan funcionalidades + para suprimir la invocación cuando hay eventos con una prioridad + más alta pendientes. + + + + +
+ + + + &reference.ev.entities.evwatcher; + + + diff --git a/reference/ev/evwatcher/clear.xml b/reference/ev/evwatcher/clear.xml new file mode 100644 index 000000000..16190162d --- /dev/null +++ b/reference/ev/evwatcher/clear.xml @@ -0,0 +1,67 @@ + + + + + + + EvWatcher::clear + Borra el estado de espera del observador + + + &reftitle.description; + + public + int + EvWatcher::clear + + + + Si el observador está en espera, este método borra su estado + de espera (pending) y devuelve su bitset + revents (como si su función de retrollamada hubiera sido invocada). + Si el observador no está en espera, este método no hará nada, + y devolverá 0. + + + Algunas veces, es útil interrogar un observador en lugar de esperar + a que su función de retrollamada sea invocada, y esto es precisamente lo que permite + hacer este método. + + + + + &reftitle.parameters; + &no.function.parameters; + + + + &reftitle.returnvalues; + + En el caso de que el observador esté en espera, devuelve el bitset + revents, como si su función de retrollamada fuera invocada. + De lo contrario, devuelve 0. + + + + + diff --git a/reference/ev/evwatcher/construct.xml b/reference/ev/evwatcher/construct.xml new file mode 100644 index 000000000..fce385130 --- /dev/null +++ b/reference/ev/evwatcher/construct.xml @@ -0,0 +1,49 @@ + + + + + + + EvWatcher::__construct + Constructor de objeto observador + + + &reftitle.description; + + abstract + public + EvWatcher::__construct + + + + EvWatcher::__construct es un constructor + de objeto observador, implementado en las clases derivadas. + + + + + &reftitle.parameters; + &no.function.parameters; + + + + diff --git a/reference/ev/evwatcher/feed.xml b/reference/ev/evwatcher/feed.xml new file mode 100644 index 000000000..43ff7dc30 --- /dev/null +++ b/reference/ev/evwatcher/feed.xml @@ -0,0 +1,69 @@ + + + + + + + EvWatcher::feed + Alimenta los revents proporcionados en el bucle de eventos + + + &reftitle.description; + + public + void + EvWatcher::feed + + int + revents + + + + Alimenta los revents proporcionados en el bucle de eventos, + como si el evento especificado hubiera ocurrido en el observador. + + + + &reftitle.parameters; + + + + revents + + + + Máscara de bits del observador + de recepción de eventos. + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + + diff --git a/reference/ev/evwatcher/getloop.xml b/reference/ev/evwatcher/getloop.xml new file mode 100644 index 000000000..5bebd8572 --- /dev/null +++ b/reference/ev/evwatcher/getloop.xml @@ -0,0 +1,55 @@ + + + + + + + + EvWatcher::getLoop + Retorna el bucle responsable del observador + + + &reftitle.description; + + public + EvLoop + EvWatcher::getLoop + + + + Retorna el bucle responsable del observador. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + Retorna un objeto EvLoop + responsable del observador. + + + + + diff --git a/reference/ev/evwatcher/invoke.xml b/reference/ev/evwatcher/invoke.xml new file mode 100644 index 000000000..871941b30 --- /dev/null +++ b/reference/ev/evwatcher/invoke.xml @@ -0,0 +1,68 @@ + + + + + + + EvWatcher::invoke + Invoca la función de retrollamada del observador con la máscara de bits de los eventos recibidos proporcionada + + + &reftitle.description; + + public + void + EvWatcher::invoke + + int + revents + + + + Invoca la función de retrollamada del observador con la máscara de bits de los eventos recibidos proporcionada. + + + + &reftitle.parameters; + + + + revents + + + + Máscara de bits del observador + que recibe los eventos. + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + + diff --git a/reference/ev/evwatcher/keepalive.xml b/reference/ev/evwatcher/keepalive.xml new file mode 100644 index 000000000..6c62ef250 --- /dev/null +++ b/reference/ev/evwatcher/keepalive.xml @@ -0,0 +1,97 @@ + + + + + + + + EvWatcher::keepalive + Mantiene el bucle activo + + + &reftitle.description; + + public + bool + EvWatcher::keepalive + + bool + value + + + + Mantiene el bucle activo. Con un parámetro value + definido a &false;, el Watcher no evitará que los métodos + Ev::run/EvLoop::run + se detengan incluso si el Watcher está activo. + + + Los Watchers tienen, por omisión, un parámetro + value definido a &true;. + + + Limpiar el estado "keepalive" es útil al regresar de los métodos + Ev::run/EvLoop::run, + en cuyo caso el Watcher ya no es deseado. Puede ser un Watcher de socket UDP + que continúa funcionando durante mucho tiempo. + + + + &reftitle.parameters; + + + + value + + + + Si es &false;, el Watcher no evitará que los métodos + Ev::run/EvLoop::run + terminen, incluso si el Watcher está activo. + + + + + + + &reftitle.returnvalues; + + Devuelve el estado anterior. + + + + &reftitle.examples; + + Registra un Watcher E/S para sockets UDP + +keepalive(FALSE); +?> +]]> + + + + + diff --git a/reference/ev/evwatcher/setcallback.xml b/reference/ev/evwatcher/setcallback.xml new file mode 100644 index 000000000..5bf8b77a2 --- /dev/null +++ b/reference/ev/evwatcher/setcallback.xml @@ -0,0 +1,67 @@ + + + + + + + EvWatcher::setCallback + Establece una nueva retrollamada para el watcher + + + &reftitle.description; + + public + void + EvWatcher::setCallback + + callable + callback + + + + Establece una nueva retrollamada para el watcher. + + + + &reftitle.parameters; + + + + callback + + + + Ver las + retrollamadas para los Watchers. + + + + + + + &reftitle.returnvalues; + + &return.void; + + + + diff --git a/reference/ev/evwatcher/start.xml b/reference/ev/evwatcher/start.xml new file mode 100644 index 000000000..b77233f72 --- /dev/null +++ b/reference/ev/evwatcher/start.xml @@ -0,0 +1,62 @@ + + + + + + + + EvWatcher::start + Inicia el Watcher + + + &reftitle.description; + + public + void + EvWatcher::start + + + + Marca el Watcher como activo. Tenga en cuenta que solo los Watchers activos + recibirán los eventos. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + EvWatcher::stop + + + + + diff --git a/reference/ev/evwatcher/stop.xml b/reference/ev/evwatcher/stop.xml new file mode 100644 index 000000000..4ae92ed69 --- /dev/null +++ b/reference/ev/evwatcher/stop.xml @@ -0,0 +1,62 @@ + + + + + + + + EvWatcher::stop + Detiene el Watcher + + + &reftitle.description; + + public + void + EvWatcher::stop + + + + Marca el Watcher como inactivo. Tenga en cuenta que solo los Watchers activos + recibirán los eventos. + + + + &reftitle.parameters; + &no.function.parameters; + + + &reftitle.returnvalues; + + &return.void; + + + + &reftitle.seealso; + + + EvWatcher::start + + + + + diff --git a/reference/ev/examples.xml b/reference/ev/examples.xml new file mode 100644 index 000000000..856e903e3 --- /dev/null +++ b/reference/ev/examples.xml @@ -0,0 +1,439 @@ + + + + + + + &reftitle.examples; + + Ejemplo de temporizadores + +stop(); + // Detiene el watcher si las próximas llamadas provocan más de 10 iteraciones + Ev::iteration() >= 10 and $w->stop(); +}); + +// Crea un temporizador detenido. Permanecerá inactivo hasta que lo iniciemos manualmente +$w_stopped = EvTimer::createStopped(10, 5, function($w) { + echo "Función de retorno de un temporizador creado detenido\n"; + + // Detiene el watcher después de 2 iteraciones + Ev::iteration() >= 2 and $w->stop(); +}); + +// Bucle mientras Ev::stop() no sea llamado o todos los watchers no estén detenidos +Ev::run(); + +// Inicia y verifica si funciona +$w_stopped->start(); +echo "Ejecuta una sola iteración\n"; +Ev::run(Ev::RUN_ONCE); + +echo "Reinicia el segundo watcher e intenta manejar el mismo evento, pero no bloquea\n"; +$w2->again(); +Ev::run(Ev::RUN_NOWAIT); + +$w = new EvTimer(10, 0, function() {}); +echo "Ejecutando un bucle bloqueante\n"; +Ev::run(); +echo "FIN\n"; +?> +]]> + + &example.outputs.similar; + + + + + + Temporizador periódico. Alerta cada 10.5 segundos + + +]]> + + + + Temporizador periódico. Uso de la función de retorno de reprogramación + + + +]]> + + + + Temporizador periódico. Alerta cada 10.5 segundos, comenzando ahora + + +]]> + + + + Espera a que STDIN sea accesible para lectura + + +]]> + + + + Uso de algunas E/S asíncronas para acceder a un socket + +stop(); + // Detiene el watcher write + $w->stop(); + + $in = "HEAD / HTTP/1.1\r\n"; + $in .= "Host: google.co.uk\r\n"; + $in .= "Connection: Close\r\n\r\n"; + + if (!socket_write($socket, $in, strlen($in))) { + trigger_error("Fallo al escribir $in en el socket", E_USER_ERROR); + } + + $read_watcher = new EvIo($socket, Ev::READ, function ($w, $re) + use ($socket, $e_nonblocking) + { + // El socket es accesible para lectura. recv() recibió 20 bytes usando el modo no bloqueante + $ret = socket_recv($socket, $out, 20, MSG_DONTWAIT); + + if ($ret) { + echo $out; + } elseif ($ret === 0) { + // Todo ha sido leído + $w->stop(); + socket_close($socket); + return; + } + + // Se capturan EINPROGRESS, EAGAIN, o EWOULDBLOCK + if (in_array(socket_last_error(), $e_nonblocking)) { + return; + } + + $w->stop(); + socket_close($socket); + }); + + Ev::run(); +}); + +$result = socket_connect($socket, $address, $service_port); + +Ev::run(); +?> +]]> + + &example.outputs.similar; + + + + + + Encapsula un bucle dentro de otro + + +]]> + + + + Encapsula un bucle creado con el backend kqueue en el bucle por defecto + + +]]> + + + + Manejo de la señal SIGTERM + +stop(); +}); + +Ev::run(); +?> +]]> + + + + Monitoreo de cambios en /var/log/messages + +attr(); + + if ($attr['nlink']) { + printf("Tamaño actual: %ld\n", $attr['size']); + printf("atime actual: %ld\n", $attr['atime']); + printf("mtime actual: %ld\n", $attr['mtime']); + } else { + fprintf(STDERR, "¡El fichero `messages` ya no está aquí!"); + $w->stop(); + } +}); + +Ev::run(); +?> +]]> + + + + Monitoreo de cambios en /var/log/messages. Se observan cambios con un segundo de retraso + +stop(); + + $stat = $w->data; + + // 1 segundo después de la última modificación de un fichero + printf("Tamaño actual: %ld\n", $stat->attr()['size']); +}); + +$stat = new EvStat("/var/log/messages", 0., function () use ($timer) { + // Reinicia el watcher timer + $timer->again(); +}); + +$timer->data = $stat; + +Ev::run(); +?> +]]> + + + + Cambio de estado de un proceso + +stop(); + + printf("El proceso %d ha salido con estado %d\n", $w->rpid, $w->rstatus); + }); + + Ev::run(); + + // Protección contra Zombies + pcntl_wait($status); +} else { + // Se bifurca el hijo + exit(2); +} +?> +]]> + + + + + diff --git a/reference/ev/periodic-modes.xml b/reference/ev/periodic-modes.xml new file mode 100644 index 000000000..38a071824 --- /dev/null +++ b/reference/ev/periodic-modes.xml @@ -0,0 +1,122 @@ + + + + + Modos de operación periódica de un watcher + + El watcher EvPeriodic funciona en diferentes + modos según los parámetros offset, + interval y reschedule_cb. + + + + + El modo Temporizador absoluto. En este modo, + interval = 0, + reschedule_cb = &null;. + La llamada se realizará a la hora del reloj offset + y no se repetirá. No se ajustará cuando ocurra un salto en el tiempo, + por lo tanto, si debe ejecutarse el 1 de enero de 2014, + se ejecutará cuando la hora del sistema sea alcanzada o superada. + + + + + El modo Temporizador con repetición por intervalo. + En este modo, interval > 0, + reschedule_cb = &null; ; el watcher será programado + automáticamente para finalizar en la próxima duración + offset + N * interval + (para un entero N) y luego se repite, independientemente + de los saltos en el tiempo. + + + Puede utilizarse para crear temporizadores que no derivan respetando + el reloj del sistema: + + +]]> + + Esto no significa que siempre habrá 3600 segundos + entre cada llamada, sino solo que la función de retrollamada será llamada + cuando el reloj del sistema muestre una hora completa (UTC). + + + La clase EvPeriodic intentará ejecutar la función + de retrollamada en este modo a la próxima hora posible donde + time = offset (mod + interval), independientemente de los saltos en el tiempo. + + + + + El modo reprogramación manual. En este modo, + reschedule_cb es un callable. + + + interval y offset + serán ambos ignorados. En su lugar, cada vez que el watcher periódico + esté programado, la función de retrollamada de reprogramación (reschedule_cb) + será llamada con el watcher primero y el tiempo actual como segundo argumento. + + + Esta función de retrollamada no debe detener ni destruir + este watcher periódico, ni otro, y no debe + llamar a funciones o métodos de bucle de eventos. Para detenerlo, + devuelva 1e30 y deténgalo después. Un watcher + EvPrepare puede ser utilizado para realizar esta tarea. + + + Debe devolver la próxima hora de llamada, basada en el valor + del tiempo pasado (el valor de tiempo más pequeño debe ser superior + o igual al segundo argumento). Será llamada, habitualmente, justo después + de que la función de retrollamada sea lanzada, pero posiblemente en otros momentos. + + + Utilización de retrollamada de reprogramación + + +]]> + + + + + + diff --git a/reference/ev/reference.xml b/reference/ev/reference.xml index 834c872cb..7ddd2da81 100644 --- a/reference/ev/reference.xml +++ b/reference/ev/reference.xml @@ -1,9 +1,10 @@ - - + + + - &Functions; de Ev + &Functions; Ev &reference.ev.entities.functions; diff --git a/reference/ev/setup.xml b/reference/ev/setup.xml index c3016dee6..37afca030 100644 --- a/reference/ev/setup.xml +++ b/reference/ev/setup.xml @@ -1,16 +1,15 @@ - - - + + + &reftitle.setup;
&reftitle.required; - La biblioteca libev - está embebida en esta extensión. No es necesario instalarla - por separado. + La biblioteca libev está incluida en + esta extensión. No es necesario instalarla por separado.
@@ -20,19 +19,11 @@ &pecl.info; - &url.pecl.package;ev - . + &url.pecl.package;ev.
-
- &reftitle.runtime; - &no.config; -
-
- &reftitle.resources; - &no.resource; -
+ + + + + Las funciones de retrollamada de un Watcher + + Todos los watchers pueden estar activos (esperando eventos) o inactivos + (en pausa). Solo los watchers activos pueden tener sus funciones de retrollamada + llamadas. Todas las funciones de retrollamada serán llamadas con al menos dos + argumentos: + watcher - el watcher, y revents, + una máscara de eventos recibidos. + + + Las funciones de retrollamada de los watchers son pasadas a los constructores de los watchers + (una clase derivada de EvWatcher - + EvCheck::__construct, EvChild::__construct + etc.). Una función de retrollamada de un watcher debe coincidir con el siguiente prototipo: + + + void + callback + + object + watcher + NULL + + + int + revents + NULL + + + + + + + watcher + + + + La instancia del watcher (de una clase que extiende EvWatcher). + + + + + + revents + + + + Un watcher que recibe los eventos. + + + + + + + Cada tipo de watcher tiene un byte asociado en + revents, por lo tanto, se puede utilizar la misma + función de retrollamada para varios watchers. La máscara de eventos + se nombra según el tipo, es decir, + EvChild (o EvLoop::child) define + EV::CHILD, EvPrepare (o + EvLoop::prepare) define Ev::PREPARE, + EvPeriodic (o EvLoop::periodic) + define Ev::PERIODIC y así sucesivamente, con la excepción de los + eventos de E/S (que pueden definir tanto los bytes + Ev::READ como Ev::WRITE). + + + + diff --git a/reference/ev/watchers.xml b/reference/ev/watchers.xml new file mode 100644 index 000000000..9be9a10d6 --- /dev/null +++ b/reference/ev/watchers.xml @@ -0,0 +1,64 @@ + + + + + + Watchers + + Un watcher es un objeto creado para registrar particularidades de un evento. + Por ejemplo, el código siguiente espera que + STDIN se vuelva accesible en lectura: + + +]]> + + + + Todos los constructores de los watchers inician automáticamente los watchers. + El método createStopped detiene un watcher (i.e. + EvIo::createStopped). + + + Tenga en cuenta que un watcher se detendrá automáticamente cuando el objeto watcher sea + destruido. Sin embargo, los objetos watchers devueltos por los constructores + o los métodos de fábrica serán conservados. + + + Tenga en cuenta también que todos los métodos que modifican las propiedades + de un watcher (set, priority etc.) + detienen y reinician automáticamente el watcher si está activo, lo que + significa que los eventos pendientes se perderán. + + + Ver también: + Las funciones de retrollamada de los Watchers. + + + +