wire_marshal (attribut)

L’attribut [wire_marshal] spécifie un type de données qui sera utilisé pour la transmission (le type de câble) au lieu d’un type de données spécifique à l’application (type utilisateur).

typedef [wire_marshal(wire_type)] type-specifier userm-type; 
unsigned long __RPC_USER  < userm-type >_UserSize(
    unsigned long __RPC_FAR *pFlags,
    unsigned long StartingSize,
    < userm-type > __RPC_FAR * pUser_typeObject );
unsigned char __RPC_FAR * __RPC_USER  < userm-type >_UserMarshal(
    unsigned long  __RPC_FAR * pFlags,
    unsigned char __RPC_FAR * Buffer,
    < userm-type >  __RPC_FAR * pUser_typeObject);
unsigned char __RPC_FAR * __RPC_USER  < userm-type >_UserUnmarshal(
    unsigned long  __RPC_FAR *  pFlags,
    unsigned char __RPC_FAR *  Buffer,
    < userm-type > __RPC_FAR * pUser_typeObject);
void __RPC_USER  < userm-type >_UserFree(
    unsigned long  __RPC_FAR * pFlags,
    < userm-type >  __RPC_FAR * pUser_typeObject);

Paramètres

wire-type

Spécifie le type de données de transfert nommé qui est réellement transféré entre le client et le serveur. Le type de câble doit être un type de base MIDL, un type prédéfini ou un identificateur de type d’un type qui peut être transmis sur le réseau.

spécificateur de type

Type pour lequel le type utilisateur deviendra un alias.

userm-type

Spécifie l’identificateur du type de données utilisateur à marshaler. Il peut s’agir de n’importe quel type, comme indiqué par le spécificateur de type, tant qu’il a une taille bien définie. Le type utilisateur n’a pas besoin d’être transmettable, mais doit être un type connu du compilateur MIDL.

pFlags

Spécifie un pointeur vers un champ d’indicateur (unsignedlong). Le mot à ordre élevé spécifie les indicateurs de représentation des données de remise tels que définis par DCE pour la représentation à virgule flottante, big ou little-endian et la représentation de caractères. Le mot de bas ordre spécifie un indicateur de contexte de marshaling. La disposition exacte des indicateurs est décrite dans la fonction type_UserSize.

StartingSize

Spécifie la taille actuelle de la mémoire tampon (offset) avant de dimensionner l’objet.

pUser_typeObject

Spécifie un pointeur vers un objet de userm_type.

Buffer

Spécifie le pointeur de mémoire tampon actuel.

Notes

Chaque type de données spécifique à l’application, type utilisateur, a une correspondance un-à-un avec un type de fil qui définit la représentation filaire du type. Vous devez fournir des routines pour dimensionner les données à des fins de marshaling, de marshaler et de démarshaler les données et de libérer de la mémoire. Notez que s’il existe des types incorporés dans vos données également définis avec [wire_marshal] ou [user_marshal],vous devez également gérer la maintenance de ces types incorporés. Pour plus d’informations sur ces routines, consultez l’attribut wire_marshal.

Votre implémentation doit respecter les règles de marshaling conformément à la spécification OSF-DCE. Vous trouverez des détails sur la syntaxe de transfert de remise d’échec de remise à l’adresse https://www.opengroup.org/onlinepubs/9629399/chap14.htm. Il n’est pas recommandé d’utiliser [wire_marshal] si vous n’êtes pas familiarisé avec le protocole filaire.

Le type de câble ne peut pas être un pointeur d’interface ou un pointeur complet. Le type de câble doit avoir une taille de mémoire bien définie. Consultez les règles de marshaling pour user_marshal et wire_marshal pour plus d’informations sur la façon de marshaler un type de câble donné.

Le type utilisateur ne doit pas être un pointeur d’interface, car il peut être marshalé directement. Si le type d’utilisateur est un pointeur complet, vous devez gérer vous-même l’alias.

Vous ne pouvez pas utiliser l’attribut [wire_marshal] avec l’attribut [allocate], directement ou indirectement, car le moteur de remise ne contrôle pas l’allocation de mémoire pour le type transmis.

Exemples

typedef unsigned long _FOUR_BYTE_DATA;

typedef struct _TWO_X_TWO_BYTE_DATA 
{
        unsigned short low;
        unsigned short high;
} TWO_X_TWO_BYTE_DATA;

typedef [wire_marshal(TWO_X_TWO_BYTE_DATA)] 
    _FOUR_BYTE_DATA FOUR_BYTE_DATA; 

//Marshaling functions:

// Calculate size that converted data will 
// require in the buffer
unsigned long __RPC_USER FOUR_BYTE_DATA_UserSize( 
    ULONG __RPC_FAR * pulFlags, 
    ULONG __RPC_FAR ulStartingSize,
    FOUR_BYTE_DATA __RPC_FAR * pul);

// Copy FOUR_BYTE_DATA into buffer as 
// TWO_X_TWO_BYTE_DATA
unsigned long __RPC_USER FOUR_BYTE_DATA_UserMarshal( 
    ULONG __RPC_FAR *pulFlags, 
    char __RPC_FAR * pBufferStart, 
    FOUR_BYTE_DATA __RPC_FAR * pul);

// Recreate FOUR_BYTE_DATA from TWO_X_TWO_BYTE_DATA in buffer
unsigned long __RPC_USER FOUR_BYTE_DATA_UserUnmarshal( 
    ULONG __RPC_FAR * pulFlags, 
    char __RPC_FAR * pBufferStart, 
    FOUR_BYTE_DATA __RPC_FAR * pul);

// Nothing to do here as the engine frees the top 
// node and FOUR_BYTE_DATA is a flat data type.
void __RPC_USER FOUR_BYTE_DATA_UserFree( 
    ULONG __RPC_FAR * pulFlags, 
    FOUR_BYTE_DATA __RPC_FAR * pul 
    );

Voir aussi

Allouer

Représentation des données

MIDL Base Types

Long

NdrGetUserMarshalInfo

Attribut wire_marshal

transmit_as

Unsigned

user_marshal