Sérialisation incrémentielle

Lorsque vous utilisez la sérialisation de style incrémentiel, vous fournissez trois routines pour manipuler la mémoire tampon. Ces routines sont les suivantes : Alloc, Read et Write. La routine Alloc alloue une mémoire tampon de la taille requise. La routine d’écriture écrit les données dans la mémoire tampon, et la routine Lecture récupère une mémoire tampon qui contient des données marshalées. Un seul appel de sérialisation peut effectuer plusieurs appels à ces routines.

Le style incrémentiel de sérialisation utilise les routines suivantes :

• MesEncodeIncrementalHandleCreate
• MesDecodeIncrementalHandleCreate
• MesIncrementalHandleReset
• MesHandleFree

Les prototypes des fonctions Alloc, Read et Write que vous devez fournir sont présentés ci-dessous :

void __RPC_USER Alloc (
   void *State,          /* application-defined pointer */
   char **pBuffer,       /* returns pointer to allocated buffer */
   unsigned int *pSize); /* inputs requested bytes; outputs 
                         /* pBuffer size */

void __RPC_USER Write (
   void *State,          /* application-defined pointer */
   char *Buffer,         /* buffer with serialized data */
   unsigned int Size);   /* number of bytes to write from Buffer */

void __RPC_USER Read (
   void *State,          /* application-defined pointer */
   char **pBuffer,       /* returned pointer to buffer with data */
   unsigned int *pSize); /* number of bytes to read into pBuffer */

L’entrée d’état un paramètre pour les trois fonctions est le pointeur défini par l’application qui a été associé au handle des services d’encodage. L’application peut utiliser ce pointeur pour accéder à la structure contenant des informations spécifiques à l’application, telles qu’un handle de fichier ou un pointeur de flux. Notez que les stubs ne modifient pas le pointeur d’état, sauf pour le passer aux fonctions Alloc, Read et Write. Pendant l’encodage, Alloc est appelé pour obtenir une mémoire tampon dans laquelle les données sont sérialisées. Ensuite, Write est appelé pour permettre à l’application de contrôler quand et où les données sérialisées sont stockées. Pendant le décodage, Read est appelé pour retourner le nombre d’octets demandé de données sérialisées à partir de l’emplacement où l’application les a stockées.

Une fonctionnalité importante du style incrémentiel est que le handle conserve le pointeur d’état pour vous. Ce pointeur conserve l’état et n’est jamais touché par les fonctions RPC, sauf lors du passage du pointeur vers la fonction Alloc, Write ou Read. Le handle conserve également un état interne qui permet d’encoder et de décoder plusieurs instances de type dans la même mémoire tampon en ajoutant le remplissage si nécessaire pour l’alignement. La fonction MesIncrementalHandleReset réinitialise un handle à son état initial pour permettre la lecture ou l’écriture à partir du début de la mémoire tampon.

Les fonctions Alloc et Write, ainsi qu’un pointeur défini par l’application, sont associées à un handle encoding-services par un appel à la fonction MesEncodeIncrementalHandleCreate . MesEncodeIncrementalHandleCreate alloue la mémoire nécessaire au handle, puis l’initialise.

L’application peut appeler MesDecodeIncrementalHandleCreate pour créer un handle de décodage, MesIncrementalHandleReset pour réinitialiser le handle ou MesHandleFree pour libérer la mémoire du handle. La fonction Read, ainsi qu’un paramètre défini par l’application, est associée à un handle de décodage par un appel à la routine MesDecodeIncrementalHandleCreate . La fonction crée le handle et l’initialise.

Les paramètres UserState, Alloc, Write et Read de MesIncrementalHandleReset peuvent avoir la valeur NULL pour indiquer qu’aucune modification n’est apportée.