<!-- EN-Revision: 13838 -->
<sect1 id="zend.memory.memory-objects">
    <title>Objet mémoire</title>

    <sect2 id="zend.memory.memory-objects.movable">
        <title>Mobile</title>

        <para>Créer des objets mémoires mobiles en utilisant la méthode <code>create([$data])</code> du manager de
        mémoire : <programlisting role="php"><![CDATA[
$memObject = $memoryManager->create($data);
]]></programlisting></para>

        <para>"Mobile" signifie que de tels objets peuvent être mis en cache et déchargés de la mémoire et chargés
        ensuite quand le code de l'application accède à l'objet.</para>
    </sect2>

    <sect2 id="zend.memory.memory-objects.locked">
        <title>Verrouillé</title>

        <para>Créer des objets mémoires verrouillés en utilisant la méthode <code>createLocked([$data])</code> du
        manager de mémoire : <programlisting role="php"><![CDATA[
$memObject = $memoryManager->createLocked($data);
]]></programlisting></para>

        <para>"Verrouillé" signifie que de tels objets ne sont jamais mis en cache et déchargés de la mémoire.</para>

        <para>Les objets verrouillés fournissent la même interface que des objets mobiles
        (<classname>Zend_Memory_Container_Interface</classname>). Donc l'objet verrouillé peut être utilisé en n'importe quel
        endroit à la place des objets mobiles.</para>

        <para>Il est utile si une application ou un développeur peut décider, que quelques objets ne devraient jamais
        être mis en cache, en se basant sur des considérations de performance.</para>

        <para>L'accès aux objets verrouillés est plus rapide, parce que le manager de mémoire ne doit pas suivre à la
        trace des changements pour ces objets.</para>

        <para>La classe d'objets verrouillés (<classname>Zend_Memory_Container_Locked</classname>) garantit pratiquement la même
        performance qu'en travaillant avec une variable de type chaîne de caractères. La couche supérieure est un simple
        référence pour récupérer la propriété de classe.</para>
    </sect2>

    <sect2 id="zend.memory.memory-objects.value">
        <title>Propriété "value" du manager de mémoire</title>

        <para>Utilisez la propriété "<code>value</code>" du conteneur de mémoire (mobile ou verrouillé) pour travailler
        avec les données des objets mémoire : <programlisting role="php"><![CDATA[
$memObject = $memoryManager->create($data);

echo $memObject->value;

$memObject->value = $newValue;

$memObject->value[$index] = '_';

echo ord($memObject->value[$index1]);

$memObject->value = substr($memObject->value, $start, $length);
]]></programlisting></para>

        <para>Une autre manière d'accéder aux données d'objet mémoire est d'utiliser la méthode <link
        linkend="zend.memory.memory-objects.api.getRef"><code>getRef()</code></link>. Cette méthode
        <emphasis>doit</emphasis> être utilisée pour les versions de PHP inférieure à 5.2. Il devrait aussi être utilisé
        dans quelques autres cas pour des raisons de performance.</para>
    </sect2>

    <sect2 id="zend.memory.memory-objects.api">
        <title>Interface du conteneur de mémoire</title>

        <para>Le conteneur de mémoire fournit les méthodes suivantes :</para>

        <sect3 id="zend.memory.memory-objects.api.getRef">
            <title>La méthode getRef()</title>

            <programlisting role="php"><![CDATA[
public function &getRef();
]]></programlisting>

            <para>La méthode <code>getRef()</code> retourne la référence vers une valeur d'objet.</para>

            <para>Des objets mobiles sont chargés du cache à ce moment si l'objet n'est pas déjà dans la mémoire. Si
            l'objet est chargé du cache, cela pourrait entraîner la mise en cache d'autres objets si la limite de
            mémoire était dépassée en ayant tous les objets en mémoire.</para>

            <para>La méthode <code>getRef()</code> <emphasis>doit</emphasis> être utilisée pour accéder aux données
            d'objet mémoire si la version de PHP est inférieure à 5.2</para>

            <para>Suivre à la trace les changements de ces données nécessitent des ressources supplémentaires. La
            méthode <code>getRef()</code> retourne une référence à une chaîne, qui est changé directement par
            l'utilisateur de l'application. Ainsi, c'est une bonne idée d'utiliser la méthode <code>getRef()</code> pour
            le traitement des données : <programlisting role="php"><![CDATA[
$memObject = $memoryManager->create($data);

$value = &$memObject->getRef();

for ($count = 0; $count < strlen($value); $count++) {
    $char = $value[$count];
    ...
}
]]></programlisting></para>
        </sect3>

        <sect3 id="zend.memory.memory-objects.api.touch">
            <title>La méthode touch()</title>

            <programlisting role="php"><![CDATA[
public function touch();
]]></programlisting>

            <para>La méthode <code>touch()</code> devrait être employée en commun avec <code>getRef()</code>. Elle
            signale que la valeur d'objet a été changé : <programlisting role="php"><![CDATA[
$memObject = $memoryManager->create($data);
...

$value = &$memObject->getRef();

for ($count = 0; $count < strlen($value); $count++) {
    ...
    if ($condition) {
        $value[$count] = $char;
    }
    ...
}

$memObject->touch();
]]></programlisting></para>
        </sect3>

        <sect3 id="zend.memory.memory-objects.api.lock">
            <title>La méthode lock()</title>

            <programlisting role="php"><![CDATA[
public function lock();
]]></programlisting>

            <para>La méthode <code>lock()</code> verrouille l'objet en mémoire. Elle devrait être utilisé pour empêcher
            la mise en cache des objets que vous choisissez. Normalement, ce n'est pas nécessaire, parce que le manager
            de mémoire utilise un algorithme intelligent pour choisir des candidats à la mise en cache. Mais si vous
            savez exactement, qu'à cette endroit du code certains objets ne devraient pas être mis en cache, vous pouvez
            les verrouiller.</para>

            <para>Le verrouillage d'objets dans la mémoire garantit aussi que la référence retournée par la méthode
            <code>getRef()</code> est valable jusqu'à ce que vous déverrouiller l'objet : <programlisting
            role="php"><![CDATA[
$memObject1 = $memoryManager->create($data1);
$memObject2 = $memoryManager->create($data2);
...

$memObject1->lock();
$memObject2->lock();

$value1 = &$memObject1->getRef();
$value2 = &$memObject2->getRef();

for ($count = 0; $count < strlen($value2); $count++) {
    $value1 .= $value2[$count];
}

$memObject1->touch();
$memObject1->unlock();
$memObject2->unlock();
]]></programlisting></para>
        </sect3>

        <sect3 id="zend.memory.memory-objects.api.unlock">
            <title>La méthode unlock()</title>

            <programlisting role="php"><![CDATA[
public function unlock();
]]></programlisting>

            <para>La méthode <code>unlock()</code> déverrouille l'objet quand il n'est plus nécessaire de maintenir
            verrouillé. Voir l'exemple ci-dessus.</para>
        </sect3>

        <sect3 id="zend.memory.memory-objects.api.isLocked">
            <title>La méthode isLocked()</title>

            <programlisting role="php"><![CDATA[
public function isLocked();
]]></programlisting>

            <para>La méthode <code>isLocked()</code> peut être utilisée pour vérifier si l'objet est verrouillé. Il
            retourne <code>true</code> si l'objet est verrouillé, ou <code>false</code> s'il n'est pas verrouillé. C'est
            toujours <code>true</code> pour les objets "verrouillés" et peut être <code>true</code> ou
            <code>false</code> pour des objets "mobiles".</para>
        </sect3>
    </sect2>
</sect1>