Corporate Info  |  News  |  Solutions  |  Products  |  Partners  |  Services  |  Events  |  Download  |  How To Buy
	http://www.oracle.com/technology/documentation/index.html   |   Site Map   |   Search   |   PDF Files   |   Contact   |   Glossary
Tuxedo Doc Home   |   Programming   |   Topic List   |   Previous   |   Next   |   Contents

   Programming a BEA Tuxedo Application Using FML

The VIEWS facility is particularly useful when a program does a lot of processing on the data in a fielded buffer, either after the program has received the buffer or before the program sends the buffer to another program.

Under such conditions, you may improve processing efficiency by using VIEWS functions to transfer fielded buffer data from the buffer to a C structure before you manipulate it. Processing efficiency is improved because C functions require less processing time than FML functions for manipulating fields in a buffer. When you finish processing the data in the C structure, you can transfer that data back to the fielded buffer before sending it to another program.

The VIEWS facility has the following features:

• You can create source view descriptions that specify C structure-to-fielded buffer mappings or COBOL record-to-fielded buffer mappings, and make possible the transfer of data between structures and buffers.

• The viewc or viewc32 view compiler is used to generate object view descriptions (stored in binary files) that are interpreted by your application programs at run time. The compiler also generates header files that can be used in C programs to define the structures used in view descriptions, and optionally generates COPY files that can be used in COBOL programs to define the records used in the view descriptions. For more information about these view compilers, see viewc, viewc32(1) in the BEA Tuxedo Command Reference.

• A view disassembler is provided to translate object view descriptions into readable form (that is, back into source view descriptions). The output of the disassembler can be re-input to the view compiler.

• Data transfers from C structures or COBOL records to fielded buffers can be done in any one of four modes: FUPDATE, FJOIN, FOJOIN, or FCONCAT. These modes are similar to the ones supported by the following FML functions: Fupdate, Fupdate32(3fml), Fjoin, Fjoin32(3fml), Fojoin, Fojoin32(3fml), and Fconcat, Fconcat32(3fml).

• At run time object view descriptions are read into a viewfile cache on demand, and remain there until the cache is full. When the cache is full and an object view description that is not in the cache is needed, the least recently accessed object view description is removed from the cache to make room for the new one.

• All types supported by FML can be used in view descriptions with the exception of FLD_PTR, FLD_FML32, and FLD_VIEW32. In addition, integer and packed decimal are supported.

• When transferring data between fielded buffers and structures, the source data is automatically converted to the type of the destination data; for instance, if a string field is mapped to an integer member, the string is converted to an integer using Ftypcvt() automatically. For more information, refer to Ftypcvt, Ftypcvt32(3fml) in the BEA Tuxedo FML Function Reference.

• Multiple field occurrences are supported.

• User-specified and default null values in view descriptions are supported.

• Functions are available for compiling and evaluating boolean expressions against application data in a VIEW.

A source viewfile is an ordinary text file that contains one or more source view descriptions. Source viewfiles are used as input to a view compiler-viewc or viewc32-which compiles the source view descriptions and stores them in object viewfiles. For more information on the view compiler, refer to viewc, viewc32(1) in the BEA Tuxedo Command Reference.

The view compiler also creates C header files for object viewfiles. These header files can be included in application programs to define the structures used in object view descriptions.

The view compiler optionally creates COBOL COPY files for object viewfiles. These COPY files can be included in COPY programs to define the record formats used in object view descriptions.

Null values are used to indicate empty members in a structure, and can be specified by the user for each structure member in a viewfile. If the user does not specify a null value for a member, default null values are used.

Note that a structure member containing the null value for that member is not transferred during a structure-to-fielded buffer transfer.

It is also possible to inhibit the transfer of data between a C or COBOL structure member and a field in a fielded buffer, even though a mapping exists between them. This is specified in the source viewfile.

The FML VIEWS functions are Fvstof(), Fvftos(), Fvnull(), Fvopt(), Fvselinit(), and Fvsinit(). For COBOL, the VIEWS facility provides two procedures: FVSTOF and FVFTOS. Upon calling any view function, the named object viewfile, if found, is loaded into the viewfile cache automatically. Each file specified in the environment variable VIEWFILES is searched in order (see Setting Up Your Environment for FML and VIEWS). The first object viewfile with the specified name is loaded. Subsequent object viewfiles with the same name, if any, are ignored. For more information on the FML VIEWS functions, refer to BEA Tuxedo FML Function Reference.

Note that arrays of structures, pointers, unions, and typedefs are not supported in VIEWS.

Because VIEWS is concerned with moving fields between fielded buffers and C structures or COBOL records, it must deal with the possibility of multiple occurrence fields in the buffer.

To store multiple occurrences of a field in a structure, a member is declared as an array in C or with the OCCURS clause in COBOL; each occurrence of a field occupies one element of the array. The size of the array reflects the maximum number of field occurrences in the buffer.

When transferring data from fielded buffers to C structures or COBOL records, if the number of elements in the receiving array is greater than the number of occurrences in the fielded buffer, the extra elements are assigned the (default or user-specified) null value. If the number of occurrences in the buffer is greater than the number of elements in the array, the extra occurrences in the buffer are ignored.

When data is transferred from C structures or COBOL records to fielded buffers, array members with the value equal to the (default or user-specified) null values are ignored.