Subversion Repositories svn1

/*************************************************************************

*           Copyright (C) 1995 Embedded Solutions

*                       All rights reserved

*

* file:     src\legtime.c

*

* purpose:  Leg time calculations

*

* functions

*   set_legs                    - Menu: Setup leg times

*   tm_lgs                      - Set up the leg start times for leg

*   leg_start                   - Set up the leg start times

*   tm_fixedstart               - Set the start time for a specific leg

*   tm_staggered                - Set a staggered start time for a specific leg

*   tm_clearleg                 - Clear start times on a specific leg

*   leg_ini                     - Initialize all stored times

*   tm_init                     - Initialize all team data

*   tm_gen                      - Generate dummy team names

*   legs_start_report           - Generate starters report

*   ls_timer                    - print the current leg entry

*   ls_team                     - print next ( numeric ) leg entry

*   sort_legs                   - Qsort callback function

*

* programmer: David Purdie

*

* revision  date        by      reason

*           11-Oct-89   DDP     leg-3 starttime. Now has an option to generate

*                               a printed report of teams and times

*

*           21-May-90   MV      now able to set start time and generate

*                               a printed report for any leg

*   00.0    27/01/95    DDP     Tidies up the program and formatted the file

*

**************************************************************************/

#include    "QDebug"

#include    "consts.h"

#include    "structs.h"

#include    "proto.h"

/*========================================================================

 *

 *  Set up the leg start times for leg

 *

 *  Purpose:

 *      This function is called to Set up the leg start times for leg

 *      The start time is based on category information

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void tm_lgs1(int leg, time_t starttime, time_t delta, bool report_it, bool clear_it)

{

    t_legs     *data;                            /* Address of table */

    t_legs     *dptr;                            /* Moving pointer */

    int         num_records;                     /* Number of records in array */

    int         i;

    team_type   team_buf;

    /*

    **  Read existing data into memory

    */

    data = ( t_legs * ) calloc( ( unsigned ) ( config.max_team - config.min_team + 2 ), sizeof( t_legs ) ); /* Fetch memory */

    if( !data )

    {

        qDebug( "No memory for report" );

        return;

    }

    /*

     * Extract the required data from the data base

     * Only save that information required for the operation

     *      - The end time of the previous leg

     */

    dptr = data;

    num_records = 0;

    for( i = config.min_team; i <= config.max_team; i++ )

    {

        if( valid_field( i ) && g_record( i, &team_buf ) )

        {

            dptr->numb = team_buf.numb;

            dptr->start = team_buf.leg[leg-1].end;

            dptr->flags = team_buf.flags;

            dptr++;

            num_records++;

        }

    }

    /*

     * Sort the data into some logical order 

     */

    qsort( ( char * ) data, num_records, sizeof( t_legs ), sort_legs );

    /*

    **  Update the team information based on the start order

    **  Ignore validity flags as the data will have been sorted with

    **  these in mind.

    */

    for( dptr = data, i = 0; i < num_records; i++, dptr++ )

    {

        if( valid_field( dptr->numb ) )

        {

            g_record( dptr->numb, &team_buf );

            team_buf.leg[leg].start = starttime;

            starttime += delta;

            team_buf.leg[leg].manual = TRUE;

            set_times( &team_buf );

            test_times( &team_buf, 0 );

            put_team_record( dptr->numb, &team_buf );

        }

    }

    /*

    **  Release the data

    */

    free( data );

    if( report_it )

        legs_start_report(leg);

    if ( clear_it )

        tm_clearleg_specified( leg, TRUE);

}

/*========================================================================

 *

 *  Set up the leg start times for leg

 *

 *  Purpose:

 *      This function is called to Set up the leg start times for leg

 *      The start time is based on current placing with:

 *          A constant offset added ( ie: lunch)

 *          A fixed increment

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void tm_lgs(int leg, time_t delta, bool report_it, bool clear_it)

{

    team_type   team_buf;

    int team = config.min_team;                      /* Team we are working with */

    while( team <= config.max_team )

    {

        if( valid_field( team ) )

        {

            g_record( team, &team_buf );

            if( team_buf.flags.valid && team_buf.leg[leg - 1].end > 0 )

            {

                team_buf.leg[leg].start = team_buf.leg[leg - 1].end + delta;

                team_buf.leg[leg].manual = TRUE;

            }

            else

                team_buf.leg[leg].start = ( time_t ) - 1;

            set_times( &team_buf );

            test_times( &team_buf, 0 );

            put_team_record( team, &team_buf );

        }

        team++;

    }

    if( report_it )

        legs_start_report(leg);

    if ( clear_it )

        tm_clearleg_specified( leg, TRUE);

}

