Serializzazione incrementale

Quando si usa la serializzazione dello stile incrementale, si forniscono tre routine per modificare il buffer. Queste routine sono: Alloc, Lettura e Scrittura. La routine Alloc alloca un buffer delle dimensioni necessarie. La routine Di scrittura scrive i dati nel buffer e la routine Di lettura recupera un buffer che contiene dati di marshalling. Una singola chiamata di serializzazione può effettuare diverse chiamate a queste routine.

Lo stile incrementale della serializzazione usa le routine seguenti:

• MesEncodeIncrementalHandleCreate
• MesDecodeIncrementalHandleCreate
• MesIncrementalHandleReset
• MesHandleFree

I prototipi per le funzioni Alloc, Read e Write che è necessario fornire sono riportate di seguito:

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'input stato di un parametro per tutte e tre le funzioni è il puntatore definito dall'applicazione associato all'handle dei servizi di codifica. L'applicazione può usare questo puntatore per accedere alla struttura contenente informazioni specifiche dell'applicazione, ad esempio un handle di file o un puntatore di flusso. Si noti che gli stub non modificano il puntatore di stato diverso da passarlo alle funzioni Alloc, Read e Write. Durante la codifica, Alloc viene chiamato per ottenere un buffer in cui i dati vengono serializzati. Viene quindi chiamato Write per consentire all'applicazione di controllare quando e dove vengono archiviati i dati serializzati. Durante la decodifica, Read viene chiamato per restituire il numero richiesto di byte di dati serializzati da cui l'applicazione l'ha archiviata.

Una caratteristica importante dello stile incrementale è che l'handle mantiene il puntatore allo stato per l'utente. Questo puntatore mantiene lo stato e non viene mai toccato dalle funzioni RPC, tranne quando si passa il puntatore a Alloc, Write o Read. L'handle gestisce anche uno stato interno che consente di codificare e decodificare diverse istanze di tipo nello stesso buffer aggiungendo spaziatura interna in base alle esigenze per l'allineamento. La funzione MesIncrementalHandleReset reimposta un handle allo stato iniziale per abilitare la lettura o la scrittura dall'inizio del buffer.

Le funzioni Alloc e Write, insieme a un puntatore definito dall'applicazione, sono associate a un handle dei servizi di codifica tramite una chiamata alla funzione MesEncodeIncrementalHandleCreate . MesEncodeIncrementalHandleCreate alloca la memoria necessaria per l'handle e quindi la inizializza.

L'applicazione può chiamare MesDecodeIncrementalHandleCreate per creare un handle di decodifica, MesIncrementalHandleReset per reinizializzare l'handle o MesHandleFree per liberare la memoria dell'handle. La funzione Read, insieme a un parametro definito dall'applicazione, è associata a un handle di decodifica tramite una chiamata alla routine MesDecodeIncrementalHandleCreate . La funzione crea l'handle e la inizializza.

I parametri UserState, Alloc, Write e Read di MesIncrementalHandleReset possono essere NULL per indicare alcuna modifica.