cvs: phpdoc-fr /reference/stream reference.xml /reference/stream/functions stream-context-create.xml stream-context-get-options.xml
stream-context-set-option.xml stream-context-set-params.xml stream-filter-append.xml stream-filter-prepend.xml stream-get-filters.xml
stream-get-meta-data.xml stream-get-wrappers.xml stream-register-filter.xml stream-register-wrapper.xml stream-select.xml stream-set-blocking.xml
stream-set-timeout.xml stream-set-write-buffer.xml

From:	Damien Seguy	Date:	Mon, 13 Jan 2003 19:56:56 +0000
Subject:	cvs: phpdoc-fr /reference/stream reference.xml /reference/stream/functions stream-context-create.xml stream-context-get-options.xml stream-context-set-option.xml stream-context-set-params.xml stream-filter-append.xml stream-filter-prepend.xml stream-get-filters.xml stream-get-meta-data.xml stream-get-wrappers.xml stream-register-filter.xml stream-register-wrapper.xml stream-select.xml stream-set-blocking.xml stream-set-timeout.xml stream-set-write-buffer.xml
Groups:	php.doc.fr
Request:	Send a blank email to doc-fr+get-151@lists.php.net to get a copy of this message

dams Mon Jan 13 14:56:56 2003 EDT Added files: /phpdoc-fr/reference/stream reference.xml /phpdoc-fr/reference/stream/functions stream-context-create.xml stream-context-get-options.xml stream-context-set-option.xml stream-context-set-params.xml stream-filter-append.xml stream-filter-prepend.xml stream-get-filters.xml stream-get-meta-data.xml stream-get-wrappers.xml stream-register-filter.xml stream-register-wrapper.xml stream-select.xml stream-set-blocking.xml stream-set-timeout.xml stream-set-write-buffer.xml Log: adding streams transaltion