/*========================================================================

 *

 *  Set up the leg start times

 *

 *  Purpose:

 *      This function is called to Set up the leg start times

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void leg_start(void)

{

    team_type   team_buf;

    int team = config.min_team;                      /* Team we are working with */

    while( team <= config.max_team )

    {

        if( valid_field( team ) )

        {

            ( void ) g_record( team, &team_buf );

            if( team_buf.teamclass > 0 && team_buf.teamclass <= config.num_class )

                team_buf.leg[0].start =

                    config.team_class[team_buf.teamclass - 1].start;

            else

                team_buf.leg[0].start = ( time_t ) - 1;

            team_buf.leg[1].manual = 0;

            team_buf.leg[1].start = team_buf.leg[0].start;

            team_buf.leg[0].l_place = 0;

            team_buf.leg[0].le_place = 0;

            team_buf.leg[0].lec_place = 0;

            team_buf.leg[0].lc_place = 0;

            team_buf.leg[0].manual = FALSE;

            set_times( &team_buf );

            test_times( &team_buf, 0 );

            put_team_record( team, &team_buf );

        }

        team++;

    }

}

/*========================================================================

 *

 *  Set the start time for a specific leg

 *

 *  Purpose:

 *      This function is called to set the start time for a specific

 *      leg to a specified and fixed time

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void tm_fixedstart(int leg, time_t starttime, bool report_it, bool clear_it)

{

    team_type   team_buf;

    int team = config.min_team;                      /* Team we are working with */

    while( team <= config.max_team )

    {

        if( valid_field( team ) )

        {

            g_record( team, &team_buf );

            if( team_buf.flags.valid )

            {

                team_buf.leg[leg].start = starttime;

                team_buf.leg[leg].manual = TRUE;

            }

            else

                team_buf.leg[leg].start = ( time_t ) - 1;

            set_times( &team_buf );

            test_times( &team_buf, 0 );

            put_team_record( team, &team_buf );

        }

        team++;

    }

    if( report_it )

        legs_start_report(leg);

    if ( clear_it )

        tm_clearleg_specified( leg, TRUE );

}

/*========================================================================

 *

 *  Set a staggered start time for a specific leg

 *

 *  Purpose:

 *      This function is called to set the start time for a specific

 *      leg to a specified and a staggered time

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void tm_staggered(int leg, time_t starttime, time_t delta, bool report_it, bool clear_it )

{

    team_type   team_buf;

    int team = config.min_team;                      /* Team we are working with */

    while( team <= config.max_team )

    {

        if( valid_field( team ) )

        {

            g_record( team, &team_buf );

            if( team_buf.flags.valid )

            {

                team_buf.leg[leg].start = starttime;

                starttime += delta;

                team_buf.leg[leg].manual = TRUE;

            }

            else

                team_buf.leg[leg].start = ( time_t ) - 1;

            set_times( &team_buf );

            test_times( &team_buf, 0 );

            put_team_record( team, &team_buf );

        }

        team++;

    }

    if( report_it )

        legs_start_report(leg);

    if ( clear_it )

        tm_clearleg_specified( leg, TRUE );

}

