
/*
 *  File Name:      outputQuery.c
 *  Purpose:        This file contains three routines which handle the output
 *                  of the index queries.  The first routine initializes the
 *                  the output by saving the output FILE ptr which is needed
 *                  by the output buffer for display.  It's possible to pass
 *                  this FILE ptr to the display routine, but this would also
 *                  require the outputQuery() routine to have the FILE as
 *                  part of it's parameter list, since the outputQuery()
 *                  routine may need to flush the output buffer.  For clarity,
 *                  the FILE ptr is saved and is static to this file.  The
 *                  second routine is the routine that the query() method
 *                  requires and places one data object into the output 
 *                  buffer.  The object is converted to a string 
 *                  representation and placed in the output buffer. Before
 *                  placement, an overflow condition is checked and, if
 *                  necessary, the buffer is flushed before.  Note that
 *                  the size of the output buffer MUST be at least the
 *                  length of the largest possible data object string
 *                  representation.  The final routine flushes the output
 *                  buffer by displaying the contents to the output stream,
 *                  via the output FILE ptr.
 *
 *  Revision History:
 *
 *  Date    Name            Revision
 *  ------- --------------- ------------------------------
 *  27May99 Matthew Rivas   Created
 *  23Jun99 Matthew Rivas   Added initializer to numberOfAttributes to prevent
 *                          warning message during compilation
 *
 *	Copyright 1999, Atlantic Aerospace Electronics Corp.
 */

#include <assert.h>         /*  for assert()                    */
#include <stdlib.h>         /*  for NULL definition             */
#include <stdio.h>          /*  for sprintf() definition        */
#include <string.h>         /*  for strcpy() definition         */
#include "dataManagement.h" /*  for primitive type definitions  */
#include "dataObject.h"     /*  for DataObject definitions      */
#include "errorMessage.h"   /*  for errorMessage() definition   */

/*
 *  Static definition of output buffer
 *      - approximate maximum length of a single data object represented
 *        as a character string is:
 *
 *              44483 characters = 8  * 50     key float values
 *                               + 43 * 1024   non-key char strings
 *                               + 50          place delimiters
 *                               + 1           line-feed/carriage return
 *      - output buffer length should be set
 */
 
#define LENGTH_OF_KEY_VALUE         50 
#define LENGTH_OF_NON_KEY_VALUE     MAX_SIZE_OF_NON_KEY_ATTRIBUTE
#define MAX_LENGTH_OF_ATTRIBUTE     MAX_SIZE_OF_NON_KEY_ATTRIBUTE
#define NUM_OF_NON_KEY_ATTRIBUTES ( NUM_OF_LARGE_ATTRIBUTES - NUM_OF_KEY_ATTRIBUTES )
#define REPRESENTATION_LENGTH       44483 
#define OUTPUT_BUFFER_LENGTH        2 * REPRESENTATION_LENGTH
#define ATTRIBUTE_DELIMITER         " "
#define END_OF_LINE_INDICATOR       "\n"

static Char outputBuffer[ OUTPUT_BUFFER_LENGTH + 1 ];
static FILE *outputFile = NULL;

/*
 *  Function prototype
 */
void flushOutputBuffer( void );

/*
 *  Name:           outputQuery
 *  Input:          data object to place in output buffer, dataObject
 *  Output:         none
 *  Return:         void
 *  Description:    This routine places a single data object into the output
 *                  buffer.  The object is first converted to a string 
 *                  representation which consists of each attribute in
 *                  character format separated by a single space.  A local
 *                  static character array is used to build the data object
 *                  string representation.  The static array, called
 *                  dataObjectString, must have a length which can handle a
 *                  data object of maximum size, i.e., largest possible key
 *                  values, large type with each non-key string of maximum
 *                  length.  Also, the output buffer size must be at least this
 *                  size.  A check is made to see if the output buffer needs to
 *                  be flushed prior to the dataObjectString placement and then
 *                  the dataObjectString is placed in the output buffer.
 *  Calls:          errorMessage()
 *                  flushErrorMessage() 
 *                  flushOutputBuffer()
 *      System:     strcat()
 *                  strlen()
 *                  sprintf()
 *  Author:         M.L.Rivas
 *
 *  Revision History:
 *
 *  Date    Name            Revision
 *  ------- --------------- ------------------------------
 *  27May99 Matthew Rivas   Created
 *
 *	Copyright 1999, Atlantic Aerospace Electronics Corp.
 */