Index: phpdoc-fr/reference/stream/reference.xml +++ phpdoc-fr/reference/stream/reference.xml <?xml version="1.0" encoding="iso-8859-1"?>  <reference id="ref.stream"> <title>Flôts</title> <titleabbrev>Flôts</titleabbrev> <partintro> <section id="stream.intro"> &reftitle.intro; <simpara> Les flôts ("streams" en anglais) on été introduits en &php; 4.3.0 comme méthode de généralisation des fichiers, sockets, connexions réseau, données compressées et autres opérations du même type, qui partagent des opérations communes. Dans sa définition la plus simple, un flôt est une ressource qui présente des capacités de flux : c'est à dire que ces objets peuvent être lus ou recevoir des écritures de manière linéaire, et dispose aussi de moyen d'accèder à des positions arbitraires dans le flux. </simpara> <simpara> Un gestionnaire (dit <literal>wrapper</literal> en anglais), est une fonction qui indique comment le flôt se comporte spécifiquement. C'est le cas du gestionnaire <literal>http</literal>, qui sait comment traduire une URL en une requête sur un serveur distant. Il existe de nombreux gestionnaires intégré à &php; par défaut (voir <xref linkend="wrappers"/>), et de plus, des gestionnaires spécifiques peuvent être ajouté dans les scripts &php; avec la fonction <function>stream_register_wrapper</function>, ou bien directement par une autre extension, en utilisant l'API C de <xref linkend="streams"/>. Grâce à la souplesse des gestionnaires qui peuvent être ajoutés à &php;, il n'y a pas de limites aux possibilités offertes. Pour connaître la liste des gestionnaires actuellement enregistrés, utilisez la fonction <function>stream_get_wrappers</function>. </simpara> <simpara> Un <literal>filtre</literal> est une fonction finale qui effectue des opérations sur les données qui sont lues ou écrites dans un flôt. Un nombre arbitraire de filtre peuvent être ajoutés sur un flôt. Des filtres personnalisés peuvent aussi être ajoutés avec la fonction <function>stream_register_filter</function>, ou bien dans une extension avec l'API C de <xref linkend="streams"/>. Pour connaître la liste des gestionnaires actuellement enregistrés, utilisez la fonction <function>stream_get_filters</function>. </simpara> <para> Un flôt est identifié dans la forme <parameter>protocole</parameter>://<parameter>serveur</parameter> <itemizedlist> <listitem> <simpara> <parameter>protocole</parameter>(&string;) - Le nom du protocole utilisé. Par exemple : file, http, https, ftp, ftps, compress.zlib, compress.bz2, ssl, tls et php. Voyez <xref linkend="wrappers"/> pour une liste de gestionnaires intégrés à &php;. Si aucun gestionnaire n'est spécifié, la fonction utilise par défaut <literal>file</literal>://). </simpara> </listitem> <listitem> <simpara> <parameter>serveur</parameter> - Dépend du gestionnaire utilisé. Pour les flôts liés au système de fichier, c'est généralement un chemin et un nom de fichier. Pour les objets réseau, c'est généralement un nom de serveur, et un chemin. Encore une fois, reportez vous à <xref linkend="wrappers"/> pour une description des différents serveurs de gestionnaire. </simpara> </listitem> </itemizedlist> </para> </section> <section id="stream.requirements"> &reftitle.required; &no.requirement; </section> <section id="stream.installation"> &reftitle.install; <para> Les flôts font partie de &php; depuis la version 4.3.0. Aucune étape supplémentaire n'est requise pour les activer. </para> </section> <section id="stream.configuration"> &reftitle.runtime; &no.config; </section> <section id="stream.resources"> <title>Stream Classes</title> <simpara> Des gestionnaires personnalisés peuvent être enregistrés via la fonction <function>stream_register_wrapper</function>, en utilisant la définition de classe décrite dans ce manuel. </simpara> <simpara> La classe php_user_filter est prédéfinie et est une classe abstraite à utiliser avec les filtres personnalisés. Voyez le manuel de la fonction <function>stream_register_filter</function> pour plus de détails sur les implémentation de filtres utilisateurs. </simpara> </section> <section id="stream.constants"> &reftitle.constants; <para> <informaltable> <tgroup cols="2"> <thead> <row> <entry>Constante</entry> <entry>Description</entry> </row> </thead> <tbody> <row> <entry><constant>STREAM_USE_PATH</constant></entry> <entry><literal>Flag</literal> indique si le flôt fait partie de l'include_path. </entry> </row> <row> <entry><constant>STREAM_REPORT_ERRORS</constant></entry> <entry><literal>Flag</literal> indiquant si le gestionnaire est responsable de la levée des erreurs via <function>trigger_error</function> durant les opérations de flôts. Si cette option n'est pas activé, vous ne pourrez pas générer d'erreurs. </entry> </row> </tbody> </tgroup> </informaltable> </para> </section> <section id="stream.errors"> <title>Erreurs de flôts</title> <para> Comme avec n'importe quel fichier ou socket, les opérations sur un flôt peuvent échouer pour une grande variété de raisons (par exemple : impossible de se connecter au serveur distant, fichier introuvable, etc...). Un flôt peut aussi échouer parceque le gestionnaire n'est pas configuré sur le système en cours. Voyez le tableau retourné par la fonction <function>stream_get_wrappers</function> pour connaître la liste des gestionnaires configurés sur votre installation de &php;. Comme avec la plus part des fonctions internes de &php;, si une erreur survient, un message de type <constant>E_WARNING</constant> sera généré pour indiquer la nature de l'erreur. </para> </section> <section id="stream.examples"> &reftitle.examples; <para> <example> <title>Exemples avec <function>file_get_contents</function></title> <programlisting role="php"> <![CDATA[ <?php // Lit un fichier local dans le dossier /home/bar $localfile = file_get_contents("/home/bar/foo.txt"); // Identique au précédent, mais utilise explicitement le gestionnaire FILE $localfile = file_get_contents("file:///home/bar/foo.txt"); // Lit un fichier distant sur le serveur www.exemple.com avec le protocole HTTP $httpfile = file_get_contents("http://www.exemple.com/foo.txt"); // Lit le même fichier sur le serveur www.exemple.com avec le protocole HTTPS $httpsfile = file_get_contents("https://www.exemple.com/foo.txt"); // Lit un fichier distant sur le serveur ftp.exemple.com en utilisant le protocole FTP $ftpfile = file_get_contents("ftp://user:pass@ftp.example.com/foo.txt"); // Lit un fichier distant sur le serveur ftp.exemple.com en utilisant le protocole FTPS $ftpsfile = file_get_contents("ftps://user:pass@ftp.example.com/foo.txt"); ?> ]]> </programlisting> </example> </para> <para> <example> <title>Envoie d'une requête de type POST sur une serveur sécurisé</title> <programlisting role="php"> <![CDATA[ <?php /* Envoi d'une requête POST sur le serveur https://secure.example.com/form_action.php * Inclusion des variables "foo" et "bar" */ $sock = fsockopen("ssl://secure.example.com", 443, $errno, $errstr, 30); if (!$sock) die("$errstr ($errno)\n"; $data = "foo=" . urlencode("Valeur de Foo") . "&bar=" . urlencode("Valeur de Bar"); fputs($sock, "POST /form_action.php HTTP/1.0\r\n"); fputs($sock, "Host: secure.example.com\r\n"); fputs($sock, "Content-type: application/x-www-url-encoded\r\n"); fputs($sock, "Content-length: " . strlen($data) . "\r\n"); fputs($sock, "Accept: */*\r\n"); fputs($sock, "\r\n"); fputs($sock, "$data\r\n"); fputs($sock, "\r\n"); $headers = ""; while ($str = trim(fgets($sock, 4096))) $headers .= "$str\n"; print "\n"; $body = ""; while (!feof($sock)) $body .= fgets($sock, 4096); fclose($sock); ?> ]]> </programlisting> </example> </para> <para> <example> <title>Ecrire des données dans un fichier compressé</title> <programlisting role="php"> <![CDATA[ <?php /* Création d'un fichier compressé contenant une chaîne arbitraire * Le fichier peut être lu en utilisant le gestionnaire compress.zlib * ou simplement décompressé en ligne de commande avec 'gzip -d foo-bar.txt.gz' */ $fp = fopen("compress.zlib://foo-bar.txt.gz","w"); if (!$fp) die("Impossible de créer le fichier."); fwrite($fp, "Ceci est un test.\n"); fclose($fp); ?> ]]> </programlisting> </example> </para> </section> </partintro> &reference.stream.functions; </reference>  Index: phpdoc-fr/reference/stream/functions/stream-context-create.xml +++ phpdoc-fr/reference/stream/functions/stream-context-create.xml <?xml version="1.0" encoding="iso-8859-1"?>  <refentry id="function.stream-context-create"> <refnamediv> <refname>stream_context_create</refname> <refpurpose>Crée un contexte de flôt</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>resource</type><methodname>stream_context_create</methodname> <methodparam><type>array</type><parameter>params</parameter></methodparam> </methodsynopsis> <simpara> <methodname>stream_context_create</methodname> crée et retourne un contexte de flôt, avec les paramètres fournis par <parameter>params</parameter>. </simpara> <simpara> Voir aussi <function>stream_context_set_params</function>. </simpara> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-context-get-options.xml +++ phpdoc-fr/reference/stream/functions/stream-context-get-options.xml <?xml version="1.0" encoding="iso-8859-1"?>  <refentry id="function.stream-context-get-options"> <refnamediv> <refname>stream_context_get_options</refname> <refpurpose>Lit la valeur des options pour un flôt/wrapper/contexte</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>bool</type><methodname>stream_context_get_options</methodname> <methodparam><type>resource</type><parameter>stream|context</parameter></methodparam> </methodsynopsis> <simpara> <function>stream_context_get_options</function> retourne un tableau contenant la liste des options pour le flôt ou le contexte <parameter>stream|context</parameter>. </simpara> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-context-set-option.xml +++ phpdoc-fr/reference/stream/functions/stream-context-set-option.xml <?xml version="1.0" encoding="iso-8859-1"?>  <refentry id="function.stream-context-set-option"> <refnamediv> <refname>stream_context_set_option</refname> <refpurpose>Configure une option pour un flôt/wrapper/contexte</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>bool</type><methodname>stream_context_set_option</methodname> <methodparam><type>resource</type><parameter>context|stream</parameter></methodparam> <methodparam><type>string</type><parameter>wrapper</parameter></methodparam> <methodparam><type>string</type><parameter>option</parameter></methodparam> <methodparam><type>mixed</type><parameter>value</parameter></methodparam> </methodsynopsis> <simpara> <function>stream_context_set_option</function> configure l'option <parameter>option</parameter> avec la nouvelle valeur <parameter>value</parameter> le flôt ou le wrapper ou le contexte <parameter>wrapper</parameter>. </simpara> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-context-set-params.xml +++ phpdoc-fr/reference/stream/functions/stream-context-set-params.xml <?xml version="1.0" encoding="iso-8859-1"?>  <refentry id="function.stream-context-set-params"> <refnamediv> <refname>stream_context_set_params</refname> <refpurpose>Configure les paramètres pour un flôt/wrapper/contexte</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>bool</type><methodname>stream_context_set_params</methodname> <methodparam><type>resource</type><parameter>stream|context</parameter></methodparam> <methodparam><type>array</type><parameter>params</parameter></methodparam> </methodsynopsis> <simpara> <methodname>stream_context_set_params</methodname> configure les paramètres pour un flôt, un wrapper ou un contexte. </simpara> <simpara> <parameter>params</parameter> doit être un tableau associatif avec la structure suivante : <literal>$params['nom_parametre'] = "valeur_parametre";</literal>. </simpara> <table> <title>Paramètres</title> <tgroup cols="2"> <thead> <row> <entry>Paramètres</entry> <entry>Usage</entry> </row> </thead> <tbody> <row> <entry><literal>notification</literal></entry> <entry> Nom de la focntion utilisateur appelée dès qu'un flôt génère une notification. </entry> </row> </tbody> </tgroup> </table> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-filter-append.xml +++ phpdoc-fr/reference/stream/functions/stream-filter-append.xml <?xml version="1.0" encoding="iso-8859-1"?>  <refentry id="function.stream-filter-append"> <refnamediv> <refname>stream_filter_append</refname> <refpurpose>Attache un filtre à un flôt en fin de liste</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>bool</type><methodname>stream_filter_append</methodname> <methodparam><type>resource</type><parameter>stream</parameter></methodparam> <methodparam><type>string</type><parameter>filtername</parameter></methodparam> <methodparam choice="opt"><type>string</type><parameter>params</parameter></methodparam> </methodsynopsis> <para> <function>stream_filter_append</function> ajoute le filtre <parameter>filtername</parameter> à la liste de filtres attachés au flôt <parameter>stream</parameter>. Ce filtre sera ajoutés avec les paramètres spécifiés dans <parameter>params</parameter> à la <emphasis>fin</emphasis> de cette liste et sera donc appelé en dernier durant les opérations de flôts. Pour ajouter un filtre au début de la liste, utilisez la fonction <function>stream_filter_prepend</function>. </para> <note> <simpara> <function>stream_register_filter</function> doit être appelé avant <function>stream_filter_append</function> pour enregistrer le filtre sous le nom de <parameter>filtername</parameter>. </simpara> </note> <simpara> Voir aussi <function>stream_register_filter</function> et <function>stream_filter_prepend</function> </simpara> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-filter-prepend.xml +++ phpdoc-fr/reference/stream/functions/stream-filter-prepend.xml <?xml version="1.0" encoding="iso-8859-1"?>  <refentry id="function.stream-filter-prepend"> <refnamediv> <refname>stream_filter_prepend</refname> <refpurpose>Attache un filtre à un flôt en début de liste</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>bool</type><methodname>stream_filter_prepend</methodname> <methodparam><type>resource</type><parameter>stream</parameter></methodparam> <methodparam><type>string</type><parameter>filtername</parameter></methodparam> <methodparam choice="opt"><type>string</type><parameter>params</parameter></methodparam> </methodsynopsis> <para> <function>stream_filter_prepend</function> ajoute le filtre <parameter>filtername</parameter> à la liste de filtres attachés au flôt <parameter>stream</parameter>. Ce filtre sera ajoutés avec les paramètres spécifiés dans <parameter>params</parameter> à la <emphasis>fin</emphasis> de cette liste et sera donc appelé en dernier durant les opérations de flôts. Pour ajouter un filtre à la fin de la liste, utilisez la fonction <function>stream_filter_prepend</function>. </para> <note> <simpara> <function>stream_register_filter</function> doit être appelé avant <function>stream_filter_prepend</function> pour enregistrer le filtre sous le nom de <parameter>filtername</parameter>. </simpara> </note> <simpara> Voir aussi <function>stream_register_filter</function> et <function>stream_filter_append</function> </simpara> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-get-filters.xml +++ phpdoc-fr/reference/stream/functions/stream-get-filters.xml <?xml version="1.0" encoding="iso-8859-1"?>  <refentry id="function.stream-get-filters"> <refnamediv> <refname>stream_get_filters</refname> <refpurpose>Liste les filtres enregistrés</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>array</type><methodname>stream_get_filters</methodname> <void/> </methodsynopsis> <simpara> <methodname>stream_get_filters</methodname> retourne un tableau indexé contenant la liste des filtres de flôts disponibles sur le système. </simpara> <para> <example> <title>Exemple avec la fonction <function>stream_get_filters</function></title> <programlisting role="php"> <![CDATA[ <?php $streamlist = stream_get_filters(); print_r($streamlist); /* L'affichage sera semblable a ce qui suit. Note: il peut y avoir plus ou moins de filtres suivant votre version de PHP --------------------------------------- Array ( [0] => string.rot13 [1] => string.toupper [2] => string.tolower [3] => string.base64 [4] => string.quoted-printable ) */ ?> ]]> </programlisting> </example> </para> <para> Voir aussi <function>stream_register_filter</function> et <function>stream_get_wrappers</function> </para> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-get-meta-data.xml +++ phpdoc-fr/reference/stream/functions/stream-get-meta-data.xml <?xml version="1.0" encoding="iso-8859-1"?>  <refentry id="function.stream-get-meta-data"> <refnamediv> <refname>stream_get_meta_data</refname> <refpurpose>Lit les entêtes et données méta des flôts</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>array</type><methodname>file_get_meta_data</methodname> <methodparam><type>resource</type><parameter>stream</parameter></methodparam> </methodsynopsis> <simpara> <methodname>file_get_meta_data</methodname> retourne les informations disponibles sur le flôt <parameter>stream</parameter>. Ce flôt peut être n'importe quel flôt créé par <function>fopen</function>, <function>fsockopen</function> et <function>pfsockopen</function>. Le tableau résultant peut contenir les éléments suivants : </simpara> <itemizedlist> <listitem> <para> <parameter>timed_out</parameter> (&boolean;) - &true; si le flôt a atteint de délai d'expiration en attendant des données durant le dernier appel aux fonctions <function>fread</function> et <function>fgets</function>. </para> </listitem> <listitem> <para> <parameter>blocked</parameter> (&boolean;) - &true; si le flôt est en mode bloquant. Voir aussi <function>socket_set_blocking</function>. </para> </listitem> <listitem> <para> <parameter>eof</parameter> (&boolean;) - &true; si le flôt a atteint la fin du fichier. Notez que pour les sockets, cette valeur peut être &true; même si <parameter>unread_bytes</parameter> est non nul. Pour déterminer si il reste des données à lire, utilisez plutôt la fonction <function>feof</function>. </para> </listitem> <listitem> <para> <parameter>unread_bytes</parameter> (&integer;) - le nombre d'octets actuellement placés dans le buffer de lecture. </para> </listitem> </itemizedlist> <simpara> Les éléments suivants ont été ajoutés en PHP 4.3 : </simpara> <itemizedlist> <listitem> <para> <parameter>stream_type</parameter> (&string;) - un nom, qui décrit l'implémentation sous-jacente de flôt. </para> </listitem> <listitem> <para> <parameter>wrapper_type</parameter> (&string;) - un nom qui décrit le gestionnaire de protocole pour ce flôt. Voyez <xref linkend="wrappers"/> pour plus d'informations sur les gestionnaires. </para> </listitem> <listitem> <para> <parameter>wrapper_data</parameter> (mixed) - des données spécifiques au gestionnaire liés à ce flôt. Voyez <xref linkend="wrappers"/> pour plus d'informations sur les gestionnaires et leurs données. </para> </listitem> <listitem> <para> <parameter>filters</parameter> (&array;) - un tableau contenant les noms de tous les fitres qui ont été attachés à ce flôt. Les filtres sont actuellements non documentés. </para> </listitem> </itemizedlist> <note> <para> Cette fonction a été introduite en PHP 4.3, mais avant cette version, <function>socket_get_status</function> était utilisée pour lire les 4 premiers éléments, <emphasis>uniquement pour les sockets</emphasis>. </para> <para> En PHP 4.3 et plus récent, <function>socket_get_status</function> est un alias de cette fonction. </para> </note> <note> <simpara> Cette fonction n'est pas utilisable avec les sockets créées par les fonctions de l'extension <link linkend="ref.sockets">socket</link>. </simpara> </note> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-get-wrappers.xml +++ phpdoc-fr/reference/stream/functions/stream-get-wrappers.xml <?xml version="1.0" encoding="iso-8859-1"?>  <refentry id="function.stream-get-wrappers"> <refnamediv> <refname>stream_get_wrappers</refname> <refpurpose>Liste les gestionnaires de flôts</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>array</type><methodname>stream_get_wrappers</methodname> <void/> </methodsynopsis> <para> <methodname>stream_get_wrappers</methodname> retourne un tableau indexé contenant le nom de tous les gestionaires de flôts disponibles sur le système. </para> <para> Voir aussi <function>stream_register_wrapper</function>. </para> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-register-filter.xml +++ phpdoc-fr/reference/stream/functions/stream-register-filter.xml <?xml version="1.0" encoding="iso-8859-1"?>  <refentry id="function.stream-register-filter"> <refnamediv> <refname>stream_register_filter</refname> <refpurpose>Enregistre un filtre de flôt</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>boolean</type><methodname>stream_register_filter</methodname> <methodparam><type>string</type><parameter>filtername</parameter></methodparam> <methodparam><type>string</type><parameter>classname</parameter></methodparam> </methodsynopsis> <para> <function>stream_register_filter</function> vous permet d'implémenter votre propre filtre de flôt, à utiliser avec les fonctions d'accès aux données externes (comme <function>fopen</function>, <function>fread</function>, etc...). </para> <para> Pour ce faire, vous devez définir une classe qui étend la classe <literal>php_user_fitler</literal> avec les membres et méthodes définies ci-dessous. Lorsque vous réalisez des opérations de lecture et d'écriture dans le flôt auquel votre filtre est attaché, &php; passera les données à travers votre filtre (et tous les autres filtres attachés), de façon à ce que les données soient modifiées telles que désiré. Vous devez implémenter les méthodes telles que décrit ci-dessous, sous peine de comportement indéfini. </para> <para> <function>stream_register_filter</function> retourne &false; si le nom de filtre <parameter>filtername</parameter> est déjà utilisé. </para> <methodsynopsis> <type>int</type><methodname>write</methodname> <methodparam><type>string</type><parameter>data</parameter></methodparam> </methodsynopsis> <para> Cette méthode est appelée dès que les données sont écrite dans le flôt, comme avec la fonction <function>fwrite</function>. Après la modification des données <parameter>data</parameter>, cette méthode doit utiliser la ligne suivante <literal>return parent::write($data);</literal> pour que le prochain filtre puisse s'exécuter. Lorsqu'il ne reste plus de filtres, le flôt va écrire les données <parameter>data</parameter> dans leur forme finale. <note> <para> Si votre filtre modifie la taille de la chaîne <parameter>data</parameter>, par exemple en supprimant le premier caractère, il faut, avant d'utiliser la fonction <literal>parent::write($data);</literal>, s'assurer d'inclure le caractère supprimé dans la valeur de retour. </para> </note> <informalexample> <programlisting role="php"> <![CDATA[ class myfilter extends php_user_filter { function write($data) { $data = substr($data,1); $written_by_parent = parent::write($data); return ($written_by_parent + 1); } } ]]> </programlisting> </informalexample> </para> <methodsynopsis> <type>string</type><methodname>read</methodname> <methodparam><type>int</type><parameter>maxlength</parameter></methodparam> </methodsynopsis> <para> Cette méthode est appelée dès que des données sont lues dans le flôt (comme avec la fonction <function>fread</function>). Un filtre doit commencer par utiliser la ligne <literal>parent::read($maxlength);</literal> pour lire les données issue du filtre précédent. Ultimement, ce sera le flôt qui lira les données. Votre filtre peut alors modifier cette valeur et retourner la valeur finale. Votre filtre ne doit jamais retourner plus de <parameter>maxlength</parameter> octets. Comme <literal>parent::read($maxlength);</literal> ne retournera aussi pas plus de <parameter>maxlength</parameter>, ce ne sera pas un problème en règle général. Cependant, si votre filtre accroit la taille des données retournées, il faut alors appeler cette ligne avec <literal>parent::read($maxlength-$x);</literal> où <parameter>x</parameter> est l'accroissement maximal de vos données. Alternativement, vous pouvez bâtir un buffer de lecture dans votre classe. </para> <methodsynopsis> <type>int</type><methodname>flush</methodname> <methodparam><type>bool</type><parameter>closing</parameter></methodparam> </methodsynopsis> <para> Cette méthode est appelée en réponse à une requête de vidage des buffers du flôt (comme avec la fonction <function>fflush</function> ou <function>fclose</function>). Le paramètre <parameter>closing</parameter> vous indique si le flôt est, en réalité, dans un processus de fermeture. L'action par défaut est d'appeler simplement <literal>return parent::flush($closing);</literal>, mais votre filtre peut souhaiter exécuter des écritures supplémentaires, ou bien nettoyer des ressources avant de réaliser le vidage en règle. </para> <methodsynopsis> <type>void</type><methodname>oncreate</methodname> <void/> </methodsynopsis> <para> Cette méthode est appelée durant l'instantiation du filtre. Si votre filtre alloue ou initialise d'autres ressources (comme des buffers), c'est le moment de le faire. </para> <methodsynopsis> <type>void</type><methodname>onclose</methodname> <void/> </methodsynopsis> <para> Cette méthode est appelée durant l'extinction du filtre (généralement, lorsque le flôt est fermé), et est exécuté <emphasis>après</emphasis> l'appel de la fonction <literal>flush</literal>. Si aucune ressource a été allouée ou créée durant <literal>oncreate()</literal>, c'est le moment de les libérer. </para> <para> L'exemple ci-dessous implémente un filtre appelé <literal>rot13</literal>, sur le flôt <literal>foo-bar.txt</literal>, qui réalise un chiffrement de type ROT-13 sur toutes les lettres lue ou écrite dans le flôt. <example> <title>Filtre ROT13 pour les flôts</title> <programlisting role="php"> <![CDATA[ <?php /* Definition de notre classe de filtre */ class rot13_filter extends php_user_filter { function read($length) { $tempstr = parent::read($length); for($i = 0; $i < strlen($tempstr); $i++) if (($tempstr[$i] >= 'A' AND $tempstr[$i] <= 'M') OR ($tempstr[$i] >= 'a' AND $tempstr[$i] <= 'm')) $tempstr[$i] = chr(ord($tempstr[$i]) + 13); else if (($tempstr[$i] >= 'N' AND $tempstr[$i] <= 'Z') OR ($tempstr[$i] >= 'n' AND $tempstr[$i] <= 'z')) $tempstr[$i] = chr(ord($tempstr[$i]) - 13); return $tempstr; } function write($data) { for($i = 0; $i < strlen($data); $i++) if (($data[$i] >= 'A' AND $data[$i] <= 'M') OR ($data[$i] >= 'a' AND $data[$i] <= 'm')) $data[$i] = chr(ord($data[$i]) + 13); else if (($data[$i] >= 'N' AND $data[$i] <= 'Z') OR ($data[$i] >= 'n' AND $data[$i] <= 'z')) $data[$i] = chr(ord($data[$i]) - 13); return parent::write($data); } } /* Enregistrement du filtre avec PHP */ stream_register_filter("rot13", "rot13_filter") or die("Impossible d'enregistrer le filtre"); $fp = fopen("foo-bar.txt", "w"); /* Liaison du filtre avec le flôt */ stream_filter_append($fp, "rot13"); fwrite($fp, "Line1\n"); fwrite($fp, "Word - 2\n"); fwrite($fp, "Easy As 123\n"); fclose($fp); /* Le filtre ne s'applique qu'au flôt $fp * ce qui fait que cette lecture se fait sans déchiffrement */ readfile("foo-bar.txt"); /* affichage * ------ Yvar1 Jbeq - 2 Rnfl Nf 123 */ ?> ]]> </programlisting> </example> </para> <simpara> Voir aussi <function>stream_register_wrapper</function>, <function>stream_filter_prepend</function> et <function>stream_filter_append</function> </simpara> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-register-wrapper.xml +++ phpdoc-fr/reference/stream/functions/stream-register-wrapper.xml <?xml version="1.0" encoding="iso-8859-1"?>   <refentry id="function.stream-register-wrapper"> <refnamediv> <refname>stream_register_wrapper</refname> <refpurpose>Enregistre une enveloppe URL, implémenté comme classe PHP</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>boolean</type><methodname>stream_register_wrapper</methodname> <methodparam><type>string</type><parameter>protocol</parameter></methodparam> <methodparam><type>string</type><parameter>classname</parameter></methodparam> </methodsynopsis> <para> <function>stream_register_wrapper</function> vous permet d'implémenter vos propres gestionnairs de protocoles et de flôts, à utiliser avec toutes les autres fonctions de fichiers, comme <function>fopen</function>, <function>fread</function> etc... </para> <para> Pour implémenter une enveloppe, vous devez définir une classe avec la liste des membres définie ci-dessous. Lorsque quelqu'un ouvre votre flôt, PHP va créer une instance de la classe <parameter>classname</parameter> et appeler les méthodes de cette instance. Vous devez implémenter ces méthodes exactement comme décrit ci-dessous : sinon, vous risquez de rencontrer des comportements indéfinis. </para> <para> <function>stream_register_wrapper</function> retourne &false; si le protocole <parameter>protocol</parameter> a déjà un gestionnaire attitré. </para> <methodsynopsis> <type>boolean</type><methodname>stream_open</methodname> <methodparam><type>string</type><parameter>path</parameter></methodparam> <methodparam><type>string</type><parameter>mode</parameter></methodparam> <methodparam><type>int</type><parameter>options</parameter></methodparam> <methodparam><type>string</type><parameter>opened_path</parameter></methodparam> </methodsynopsis> <para> Cette méthode est appelée immédiatement après la création de votre flôt. <parameter>path</parameter> spécifie l'URL qui doit être passée à la fonction <function>fopen</function> et ce que cet objet est supposé y lire. Vous pouvez utiliser <function>parse_url</function> pour l'analyser. </para> <para> <parameter>mode</parameter> est le mode d'ouverture du fichier, comme expliqué dans <function>fopen</function>. Vous êtes responsable de la vérification de la validité du paramètre <parameter>mode</parameter> avec le chemin <parameter>path</parameter> fourni. </para> <para> <parameter>options</parameter> contient des options supplémentaires, utilisées par les API de flôts. Il peut contenir une ou plusieurs des options suivantes, combinées par des OR. <informaltable> <tgroup cols="2"> <thead> <row> <entry>Option</entry> <entry>Description</entry> </row> </thead> <tbody> <row> <entry>STREAM_USE_PATH</entry> <entry>Si <parameter>path</parameter> est relatif, recherche la ressources en utilisant la configuration de l'include_path. </entry> </row> <row> <entry>STREAM_REPORT_ERRORS</entry> <entry>Si cette option est activée, vous êtes responsable pour lever les erreurs avec <function>trigger_error</function> durant l'ouverture du flôt. Si cette option n'est pas activée, vous ne devez lever aucune erreur. </entry> </row> </tbody> </tgroup> </informaltable> </para> <para> Si le paramètre <parameter>path</parameter> est ouvert avec succès, et que STREAM_USE_PATH est activé dans le paramètre <parameter>options</parameter>, vous devez affecter à <parameter>opened_path</parameter> le chemin complet de la ressource ou du fichier que vous avez réellement ouvert. </para> <para> Si la ressource demandée a été ouverte, vous devez retourner &true;, ou sinon, vous devez retourner &false; </para> <methodsynopsis> <type>void</type><methodname>stream_close</methodname> <methodparam><type>void</type><parameter></parameter></methodparam> </methodsynopsis> <para> Cette méthode est appelée lors que flôt est fermée, grâce à la fonction <function>fclose</function>. Vous devez libérez toutes les ressources réservées par le flôt. </para> <methodsynopsis> <type>string</type><methodname>stream_read</methodname> <methodparam><type>int</type><parameter>count</parameter></methodparam> </methodsynopsis> <para> Cette méthod est appelée suite à l'utilisation des fonctions <function>fread</function> et <function>fgets</function>. Vous devez lire jusqu'à <parameter>count</parameter> octets de données à partir de la position courante d'écriture ou de lecture, sous la forme de chaîne de caractères. Si il y a moins que <parameter>count</parameter> octets disponibles, vous devez en retourner autant que possible. Si aucune autre données n'est disponible, retournez soit &false; soit une chaîne vide. Vous devez aussi tenir à jour la position du pointeur d'écriture/lecture dans le flôt, en ajoutant ou retranchant le nombre d'octets lus. </para> <methodsynopsis> <type>int</type><methodname>stream_write</methodname> <methodparam><type>string</type><parameter>data</parameter></methodparam> </methodsynopsis> <para> Cette méthode est appelée lorsque la fonction <function>fwrite</function> est utilisée. Vous devez stocker les données <parameter>data</parameter> dans le flôt. Si il n'y a pas assez de place, essayez d'en stocker le maximum. Vous devriez aussi retourner le nombre d'octets que vous avez réussi à écrire, ou bien 0 si aucun n'a pu être stocké. Vous devez aussi tenir à jour la position du pointeur d'écriture/lecture dans le flôt, en ajoutant ou retranchant le nombre d'octets lus. </para> <methodsynopsis> <type>boolean</type><methodname>stream_eof</methodname> <methodparam><type>void</type><parameter></parameter></methodparam> </methodsynopsis> <para> Cette méthode est appelée lorsque la fonction <function>feof</function> est utilisée. Vous devez retourner &true; si la position de lecture se situe a la fin du fichier et si il n'y a plus de données disponibles pour la lecture, ou bien &false; sinon. </para> <methodsynopsis> <type>int</type><methodname>stream_tell</methodname> <methodparam><type>void</type><parameter></parameter></methodparam> </methodsynopsis> <para> Cette méthode est appelée lorsque la fonction <function>ftell</function> est utilisée. Vous devez retourner la position actuelle du pointeur de lecture/écriture. </para> <methodsynopsis> <type>boolean</type><methodname>stream_seek</methodname> <methodparam><type>int</type><parameter>offset</parameter></methodparam> <methodparam><type>int</type><parameter>whence</parameter></methodparam> </methodsynopsis> <para> Cette méthode est appelée lorsque la fonction <function>fseek</function> est utilisée. Vous devez modifier la position du pointeur de lecture/ écriture en fonction des paramètres d'offset <parameter>offset</parameter> et de direction <parameter>whence</parameter>. Reportez-vous à la fonction <function>fseek</function> pour plus de détails sur ces paramètres. Retournez &true; si la position a été modifiée, et &false; sinon. </para> <methodsynopsis> <type>boolean</type><methodname>stream_flush</methodname> <methodparam><type>void</type><parameter></parameter></methodparam> </methodsynopsis> <para> Cette méthode est appelée lorsque la fonction <function>fflush</function> est utilisée. Si vous avez mis des données dans un système de cache pour votre flôt, mais qu'ils ne sont pas encore stockés de manière pérenne, c'est le moment de le faire. Retournez &true; si les données cachées ont pu être stockées avec succès (il n'y a plus de données à stocker), ou bien &false; si les données n'ont pu être stockées. </para> <para> L'exemple ci-dessous implémente un gestionnaire de protocole pour le protocole var://, qui permet l'écriture et la lecture de variables globales en utilisant un flôt de fichier standard, et les fonctions classiques telles que <function>fread</function>. Le protocole var:// implémenté ci-dessous, étant donné l'URL "var://foo" va écrire ou lire les données dans $GLOBALS["foo"]. <example> <title>A Stream for reading/writing global variables</title> <programlisting role="php"> <![CDATA[ class VariableStream { var $position; var $varname; function stream_open($path, $mode, $options, &$opened_path) { $url = parse_url($path); $this->varname = $url["host"]; $this->position = 0; return true; } function stream_read($count) { $ret = substr($GLOBALS[$this->varname], $this->position, $count); $this->position += strlen($ret); return $ret; } function stream_write($data) { $left = substr($GLOBALS[$this->varname], 0, $this->position); $right = substr($GLOBALS[$this->varname], $this->position + strlen($data)); $GLOBALS[$this->varname] = $left . $data . $right; $this->position += strlen($data); return strlen($data); } function stream_tell() { return $this->position; } function stream_eof() { return $this->position >= strlen($GLOBALS[$this->varname]); } function stream_seek($offset, $whence) { switch($whence) { case SEEK_SET: if ($offset < strlen($GLOBALS[$this->varname]) && $offset >= 0) { $this->position = $offset; return true; } else { return false; } break; case SEEK_CUR: if ($offset >= 0) { $this->position += $offset; return true; } else { return false; } break; case SEEK_END: if (strlen($GLOBALS[$this->varname]) + $offset >= 0) { $this->position = strlen($GLOBALS[$this->varname]) + $offset; return true; } else { return false; } break; default: return false; } } } stream_register_wrapper("var", "VariableStream") or die("Failed to register protocol"); $myvar = ""; $fp = fopen("var://myvar", "r+"); fwrite($fp, "line1\n"); fwrite($fp, "line2\n"); fwrite($fp, "line3\n"); rewind($fp); while(!feof($fp)) { echo fgets($fp); } fclose($fp); var_dump($myvar); ]]> </programlisting> </example> </para> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-select.xml +++ phpdoc-fr/reference/stream/functions/stream-select.xml <?xml version="1.0" encoding="iso-8859-1"?>  <refentry id="function.stream-select"> <refnamediv> <refname>stream_select</refname> <refpurpose>Runs the equivalent of the select() system call on the given arrays of streams with a timeout specified by tv_sec and tv_usec </refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>int</type><methodname>stream_select</methodname> <methodparam><type>resource</type><parameter>&read</parameter></methodparam> <methodparam><type>resource</type><parameter>&write</parameter></methodparam> <methodparam><type>resource</type><parameter>&except</parameter></methodparam> <methodparam><type>int</type><parameter>tv_sec</parameter></methodparam> <methodparam choice="opt"><type>int</type><parameter>tv_usec</parameter></methodparam> </methodsynopsis> <simpara> <function>stream_select</function> accepte un tableau de flôts et attend que l'un d'entre eux change de statut. Cette opération est équivalente à ce que fait la fonction <function>socket_select</function>, ormis le fait qu'elle travaille sur flôts. </simpara> <simpara> Les flôts qui sont listés dans le paramètre <parameter>read</parameter> seront surveillés en lecture, c'est à dire si de nouveaux octets sont disponibles en lecture (pour être précis, si une lecture ne bloquera pas, ce qui inclut aussi les flôts qui sont en fin de fichier, auquel cas un appel à la fonction <function>fread</function> retournera une chaîne de taille 0). </simpara> <simpara> Les flôts qui sont listés dans le paramètre <parameter>write</parameter> seront surveillé en écriture (pour être précis, si une écriture ne bloquera pas). </simpara> <simpara> Les flôts qui sont listés dans le paramètre <parameter>except</parameter> seront surveillé pour voir si une exception est levée. </simpara> <warning> <para> Lors de la fin de la fonction, les tableaux sont modifiés pour rapporter leurs évolutions respectives. </para> </warning> <simpara> Vous n'êtes pas obligés de passer tous les tableaux à la fonction <function>stream_select</function>. Vous pouvez en omettre certains, en utilisant un tabeau vide ou la valeur &null;. N'oubliez pas que ces tableaux sont passés <emphasis>par référence</emphasis> et qu'ils seront modifiés lorsque <function>stream_select</function> s'achèvera. </simpara> <para> Exemple <programlisting role="php"> <![CDATA[ <?php /* Preparation du tableau de flôts lecture */ $read = array($stream1, $stream2); if (false === ($num_changed_streams = stream_select($read, $write = NULL, $except = NULL, 0))) { /* Gestion d'erreur */ else if ($num_changed_streams > 0) { /* Au moins un des flôts a évolué */ } ?> ]]> </programlisting> </para> <note> <para> A cause d'une limitation du Zend Engine actuel, il n'est pas possible de passer la valeur &null; directement comme paramètre d'une fonction qui s'attend à des paramètres passés par référence. Au lieu de cela, il est recommandé d'utiliser une variable temporaire, ou une expression don le membre de gauche est une variable temporaire. Comme ceci : <programlisting role="php"> <![CDATA[ <?php stream_select($r, $w, $e = NULL, 0); ?> ]]> </programlisting> </para> </note> <simpara> Les paramètres <parameter>tv_sec</parameter> et <parameter>tv_usec</parameter> ensemle forment le délai d'expiration. Ce délai est la durée maximale d'exécution de <function>stream_select</function>. <parameter>tv_sec</parameter> peut valoir zéro, ce qui fait que <function>stream_select</function> s'achève immédiatement. C'est pratique pour réaliser du polling. Si <parameter>tv_sec</parameter> est &null; (pas de délai d'expiration), <function>stream_select</function> peut bloquer le script indéfiniment. </simpara> <simpara> En cas de succès, <function>stream_select</function> retourne le nomre de flôts qui ont évolué, ce qui peut être zéro si le délai d'expiration a été atteint avant que les flôts n'évoluent. En cas d'erreur, la fonction retourne &false;. </simpara> <note> <para> Assurez vous de bien utiliser l'opérateur <literal>===</literal> lorsque vous recherchez des erreurs. Comme <function>stream_select</function> peut retourner 0, une comparaison effectuée à l'aide de <literal>==</literal> la confondrait avec une erreur. <programlisting role="php"> <![CDATA[ <?php if (false === stream_select($r, $w, $e = NULL, 0)) { echo "stream_select() failed\n"; } ?> ]]> </programlisting> </para> </note> <note> <para> Gardez à l'esprit que certaines implémentations de flôts doivent être gérées très prudemment. Voici quelques règles à suivre : <itemizedlist> <listitem> <simpara> Il faut toujours essayer d'utiliser <function>stream_select</function> sans délai d'expiration. Votre programme ne devrait rien faire si il ne reçoit pas de données extérieures. Les codes qui dépendent du délai d'expiration ne sont généralement pas portable, et difficiles à déboguer. </simpara> </listitem> <listitem> <simpara> Si vous avez écrit ou lu dans un flôt qui retournés dans les tableaux de flôts, soyez bien conscient que ces flôts n'ont peut être pas écrit ou lu la totalité des données demandées. Soyez préparés à être en mesure de lire un seul octet. </simpara> </listitem> </itemizedlist> </para> </note> <para> Voir aussi <function>stream_set_blocking</function>. </para> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-set-blocking.xml +++ phpdoc-fr/reference/stream/functions/stream-set-blocking.xml <?xml version="1.0" encoding="iso-8859-1"?>   <refentry id="function.stream-set-blocking"> <refnamediv> <refname>stream_set_blocking</refname> <refpurpose>Configure le mode bloquant d'un flôt</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>bool</type><methodname>stream_set_blocking</methodname> <methodparam><type>resource</type><parameter>stream</parameter></methodparam> <methodparam><type>int</type><parameter>mode</parameter></methodparam> </methodsynopsis> <para> <function>stream_set_blocking</function> configure le mode bloquant du flôt <parameter>stream</parameter>. Si <parameter>mode</parameter> vaut &false;, <parameter>stream</parameter> sera configuré en mode non-bloquant, et si il vaut &true;, <parameter>stream</parameter> sera configuré en mode bloquant. Cet appel affecte les fonctions telles que <function>fgets</function> et <function>fread</function> qui lisent dans des flôts. En mode non-bloquant, la fonction <function>fgets</function> s'exécute juste après son appel, alors qu'en mode bloquant, elle attendra des données. </para> <para> <function>stream_set_blocking</function> était appelée <function>set_socket_blocking</function> et plus tard <function>socket_set_blocking</function> mais ces appellations sont obsolètes. </para> <note> <simpara> Depuis PHP 4.3, cette fonction peut (potentiellement) fonctionner avec n'importe quel flôt. Avant PHP 4.3, les flôts utilisant des sockets sont les seul qui soit supporté dans le coeur de PHP, même si les autres extensions pourrait supporter cette fonction. </simpara> </note> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-set-timeout.xml +++ phpdoc-fr/reference/stream/functions/stream-set-timeout.xml <?xml version="1.0" encoding="iso-8859-1"?>   <refentry id="function.stream-set-timeout"> <refnamediv> <refname>stream_set_timeout</refname> <refpurpose>Configure la durée d'expiration d'un flôt</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>bool</type><methodname>stream_set_timeout</methodname> <methodparam><type>resource</type><parameter>stream</parameter></methodparam> <methodparam><type>int</type><parameter>seconds</parameter></methodparam> <methodparam><type>int</type><parameter>microseconds</parameter></methodparam> </methodsynopsis> <para> <function>stream_set_timeout</function> configure la durée d'expiration du flôt <parameter>stream</parameter>,exprimé comme la durée de <parameter>seconds</parameter> secondes et <parameter>microseconds</parameter> micro-secondes. <example> <title>Exemple avec <function>stream_set_timeout</function></title> <programlisting role="php"> <![CDATA[ <?php $fp = fsockopen("www.example.com", 80); if(!$fp) { echo "Unable to open\n"; } else { fputs($fp, "GET / HTTP/1.0\n\n"); $start = time(); stream_set_timeout($fp, 2); $res = fread($fp, 2000); var_dump(stream_get_meta_data($fp)); fclose($fp); print $res; } ?> ]]> </programlisting> </example> </para> <note> <simpara> Depuis PHP 4.3, cette fonction peut (potentiellement) fonctionner avec n'importe quel flôt. Avant PHP 4.3, les flôts utilisant des sockets sont les seul qui soit supporté dans le coeur de PHP, même si les autres extensions pourrait supporter cette fonction. </simpara> </note> <para> <function>stream_set_timeout</function> était appelée auparavant <function>set_socket_timeout</function>, et aussi <function>socket_set_timeout</function> mais ces appellations sont obsolètes. </para> <para> Voir aussi <function>fsockopen</function> et <function>fopen</function>. </para> </refsect1> </refentry>  Index: phpdoc-fr/reference/stream/functions/stream-set-write-buffer.xml +++ phpdoc-fr/reference/stream/functions/stream-set-write-buffer.xml <?xml version="1.0" encoding="iso-8859-1"?>   <refentry id="function.stream-set-write-buffer"> <refnamediv> <refname>stream_set_write_buffer</refname> <refpurpose>Configure la bufferisation de fichier pour un flôt</refpurpose> </refnamediv> <refsect1> <title>Description</title> <methodsynopsis> <type>int</type><methodname>stream_set_write_buffer</methodname> <methodparam><type>resource</type><parameter>stream</parameter></methodparam> <methodparam><type>int</type><parameter>buffer</parameter></methodparam> </methodsynopsis> <simpara> <function>fwrite</function> est habituellement configuré avec un buffer de 8ko. Cela signifie que si deux processus veulent écrirent dans le même flôt de sortie (par exemple, un fichier), ils font une pause tous les 8ko pour laisser l'autre écrire aussi. <function>stream_set_write_buffer</function> configure la taille du buffer des opérations d'écritures pour le flôt <parameter>stream</parameter> avec la nouvelle valeur de <parameter>buffer</parameter> octets. Si <parameter>buffer</parameter> vaut 0, les opérations d'écritures ne seront pas bufferisées. Cela signifie que chaque appel à <function>fwrite</function> doit être terminé pour qu'un autre processus soit autorisé à écrire dans le fichier. </simpara> <simpara> <function>stream_set_write_buffer</function> retourne 0 en cas de succès, et EOF si la requête échoue. </simpara> <para> L'exemple ci-dessous illustre l'utilisation de <function>stream_set_write_buffer</function> pour créer un flôt non bufferisé. <example> <title>Exemple avec <function>stream_set_write_buffer</function></title> <programlisting role="php"> <![CDATA[ $fp = fopen($file, "w"); if ($fp) { stream_set_write_buffer($fp, 0); fputs($fp, $output); fclose($fp); } ]]> </programlisting> </example> </para> <simpara> Voir aussi <function>fopen</function> et <function>fwrite</function>. </simpara> </refsect1> </refentry>