Sérialisation de la mémoire tampon fixe

Lorsque vous utilisez le style de mémoire tampon fixe, spécifiez une mémoire tampon suffisamment grande pour prendre en charge les opérations d’encodage (marshaling) effectuées avec le handle. Lors de la démarshalation, vous fournissez la mémoire tampon qui contient toutes les données à décoder.

Le style de mémoire tampon fixe de sérialisation utilise les routines suivantes :

• MesEncodeFixedBufferHandleCreate
• MesDecodeBufferHandleCreate
• MesBufferHandleReset
• MesHandleFree

La fonction MesEncodeFixedBufferHandleCreate alloue la mémoire nécessaire au handle d’encodage, puis l’initialise. L’application peut appeler MesBufferHandleReset pour réinitialiser le handle, ou elle peut appeler MesHandleFree pour libérer la mémoire du handle. Pour créer un handle de décodage correspondant au handle d’encodage de style fixe, vous devez utiliser MesDecodeBufferHandleCreate.

L’application appelle MesHandleFree pour libérer le handle de mémoire tampon d’encodage ou de décodage.

Exemples d’encodage de mémoire tampon fixe

La section suivante fournit un exemple d’utilisation d’une poignée de sérialisation de style de mémoire tampon fixe pour l’encodage de procédure.

/*This is a fragment of the IDL file defining MooProc */

...
void __RPC_USER
MyProc( [in] handle_t Handle, [in,out] MyType * pMyObject,
        [in, out] ThisType * pThisObject);
...

/*This is an ACF file. MyProc is defined in the IDL file */

[
    explicit_handle
]
interface regress
{
    [ encode,decode ] MyProc();
}

L’extrait suivant représente une partie d’une application.

if (MesEncodeFixedBufferHandleCreate (
        Buffer, BufferSize, 
        pEncodedSize, &Handle) == RPC_S_OK)
{
    ...
    /* Manufacture a MyObject and a ThisObject */
    ...
    /* The serialization works from the beginning of the buffer because 
   the handle is in the initial state. The function MyProc does the    
   following when called with an encoding handle:
     - sizes all the parameters for marshalling,
     - marshalls into the buffer (and sets the internal state 
    appropriately) 
    */

    MyProc ( Handle, pMyObject, pThisObject );
    ...
    MesHandleFree ();
}
if (MesDecodeBufferHandleCreate (Buffer, BufferSize, &Handle) ==
    RPC_S_OK)
{

    /* The MooProc does the following for you when called with a decoding 
    handle:
     - unmarshalls the objects from the buffer into *pMooObject and 
       *pBarObject
*/

MyProc ( Handle, pMyObject, pThisObject);
...
MesHandleFree ( Handle );
}

La section suivante fournit un exemple d’utilisation d’un handle de style de mémoire tampon fixe et de sérialisation pour l’encodage de type.

/* This is an ACF file. MyType is defined in the IDL file */

[    
    explicit_handle
]
interface regress
{
    typedef [ encode,decode ] MyType;
}

L’extrait suivant représente les fragments d’application appropriés.

if (MesEncodeFixedBufferHandleCreate (Buffer, BufferSize, 
    pEncodedSize, &Handle) == RPC_S_OK)
{
    //...
    /* Manufacture a MyObject and a pMyObject */
    //...
    MyType_Encode ( Handle, pMyObject );
    //...
    MesHandleFree ();
}
if (MesDecodeBufferHandleCreate (Buffer, BufferSize, &Handle) ==
    RPC_S_OK )
{
    MooType_Decode (Handle, pMooObject);
    //...
    MesHandleFree ( Handle );
}