void outputQuery( DataObject *dataObject )  /*  object to place in buffer */
{   /*  beginning of outputQuery()  */
    Int i;                  /*  loop variable for attributes         */
    Int numberOfAttributes; /*  number of attributes for object      */
    
#ifndef NDEBUG
    static Char name[] = "outputQuery";
#endif /* NDEBUG */
    
    /*
     *  Static character strings for converting dataObject to string 
     *  representation.  temp is used to convert individual key attributes to a 
     *  string and then strcat() is used to place the attribute string version 
     *  into the dataObjectString which holds the entire data object string 
     *  representation.  When all of the attributes have been processed, 
     *  dataObjectString is placed into the output buffer.
     */
    static Char temp[ LENGTH_OF_KEY_VALUE + 1 ];
    static Char dataObjectString[ REPRESENTATION_LENGTH + 1 ];

    assert( outputFile );    
    assert( dataObject );
    assert( !(dataObject->type != SMALL  && \
              dataObject->type != MEDIUM && \
              dataObject->type != LARGE ) );
    assert( LENGTH_OF_KEY_VALUE     <= MAX_LENGTH_OF_ATTRIBUTE && \
            LENGTH_OF_NON_KEY_VALUE <= MAX_LENGTH_OF_ATTRIBUTE );
    assert( REPRESENTATION_LENGTH >= \
            LENGTH_OF_KEY_VALUE * NUM_OF_KEY_ATTRIBUTES \
          + LENGTH_OF_NON_KEY_VALUE * NUM_OF_NON_KEY_ATTRIBUTES \
          + ( NUM_OF_LARGE_ATTRIBUTES - 1 ) \
          + 1 );
    assert( REPRESENTATION_LENGTH <= OUTPUT_BUFFER_LENGTH );
    assert( MIN_ATTRIBUTE_CODE < NUM_OF_KEY_ATTRIBUTES );
    assert( MIN_ATTRIBUTE_CODE < MAX_ATTRIBUTE_CODE );
    assert( MAX_ATTRIBUTE_CODE < NUM_OF_LARGE_ATTRIBUTES );
    assert( NUM_OF_KEY_ATTRIBUTES < NUM_OF_SMALL_ATTRIBUTES );
    assert( NUM_OF_KEY_ATTRIBUTES < NUM_OF_MEDIUM_ATTRIBUTES );
    assert( NUM_OF_KEY_ATTRIBUTES < NUM_OF_LARGE_ATTRIBUTES );
    assert( REPRESENTATION_LENGTH <= OUTPUT_BUFFER_LENGTH );

    /*
     *  Determine the number of attributes for data object
     */
    numberOfAttributes = 0;
    if ( dataObject->type == SMALL ) {
        numberOfAttributes = NUM_OF_SMALL_ATTRIBUTES - 1;
    }   /*  end if ( dataObject->type == SMALL )      */
    else if ( dataObject->type == MEDIUM ) {
        numberOfAttributes = NUM_OF_MEDIUM_ATTRIBUTES - 1;
    }   /*  end if ( dataObject->type == MEDIUM )    */
    else if ( dataObject->type == LARGE ) {
        numberOfAttributes = NUM_OF_LARGE_ATTRIBUTES - 1;
    }   /*  end if ( dataObject->type == LARGE )      */
    
    /*
     *  Place each attribute into dataObjectString. Key and Non-Key values are 
     *  handled separately because of the format command, i.e. %f or %s.  The 
     *  temp string is used to hold the character string representation of the 
     *  key attribute values returned from sprintf().  Then strcat() is used to 
     *  add the attribute string representation to the full data object 
     *  representation being built up in dataObjectString.  All of the non-key 
     *  attributes are added to the dataObjectString using strcat() except for 
     *  the last attribute.  This attribute has no space delimiter after and so 
     *  is handled separately.  Finally, an end-of-line indicator is added to 
     *  the data object string and the string is place in the output buffer.  
     *  Note that the dataObjectString needs to be initialized to EMPTY/'\0' 
     *  each time the routine is called, since the array is static for memory 
     *  efficiency.
     */
    dataObjectString[ 0 ] = '\0';
    for ( i = MIN_ATTRIBUTE_CODE; i < NUM_OF_KEY_ATTRIBUTES; i++ ) {
        sprintf( temp, "%.8e", dataObject->attributes[ i ].value.key );
        strcat( dataObjectString, temp );
        strcat( dataObjectString, ATTRIBUTE_DELIMITER );
    }   /*  end of loop for key attributes  */

    for ( i = NUM_OF_KEY_ATTRIBUTES; i < numberOfAttributes; i++ ) {
        assert( dataObject->attributes[ i ].value.nonKey );
        assert( strlen( dataObject->attributes[ i ].value.nonKey ) > 0 );

        strcat( dataObjectString, dataObject->attributes[ i ].value.nonKey );
        strcat( dataObjectString, ATTRIBUTE_DELIMITER );
    }   /*  end of loop for non-key attributes  */

    assert( dataObject->attributes[ numberOfAttributes ].value.nonKey );
    assert(strlen(dataObject->attributes[numberOfAttributes].value.nonKey) > 0);

    strcat( dataObjectString, 
            dataObject->attributes[ numberOfAttributes ].value.nonKey );
    strcat( dataObjectString, END_OF_LINE_INDICATOR );

    assert( strlen( dataObjectString ) <= REPRESENTATION_LENGTH );
    
    /*
     *  Place the data object string representation into the output buffer, 
     *  flushing if necessary.
     */
    if ( strlen( dataObjectString ) + strlen( outputBuffer ) 
         > OUTPUT_BUFFER_LENGTH ) {
#ifndef NDEBUG
        errorMessage( "output buffer full - flushing", REPLACE );
        errorMessage( name, PREPEND );
        flushErrorMessage();
#endif /* NDEBUG */

        flushOutputBuffer();
    }
    
    strcat( outputBuffer, dataObjectString );

    return;
}   /*  end of outputQuery()    */