/*========================================================================

 *

 *  Clear start times on a specific leg

 *

 *  Purpose:

 *      This function is called to clear start times on a specifc leg

 *

 *  Parameters:

 *      cleg                - Leg to clear

 *      manual              - Force manual, else leave alone

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void tm_clearleg_specified(int leg, bool manual)

{

    team_type   team_buf;

    /*

    **  Validate the users argument

    */

    if( leg == 0 )

        return;                              /* Null leg - just exit */

    if( leg > config.num_legs )             /* Valid leg number - Exit loop */

        return;

    int team = config.min_team;                 /* Team we are working with */

    while( team <= config.max_team )

    {

        if( valid_field( team ) )

        {

            g_record( team, &team_buf );

            team_buf.leg[leg].manual = manual;

            team_buf.leg[leg].start = ( time_t ) -1;

            set_times( &team_buf );

            test_times( &team_buf, 0 );

            put_team_record( team, &team_buf );

        }

        team++;

    }

}

/*========================================================================

 *

 *  Initialize all stored times

 *

 *  Purpose:

 *      This function is called to Initialize all stored times

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void leg_ini(void)

{

    int         i;

    team_type   team_buf;

    int team = config.min_team;                      /* Team we are working with */

    while( team <= config.max_team )

    {

        if( valid_field( team ) )

        {

            ( void ) g_record( team, &team_buf );

            for( i = 0; i <= MAX_LEGS; i++ )

            {

                team_buf.leg[i].start = team_buf.leg[i].end =

                    team_buf.leg[i].elapsed = ( time_t ) - 1;

                team_buf.leg[i].l_place = 0;

                team_buf.leg[i].le_place = 0;

                team_buf.leg[i].lec_place = 0;

                team_buf.leg[i].lc_place = 0;

                team_buf.leg[i].manual = FALSE;

            }

            if( team_buf.teamclass > 0 && team_buf.teamclass <= config.num_class )

                team_buf.leg[0].start =

                    config.team_class[team_buf.teamclass - 1].start;

            else

                team_buf.leg[0].start = ( time_t ) - 1;

            team_buf.leg[1].start = team_buf.leg[0].start;

            team_buf.flags.disqualified = FALSE;

            team_buf.flags.non_equestrian = FALSE;

            put_team_record( team, &team_buf );

        }

        team++;

    }

}

/*========================================================================

 *

 *  Initialize all team data

 *

 *  Purpose:

 *      This function is called to Initialize all team data

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void tm_init(void)

{

    team_type   team_buf;

    int team = config.min_team;                      /* Team we are working with */

    while( team <= config.max_team )

    {

        if( valid_field( team ) )

        {

            clr_team( team, &team_buf );

            put_team_record( team, &team_buf );

        }

        team++;

    }

}

/*========================================================================

 *

 *  Generate dummy team names

 *

 *  Purpose:

 *      This function is called to Generate dummy team names

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void tm_gen(void)

{

    team_type   team_buf;

    int team = config.min_team;                      /* Team we are working with */

    while( team <= config.max_team )

    {

        if( valid_field( team ) )

        {

            ( void ) g_record( team, &team_buf );

            team_buf.flags.valid = TRUE;

            sprintf( team_buf.name, "Team - %4.4d", team );

            team_buf.teamclass = 1;                  /* Set default class */

            put_team_record( team, &team_buf );

        }

        team++;

    }

}

