Subversion Repositories svn1-original

/*************************************************************************
*           Copyright (C) 1995 Embedded Solutions
*                       All rights reserved
*
* file:     src\check.c
*
* purpose:  This module provides routines that are used to test the team's
*           times.
*
*
* functions
*       test_times              - Recalculate team time information
*       set_times               - Calc start times for each leg
*
* programmer: David Purdie
*
* revision  date        by      reason
*           ??/05/90    MV      Modified May 1990 by Margherita Veroni
*   00.0    27/01/95    DDP     Tidies up the program and formatted the file
*
**************************************************************************/
#include    <stdlib.h>

#include    "consts.h"
#include    "structs.h"
#include    "proto.h"

/* Internal declarations and definitions */

int         parallel_legs = FALSE;               /* Legs run in Parallel */
ty_check_error check_error;

/*========================================================================
 *
 *  Recalculate team time information
 *
 *  Purpose:
 *      This routine will examine the team entry and :-
 *      Calculate the elapsed times for each leg
 *      Calculate the elapsed time for the team
 *      Flag any inconsistencies in the data
 *          In consistencies are :-
 *          No start time
 *          No end time
 *          End before start
 *          Times without team data
 *          NE team with a named NE competitor
 *
 *
 *  Parameters:
 *      data            address of the data buffer
 *      upto_leg;       Examine upto and including this leg
 *
 *  Returns:
 *      The function returns the bad_times flag
 *
 *========================================================================*/

bool test_times( team_type * data, int upto_leg )
{
    int         i;                               /* One of those loopy things */
    time_t      t;                               /* Used for time calcs */
    leg_type   *use;                             /* pointer to leg entry */

    if( upto_leg == 0 )
        upto_leg = config.num_legs;              /* Test all legs */

    data->flags.bad_times = FALSE;               /* Set times ok */
    check_error.leg = check_error.type = 0;

    if( !data->flags.valid )
    {
        /*
        ** Test for invalid team with time information present
        */
        for( i = 0; i < upto_leg; i++ )
            if( data->leg[i + 1].end >= 0 )
            {
                check_error.type = 4;            /* Flag error */
                check_error.leg = i;
                data->flags.bad_times = TRUE;
                t = ( time_t ) - 1;
            }
    }
    else
    {
        for( i = 0, t = 0; i < upto_leg; i++ )
        {
            use = &data->leg[i + 1];             /* Pointer to leg data */

            // Is this the NE leg ?
            // If NE then
            //      If we have a competitor name - warn
            //      Don't add in time
            if ( i + 1 == config.equestrian_leg && data->flags.non_equestrian   )
            {
                // This error is now detected by the caller
                //if ( data->members[i].name[0] && use->end >= 0)
                //{
                //    if( !check_error.leg )
                //    {
                //        check_error.leg = i + 1;
                //        check_error.type = 5;
                //    }
                //}
                use->elapsed = -1;
                continue;
            }


            // Have a start and  end time
            // Calculate the elapsed time
            if( ( use->start >= 0 ) && ( use->end >= 0 ) && ( use->end > use->start ) )
            {
                t += use->elapsed = use->end - use->start;
            }
            else
            {
                // Determine error
                use->elapsed = ( time_t ) - 1;
                data->flags.bad_times = TRUE;
                if( !check_error.leg )
                {
                    check_error.leg = i + 1;
                    check_error.type = 1;
                    if( use->start < 0 )
                        continue;
                    check_error.type = 2;
                    if( use->end < 0 )
                        continue;
                    check_error.type = 3;
                }
            }
        }
    }
    data->leg[0].elapsed = t;                    /* total elapsed so far */
    data->leg[0].start = data->leg[1].start;     /* Team start */
    data->leg[0].end = data->leg[upto_leg].end;  /* Team end */
    return ( data->flags.bad_times );            /* Flag errors, not warnings */
}

/*========================================================================
 *
 *  Calc start times for each leg
 *
 *  Purpose:
 *      This routine will calculate the start times for each leg of the event
 *      where the start time has not been manually entered.
 *
 *      The routine will allow for  two types of start-time calculations
 *          1) End of previous leg = Start of leg.
 *          2) Legs run in parallel ( No calcs to do )
 *      These are controlled on a global scale
 *
 *      Note : Break in time caused by the specials for the start of a leg
 *
 *  Parameters:
 *      data        Address of the team data
 *
 *  Returns:
 *      Nothing
 *
 *========================================================================*/

void set_times( team_type * data )
{
    int         i;

    if( !parallel_legs )
    {
        for( i = 2; i <= config.num_legs; i++ )
        {
            if( data->leg[i].manual )
                continue;                        /* Skip manually entered leg start */

            if( data->leg[i - 1].end >= 0 )
                data->leg[i].start = data->leg[i - 1].end;
            else
                data->leg[i].start = ( time_t ) - 1;
        }
    }
}

/********************************* EOF ***********************************/