/*
 *  Name:           initOutputBuffer
 *  Input:          FILE ptr to output stream, file
 *  Output:         none
 *  Return:         void
 *  Description:    This routine initializes the output buffer by
 *                  saving the output FILE ptr for later buffer
 *                  display.
 *  Calls:          
 *      System:     
 *  Author:         M.L.Rivas
 *
 *  Revision History:
 *
 *  Date    Name            Revision
 *  ------- --------------- ------------------------------
 *  27May99 Matthew Rivas   Created
 *
 *	Copyright 1999, Atlantic Aerospace Electronics Corp.
 */

void initOutputBuffer( FILE *file )
{   /*  beginning of initOutputBuffer() */
    assert( file );
    
    outputFile = file;
}   /*  end of initOutputBuffer()   */

/*
 *  Name:           flushOutputBuffer
 *  Input:          none
 *  Output:         none
 *  Return:         void
 *  Description:    This routine flushes the output buffer by displaying
 *                  the current contents of the buffer into the output
 *                  stream via the static outputFile FILE ptr.  A check
 *                  is made to ensure that the buffer has contents to 
 *                  display before a flush occurs.
 *  Calls:          
 *      System:     fprintf()
 *                  fflush()
 *  Author:         M.L.Rivas
 *
 *  Revision History:
 *
 *  Date    Name            Revision
 *  ------- --------------- ------------------------------
 *  27May99 Matthew Rivas   Created
 *
 *	Copyright 1999, Atlantic Aerospace Electronics Corp.
 */

void flushOutputBuffer( void )
{   /*  beginning of flushOutputBuffer()    */
    assert( outputFile );
    
    /*
     *  If the contents are not empty, flush the buffer
     */
    if ( strlen( outputBuffer ) > 0 ) {
        fprintf( outputFile, "%s", outputBuffer );
        fflush( outputFile );
    } 

    outputBuffer[ 0 ] = '\0';
    
    return;
}   /*  end of flushOutputBuffer()  */