/*========================================================================

 *

 *  Generate starters report

 *

 *  Purpose:

 *      This routine is used to generate a list of leg start times

 *      This system can cope with a break at the start of leg

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void legs_start_report(int leg)

{

    int         i;

    t_legs     *data;                            /* Address of table */

    t_legs     *dptr;                            /* Moving pointer */

    int         last_team;

    int         num_records = 0;                 /* Number of records in array */

    char        l_s[40];                         /* Name of start time file */

    team_type   team_buf;

    printf( "Generating Starters report for Leg-%d", leg );

    data = ( t_legs * ) calloc( ( unsigned ) ( config.max_team - config.min_team + 2 ), sizeof( t_legs ) ); /* Fetch memory */

    if( !data )

    {

        qDebug( "No memory for report" );

        return;

    }

    /*

     * Extract the required data from the data base

     * Only save that information required for the operation

     */

    dptr = data;

    for( i = config.min_team; i <= config.max_team; i++ )   /* Print team order data */

    {

        if( valid_field( i ) && g_record( i, &team_buf ) )

        {

            dptr->numb = team_buf.numb;

            dptr->start = team_buf.leg[leg].start;

            dptr->flags = team_buf.flags;

            dptr++;

            num_records++;

        }

    }

    /*

     * Sort the data into some logical order 

     */

    qsort( ( char * ) data, num_records, sizeof( t_legs ), sort_legs );

    /*

    **  Now print the data on the printer

    **      - Generte the name of the printer file

    **      - Open the printer

    */

    sprintf( l_s, "l_%d", leg );

    if( !open_printer( "", l_s, 80, text, "Starters Report" ) )

        return;

    /*

     * Print out the header for the file 

     */

    print( "\nStarters report for leg:%d %-*s\n", leg, 18, config.leg_name[leg - 1] );

    print( "Team order listing\n\n" );

    print_underline (TRUE);

    print( "%-8s   %-5s   %-8s   |   %-5s   %-8s", "Time", "Team", "DeltaT", "Team", "Time" );

    print_underline (FALSE);

    print( "\n" );

    last_team = 0;

    for( dptr = data, i = 0; i < num_records; i++ )

    {

        ls_timer( dptr++, i );

        print( "   |   " );

        ls_team( &last_team, data );

        print( "\n" );

    }

    print( "\nTeams without marked times will be started when ALL marked teams\n" );

    print( "have been started.\n" );

    /*

    **  Release the resources

    **      - Printer

    **      - Memory

    */

    close_printer();

    free( data );

}

/*========================================================================

 *

 *  print the current leg entry

 *

 *  Purpose:

 *      This function is a helper routine to print the current leg entry

 *      in time : Team number order

 *

 *  Parameters:

 *      ptr     Pointer to entry

 *      num     Entry index

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void ls_timer( t_legs * ptr, int num )

{

    time_t      time;

    time_t      delta;

    if( num == 0 )

        delta = ( time_t ) - 1;

    else

        delta = ptr[0].start - ptr[-1].start;

    time = ptr->start;

    if( ptr->flags.disqualified )

        time = ( time_t ) - 1;

    print( "%-8s   %-5d", time_fa( time, ptr->flags.disqualified ),

           ptr->numb );

    print( "   %-8s", time_fa( delta, TRUE ) );

}

/*========================================================================

 *

 *  print next ( numeric ) leg entry

 *

 *  Purpose:

 *      This helper function is called to print next ( numeric ) leg entry

 *      in Team # time order

 *

 *  Parameters:

 *      last        Last one found

 *                  Used to relocate my self

 *      data        Start of data

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void ls_team( int *last, t_legs * data )

{

    t_legs     *min;

    time_t      time;

    for( min = 0; data->numb; data++ )

    {

        if( data->numb > *last && ( min == 0 || data->numb < min->numb ) )

            min = data;

    }

    *last = min->numb;                           /* Save current team as done */

    time = min->start;

    if( min->flags.disqualified )

        time = ( time_t ) - 1;

    print( "%-5d   %-8s", min->numb,

           time_fa( time, min->flags.disqualified ) );

}

/*========================================================================

 *

 *  Qsort callback function

 *

 *  Purpose:

 *      This function is provided to Qsort() to sort the teams

 *

 *  Parameters:

 *      a           - Leg entry to compare

 *      b           - Leg entry to compare

 *

 *

 *  Returns:

 *      -1      a < b

 *       0      a = b

 *       1      a > b

 *

 *========================================================================*/

int sort_legs( const void * aa, const void * bb )

{

    const t_legs * a = (const t_legs *)aa;

    const t_legs * b = (const t_legs *)bb;

    int         a_bad;

    int         b_bad;

    a_bad = a->flags.disqualified || a->start <= 0;

    b_bad = b->flags.disqualified || b->start <= 0;

    if( a_bad || b_bad )                         /* Valid data has precedence */

    {

        if( a_bad && b_bad )

            return ( a->numb - b->numb );

        else

            return ( a_bad ? 1 : -1 );

    }

    if( a->start == b->start )

        return ( a->numb - b->numb );

    else

    {

        if( ( a->start > 0 ) && ( b->start > 0 ) )

            return ( ( int ) ( a->start - b->start ) );

        else

            return ( ( a->start > 0 ) ? -1 : 1 );

    }

}

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