Atributo represent_as

El atributo [ represent_as] permite especificar cómo se representa un tipo de datos transmitible determinado en la aplicación. Esto se hace especificando el nombre del tipo representado para un tipo transmitible conocido y proporcionando las rutinas de conversión. También debe proporcionar las rutinas para liberar la memoria utilizada por los objetos de tipo de datos.

Use el atributo [represent_as] para presentar una aplicación con un tipo de datos diferente, posiblemente intransmitible, en lugar del tipo que se transmite realmente entre el cliente y el servidor. También es posible que el tipo que manipula la aplicación pueda ser desconocido en el momento de la compilación MIDL. Al elegir un tipo de transmisión bien definido, no es necesario preocuparse por la representación de datos en el entorno heterogéneo. El atributo [represent_as] puede hacer que la aplicación sea más eficaz al reducir la cantidad de datos transmitidos a través de la red.

El atributo [represent_as] es similar al atributo [ transmit_as]. Sin embargo, aunque [transmit_as] permite especificar un tipo de datos que se usará para la transmisión, [represent_as] le permite especificar cómo se representa un tipo de datos para la aplicación. No es necesario definir el tipo representado en los archivos procesados MIDL; se puede definir en el momento en que los códigos auxiliares se compilan con el compilador de C. Para ello, use la directiva include en el archivo de configuración de la aplicación (ACF) para compilar el archivo de encabezado adecuado. Por ejemplo, el siguiente ACF define un tipo local para la aplicación, repr_type, para el tipo transmitible named_type:

typedef [represent_as(repr_type) [, type_attribute_list] named_type;

En la tabla siguiente se describen las cuatro rutinas proporcionadas por el programador.

Rutina	Descripción
named_type_from_local	Asigna una instancia del tipo de red y convierte del tipo local al tipo de red.
named_type_to_local	Convierte del tipo de red al tipo local.
named_type_free_local	Libera memoria asignada por una llamada a la rutina named_type_to_local , pero no al propio tipo.
named_type_free_inst	Libera almacenamiento para el tipo de red (ambos lados).

 

Aparte de estas cuatro rutinas proporcionadas por el programador, la aplicación no manipula el tipo con nombre. El único tipo visible para la aplicación es el tipo representado. La aplicación usa el nombre de tipo representado en lugar del nombre de tipo transmitido en los prototipos y códigos auxiliares generados por el compilador. Debe proporcionar el conjunto de rutinas para ambos lados.

En el caso de los objetos de named_type temporales, el código auxiliar llamará a named_type_free_inst para liberar cualquier memoria asignada por una llamada a named_type_from_local.

Si el tipo representado es un puntero o contiene un puntero, la rutina named_type_to_local debe asignar memoria para los datos a los que apunta el puntero (el propio objeto de tipo representado se manipula mediante el código auxiliar de la manera habitual). Para [ out] y [ in, out] parámetros de un tipo que contiene [represent_as o uno de sus componentes, se llama automáticamente a la rutina named_type_free_local para los objetos de datos que contienen el atributo . Para los parámetros [in], solo se llama a la rutina named_type_free_local si el atributo [represent_as] se ha aplicado al parámetro . Si el atributo se ha aplicado a los componentes del parámetro , no se llama a la * rutina _free_local. No se llama a las rutinas de libreción para los datos incrustados y a la llamada de más una vez (relacionada con el atributo de nivel superior) para un parámetro solo [in].

Nota

Es posible aplicar los atributos [transmit_as] y [represent_as] al mismo tipo. Al serializar datos, primero se aplica la conversión de tipos [represent_as] y, a continuación, se aplica la conversión [transmit_as]. El orden se invierte al desacoplar datos. Por lo tanto, al serializar, *_from_local asigna una instancia de un tipo con nombre y la traduce de un objeto de tipo local al objeto de tipo con nombre temporal. Este objeto es el objeto de tipo presentado utilizado para la rutina *_to_xmit . A continuación, la rutina *_to_xmit asigna un objeto de tipo transmitido y lo traduce del objeto presentado (con nombre) al objeto transmitido.

 

Se puede usar una matriz de enteros largos para representar una lista vinculada. De este modo, la aplicación manipula la lista y la transmisión usa una matriz de enteros largos cuando se transmite una lista de este tipo. Puede comenzar con una matriz, pero usar una construcción con una matriz abierta de enteros largos es más conveniente. El ejemplo siguiente muestra cómo hacerlo.

/* IDL definitions */
 
typedef struct_lbox 
{
    long        data;
    struct_lbox *        pNext;
} LOC_BOX, * PLOC_BOX;
 
/* The definition of the local type visible to the application, 
as shown above, can be omitted in the IDL file. See the include 
in the ACF file. */
 
typedef struct_xmit_lbox 
{
    short        Size;
    [size_is(Size)] long DaraArr[];
} LONGARR;
 
void WireTheList( [in,out] LONGARR * pData );
 
/* ACF definitions */
 
/* If the IDL file does not have a definition for PLOC_BOX, you 
can still ready it for C compilation with the following include 
statement (notice that this is not a C include): 
include "local.h";*/
 
typedef [represent_as(PLOC_BOX)] LONGARR;

Tenga en cuenta que los prototipos de las rutinas que usan el tipo LONGARR se muestran realmente en los archivos Stub.h como PLOC_BOX en lugar del tipo LONGARR . Lo mismo ocurre con los códigos auxiliares adecuados en el archivo Stub_c.c.

Debe proporcionar las cuatro funciones siguientes:

void __RPC_USER
LONGARR_from_local(
    PLOC_BOX __RPC_FAR * pList,
    LONGARR __RPC_FAR * _RPC_FAR * ppDataArr );
 
void __RPC_USER
LONGARR_to_local(
    LONGARR __RPC_FAR * _RPC_FAR * ppDataArr,
    PLOC_BOX __RPC_FAR * pList );
 
void __RPC_USER
LONGARR_free_inst(
    LONGARR __RPC_FAR * pDataArr);
 
void __RPC_USER
LONGARR_free_local(
    PLOC_BOX __RPC_FAR * pList );

Las rutinas mostradas anteriormente hacen lo siguiente:

• La rutina de LONGARR_from_local cuenta los nodos de la lista, asigna un objeto LONGARR con el tamaño sizeof(LONGARR) + Count*sizeof(long), establece el campo Size en Count y copia los datos en el campo DataArr .
• La rutina LONGARR_to_local crea una lista con nodos Size y transfiere la matriz a los nodos adecuados.
• La rutina LONGARR_free_inst no libera nada en este caso.
• La rutina LONGARR_free_local libera todos los nodos de la lista.