Serialização Incremental

Ao usar a serialização de estilo incremental, você fornece três rotinas para manipular o buffer. Essas rotinas são: Alloc, Read e Write. A rotina Alloc aloca um buffer do tamanho necessário. A rotina de gravação grava os dados no buffer e a rotina de leitura recupera um buffer que contém dados marshaled. Uma única chamada de serialização pode fazer várias chamadas para essas rotinas.

O estilo incremental de serialização usa as seguintes rotinas:

• MesEncodeIncrementalHandleCreate
• MesDecodeIncrementalHandleCreate
• MesIncrementalHandleReset
• MesHandleFree

Os protótipos das funções Alloc, Read e Write que você deve fornecer são mostrados abaixo:

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 */

O parâmetro State input a parameter for all three functions is the application-defined pointer that was associated with the encoding services handle. O aplicativo pode usar esse ponteiro para acessar a estrutura que contém informações específicas do aplicativo, como um identificador de arquivo ou ponteiro de fluxo. Observe que os stubs não modificam o ponteiro Estado além de passá-lo para as funções Alloc, Read e Write. Durante a codificação, Alloc é chamado para obter um buffer no qual os dados são serializados. Em seguida, Write é chamado para habilitar o aplicativo a controlar quando e onde os dados serializados são armazenados. Durante a decodificação, Read é chamado para retornar o número solicitado de bytes de dados serializados de onde o aplicativo os armazenou.

Um recurso importante do estilo incremental é que o identificador mantém o ponteiro de estado para você. Esse ponteiro mantém o estado e nunca é tocado pelas funções RPC, exceto ao passar o ponteiro para a função Alloc, Write ou Read. O identificador também mantém um estado interno que possibilita codificar e decodificar várias instâncias de tipo para o mesmo buffer adicionando preenchimento conforme necessário para alinhamento. A função MesIncrementalHandleReset redefine um identificador para seu estado inicial para habilitar a leitura ou gravação desde o início do buffer.

As funções Alloc e Write, juntamente com um ponteiro definido pelo aplicativo, são associadas a um identificador de serviços de codificação por uma chamada para a função MesEncodeIncrementalHandleCreate . MesEncodeIncrementalHandleCreate aloca a memória necessária para o identificador e, em seguida, inicializa-a.

O aplicativo pode chamar MesDecodeIncrementalHandleCreate para criar um identificador de decodificação, MesIncrementalHandleReset para reinicializar o identificador ou MesHandleFree para liberar a memória do identificador. A função Read, juntamente com um parâmetro definido pelo aplicativo, está associada a um identificador de decodificação por uma chamada para a rotina MesDecodeIncrementalHandleCreate . A função cria o identificador e o inicializa.

Os parâmetros UserState, Alloc, Write e Read de MesIncrementalHandleReset podem ser NULL para indicar nenhuma alteração.