WebSVN – svn1-original – Diff – /Mara/branches/alternateUploadTimeFormat/report.cpp

 *       pri_final               - Print final results
 *       pri_interim             - Print interim results
 *       print_class_header      - Print a class header
 *       print_class_stats       - Generate the class stats
 *       print_legend            - Print the legend
-*       pi_place                - Return place data (Interim processing)
-*       pr_place                - Return place data
-*       pn_place                - Return place data with NE indication
+*       px_place                - Return place data with NE and V indication
 *       ck_data                 - Check data for bad times
 *       srt_place               - Update placing information
 *       do_big_sort             - Main sort routine for final data
 *       sort                    - Sort in memory buffer
 *       sort_comp               - qsort comparison function
 };
 int         sort_leg;
 int         sort_mode;
 bool        sort_withEquestrian;
+bool        sort_afterEquestrianLeg;
 report_type report_html = text;
 bool        report_all = FALSE;
 /* Parameters used by the sort routine to govern its actions */
     /*
      * Sort the data in finishing order
      */
-    if( ck_data( leg, C_END ) )
-        return;                                  /* Check data for this leg */
+    ck_data( leg, C_END );                      /* Check data for this leg */
     sort_team_data( leg, S_FIN, true );         /* Sort the data */
     /*
      * Now print the data on the printer
 void p_place( ty_s_data * ptr, int leg, unsigned k )
+{
     if( k < sort_num )
+    {
         print( "%4.4s %4d %8s  ",
-               pr_place( ptr->place, ptr->flags.bad_times, ptr->flags.vet_check && (leg == 0) ),
+               px_place(-1, ptr->place, false, false, ptr->flags ),
                ptr->team, time_fa( ptr->leg[leg], ptr->flags.disqualified ) );
+    }
     else
+    {
         print( "%20s", "" );
+    }
     if( found )
+    {
         print( "%4d %4.4s %8s  ",
                ptra->team,
-               pr_place( ptra->place, ptra->flags.bad_times, ptra->flags.vet_check && (leg == 0) ),
+               px_place( -1, ptra->place, false, false, ptra->flags ),
                time_fa( ptra->leg[leg], ptra->flags.disqualified ) );
+    }
     else
+    {
         print( "%20s", "" );
     /*
      * Sort the data in finishing order
      */
-    if( ck_data( leg, C_ELAPSED ) )
-        return;                                     /* Check data for this leg */
+    ck_data( leg, C_ELAPSED );                      /* Check data for this leg */
     sort_team_data( leg, S_IFIN, true );            /* Sort the data on elapsed time */
     /*
      * Now print the data on the printer
 void pe_place( ty_s_data * ptr, int leg, unsigned k )
+{
     if( k < sort_num )
+    {
         print( "%4.4s %4d %8s  ",
-               pr_place( ptr->place, ptr->flags.bad_times, ptr->flags.vet_check && (leg == 0) ),
+               px_place( -1, ptr->place, false, false, ptr->flags ),
                ptr->team,
                time_fa( ptr->lege[leg], ptr->flags.disqualified ) );
+    }
     else
+    {
+    }
     if( found )
+    {
         print( "%4d %4.4s %8s  ",
                ptra->team,
-               pr_place( ptra->place, ptra->flags.bad_times, ptra->flags.vet_check && (leg == 0) ),
+               px_place( -1, ptra->place, false, false, ptra->flags ),
                time_fa( ptra->lege[leg], ptra->flags.disqualified ) );
+    }
     else
+    {
         print( "%20s", "" );
     int         lcount;
     bool        isNeClass = false;
     int         place;
-    if( ck_data( -1, C_ELAPSED ) )
+    ck_data( -1, C_ELAPSED );
-        return;
     /*
     **  Sort on every thing
     **  Then generate all the stats too
     */
     do_big_sort();
         return;
     /*
      * Print out the data
      */
-    print_class_header( -1, TRUE );                      /* Print the header */
+    print_class_header( -1, TRUE );                     /* Print the header */
-    ptr = sort_data;
     sort_team_data( 0, S_L, true );                     /* Re-sort on elapsed time */
     lcount = 0;
     for( ptr = sort_data, i = 0; i < sort_num; i++, ptr++ )
+    {
         if ( ptr->teamclass == config.nonequestrian_class )
         **      - Place within complete field
         **      - Team number - with HTML reference to team file
         **      - Class
         */
         if ( report_html == printed && lcount % 5 == 4 ) print_underline( TRUE );
-        print( "%4.4s ", pn_place( team_buf.leg[0].l_place, ptr->flags.bad_times, ptr->flags.vet_check, ptr->flags.non_equestrian ) );
+        print( "%4.4s ", px_place( 0, team_buf.leg[0].l_place, false, true, ptr->flags ) );
         if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "name" ,"html")), team_buf.numb );
         print( "%4d",  team_buf.numb );
         if ( report_html == html ) print( "</A>" );
         print( " %-*s", 3, team_buf.teamclass == 0 ? "" : config.team_class[team_buf.teamclass - 1].abr );
         **      - End place
         */
         for( j = 1; j <= config.num_legs; j++ )
+        {
             bool isEquestrianLeg = (j == config.equestrian_leg && team_buf.flags.non_equestrian);
-            bool afterEquestrianLeg = (team_buf.flags.non_equestrian && j > config.equestrian_leg);
             /*
             **  Ensure that non-equestrian leg data is not displayed
             */
             if ( isEquestrianLeg )
+            {
+            }
             else
+            {
                 print( "  %-8s %4.4s %4.4s",
                     time_a( team_buf.leg[j].elapsed ),
-                    pr_place( team_buf.leg[j].l_place, ptr->flags.bad_times, ptr->flags.vet_check && (j == 0) ),
+                    px_place( j, team_buf.leg[j].l_place, false, false, ptr->flags ),
-                    pn_place( team_buf.leg[j].le_place,ptr->flags.bad_times, ptr->flags.vet_check && (j == 0), afterEquestrianLeg )
+                    px_place( j, team_buf.leg[j].le_place,true , true, ptr->flags )
                   );
+            }
+        }
        /*
         */
 //        print( "  %-8s ",  time_a( team_buf.leg[0].elapsed ) );
         print( "  %-8s ", time_a( ptr->lege[0] ) );
         if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">",url_encode(p_filename(filebase, config.team_class[team_buf.teamclass - 1].abr ,"html")), team_buf.numb );
-        print( "%-4.4s", pn_place( team_buf.leg[0].lc_place, ptr->flags.bad_times, ptr->flags.vet_check, ptr->flags.non_equestrian && 0 ) );
+        print( "%-4.4s", px_place( 0, team_buf.leg[0].lc_place, false, false, ptr->flags) );
         if ( report_html == html ) print( "</A>" );
         if ( report_html == printed && lcount %5 == 4 ) print_underline( FALSE );
         lcount++;
         print( "\n" );
+    }
         **      - Team number - with HTML reference to team file
         **      - Class
         */
         if ( report_html == printed && lcount %5 == 4 ) print_underline( TRUE );
-        print( "%4.4s ", pn_place( team_buf.leg[0].lc_place, flags , ptr->flags.vet_check, eflags ) );
+        print( "%4.4s ", px_place( 0, team_buf.leg[0].lc_place, false, false, ptr->flags) );
         if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "name" ,"html")), team_buf.numb );
         print( "%4d",  team_buf.numb );
         if ( report_html == html ) print( "</A>" );
         print( " %-*s", 3, team_buf.teamclass == 0 ? "" : config.team_class[team_buf.teamclass - 1].abr );
         for( j = 1; j <= config.num_legs; j++ )
+        {
             bool isEquestrianLeg = (j == config.equestrian_leg && (ptr->teamclass == config.nonequestrian_class || ptr->flags.non_equestrian));
-            bool afterEquestrianLeg = ((ptr->teamclass == config.nonequestrian_class || ptr->flags.non_equestrian) && j > config.equestrian_leg);
             /*
             **  Ensure that non-equestrian leg data is not displayed
             */
             if ( isEquestrianLeg )
                 print( "  %-8s %4.4s %4.4s", "-- NE --", "NE","NE");
+            }
             else
+            {
                 print( "  %-8s %4.4s %4.4s", time_a( team_buf.leg[j].elapsed ),
-                       pr_place( team_buf.leg[j].lc_place,  flags, ptr->flags.vet_check && (j == 0) ),
+                       px_place( j, team_buf.leg[j].lc_place,  false, false, ptr->flags ),
-                       pn_place( team_buf.leg[j].lec_place, flags, ptr->flags.vet_check && (j == 0), afterEquestrianLeg ) );
+                       px_place( j, team_buf.leg[j].lec_place, true , true, ptr->flags ) );
+            }
+        }
         /*
         **  Print the trailer
         */
         /* print( "  %-8s ", time_a( team_buf.leg[0].elapsed ) ); */
         print( "  %-8s ", time_a( ptr->lege[0] ) );
         if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "finish" ,"html")), team_buf.numb );
-        print( "%4.4s", pn_place( team_buf.leg[0].l_place, flags , ptr->flags.vet_check, ptr->flags.non_equestrian));
+        print( "%4.4s", px_place( 0, team_buf.leg[0].l_place, false, true, ptr->flags));
         if ( report_html == html ) print( "</A>" );
         if ( report_html == printed && lcount %5 == 4 ) print_underline( FALSE );
         lcount++;
         print( "\n" );
     pri_name_index_body();
+}
 /*========================================================================
+ *
- *  Print final results
+ *  Print final results in Team Order
+ *
  *  Purpose:
  *      This function is called to Print final results in Team Order
+ *
  *  Parameters:
     team_type   team_buf;
     unsigned    i;
     int         j;
     int         lcount;
-    if( ck_data( -1, C_ELAPSED ) )
+    ck_data( -1, C_ELAPSED );
-        return;
     /*
     **  Sort on every thing
     **  Then generate all the stats too
     */
     do_big_sort();
         **      - Place within complete field
         **      - Team number - with HTML reference to team file
         **      - Class
         */
         if ( report_html == printed && lcount %5 == 4 ) print_underline( TRUE );
-        print( "%4.4s ", pn_place( team_buf.leg[0].l_place, ptr->flags.bad_times, ptr->flags.vet_check, ptr->flags.non_equestrian ) );
+        print( "%4.4s ", px_place( 0, team_buf.leg[0].l_place, false, true, ptr->flags ) );
         if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "name" ,"html")), team_buf.numb );
         print( "%4d",  team_buf.numb );
         if ( report_html == html ) print( "</A>" );
         print( " %-*s", 3, team_buf.teamclass == 0 ? "" : config.team_class[team_buf.teamclass - 1].abr );
         **      - End place
         */
         for( j = 1; j <= config.num_legs; j++ )
+        {
             bool isEquestrianLeg = (j == config.equestrian_leg && team_buf.flags.non_equestrian);
-            bool afterEquestrianLeg = (team_buf.flags.non_equestrian && j > config.equestrian_leg);
             /*
             **  Ensure that non-equestrian leg data is not displayed
             */
             if ( isEquestrianLeg )
+            {
+            }
             else
+            {
                 print( "  %-8s %4.4s %4.4s",
                     time_a( team_buf.leg[j].elapsed ),
-                    pr_place( team_buf.leg[j].l_place, ptr->flags.bad_times, ptr->flags.vet_check && (j == 0) ),
+                    px_place(j, team_buf.leg[j].l_place, false, false, ptr->flags ),
-                    pn_place( team_buf.leg[j].le_place,ptr->flags.bad_times, ptr->flags.vet_check && (j == 0), afterEquestrianLeg )
+                    px_place(j, team_buf.leg[j].le_place,true,  true, ptr->flags )
                   );
+            }
+        }
        /*
         */
 //        print( "  %-8s ",  time_a( team_buf.leg[0].elapsed ) );
         print( "  %-8s ", time_a( ptr->lege[0] ) );
         if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">",url_encode(p_filename(filebase, config.team_class[team_buf.teamclass - 1].abr ,"html")), team_buf.numb );
-        print( "%-4.4s", pn_place( team_buf.leg[0].lc_place, ptr->flags.bad_times, ptr->flags.vet_check, ptr->flags.non_equestrian && 0 ) );
+        print( "%-4.4s", px_place( 0, team_buf.leg[0].lc_place, false, false, ptr->flags ) );
         if ( report_html == html ) print( "</A>" );
         if ( report_html == printed && lcount %5 == 4 ) print_underline( FALSE );
         lcount++;
         print( "\n" );
+    }
         g_record( ptr->team, &team_buf );
         print( "%4d %4.4s %-*s",
                team_buf.numb,
-               pi_place( team_buf.leg[config.num_legs].le_place,
+               px_place(-1, team_buf.leg[config.num_legs].le_place, false, false, ptr->flags ),
-                         ptr->flags.disqualified, team_buf.leg[0].elapsed ),
 ,
-               team_buf.teamclass ==
-? "" : config.team_class[team_buf.teamclass - 1].abr );
+               team_buf.teamclass == 0 ? "" : config.team_class[team_buf.teamclass - 1].abr );
         for( j = 1; j <= config.num_legs; j++ )
+        {
             print( "  %-8s %4.4s %4.4s",
-                   time_fa( team_buf.leg[j].elapsed,
+                   time_fa( team_buf.leg[j].elapsed, ptr->flags.disqualified ),
-                            ptr->flags.disqualified ),
-                   pi_place( team_buf.leg[j].l_place, ptr->flags.disqualified,
+                   px_place(j, team_buf.leg[j].l_place, false, true, ptr->flags ),
-                             team_buf.leg[j].elapsed ),
-                   pi_place( team_buf.leg[j].le_place,
+                   px_place(j, team_buf.leg[j].le_place, false, true, ptr->flags )
-                             ptr->flags.disqualified,
+                   );
-                             team_buf.leg[j].elapsed ) );
+        }
         print( "  %-8s %4.4s\n",
                time_fa( team_buf.leg[0].elapsed, ptr->flags.disqualified ),
-               pi_place( team_buf.leg[config.num_legs].lec_place,
+               px_place(0, team_buf.leg[config.num_legs].lec_place, false, false, ptr->flags )
-                         ptr->flags.disqualified, team_buf.leg[0].elapsed ) );
+               );
+    }
     print_class_stats( -1, FALSE );             /* Print statistics */
     print_legend(-1, 1);                        /* Print the legend */
     close_printer();                            /* Close the printer */
         **  Now read in the team record
         */
         g_record( ptr->team, &team_buf );
         print( "%4d %4.4s %-*s",
                team_buf.numb,
-               pi_place( team_buf.leg[config.num_legs].lec_place,
+               px_place(-1, team_buf.leg[config.num_legs].lec_place, false, false, ptr->flags ),
-                         ptr->flags.disqualified, team_buf.leg[0].elapsed ),
 ,
-               team_buf.teamclass ==
-? "" : config.team_class[team_buf.teamclass - 1].abr );
+               team_buf.teamclass == 0 ? "" : config.team_class[team_buf.teamclass - 1].abr );
         for( j = 1; j <= config.num_legs; j++ )
+        {
             print( "  %-8s %4.4s %4.4s",
-                   time_fa( team_buf.leg[j].elapsed,
+                   time_fa( team_buf.leg[j].elapsed, ptr->flags.disqualified ),
-                            ptr->flags.disqualified ),
-                   pi_place( team_buf.leg[j].lc_place,
+                   px_place(j, team_buf.leg[j].lc_place,  false, true, ptr->flags ),
-                             ptr->flags.disqualified,
-                             team_buf.leg[j].elapsed ),
-                   pi_place( team_buf.leg[j].lec_place,
+                   px_place(j, team_buf.leg[j].lec_place, false, true, ptr->flags ) );
-                             ptr->flags.disqualified,
-                             team_buf.leg[j].elapsed ) );
+        }
         print( "  %-8s %4.4s\n",
                time_fa( team_buf.leg[0].elapsed, ptr->flags.disqualified ),
-               pi_place( team_buf.leg[config.num_legs].le_place,
+               px_place(0, team_buf.leg[config.num_legs].le_place, false, false, ptr->flags ) );
-                         ptr->flags.disqualified, team_buf.leg[0].elapsed ) );
+    }
     print_class_stats( last_class, FALSE );
     print_legend(last_class, 1);
     close_printer();
     pri_summary();
     pri_awards_html();
     pri_awards();
     pri_master_index();
+    report_html = html;
+    pri_interim();
+    report_html = text;
     pri_interim();
     report_all = FALSE;
+}
     for( i = 1, count = 0; i <= config.num_class; i++ )
+    {
         if (!config.team_class[i - 1].abr[0])
             continue;
-#if 0
-        /*
-        **  Skip any non-equestrian class in the legend
-        **  Don't want to tell the general user whats goes on, unless we actually
-        **  creating the non-equestrian report.
-        */
-        if ( class != config.nonequestrian_class  && i == config.nonequestrian_class )
-            continue;
-#endif
         if ( report_html == html ) print( "<A HREF=\"%s\">",url_encode(p_filename(filebase, config.team_class[i - 1].abr ,"html")) );
         print( "%-*s", 3, config.team_class[i - 1].abr );
         if ( report_html == html ) print( "</A>" );
         print( " : %-*s  ", LEN_CLASS_NAME, config.team_class[i - 1].full_name );
         print( "\nTiming and Results by\n" );
         print( "Embedded Solutions\n" );
+    }
+}
-/*========================================================================
- *
- *  Return place data
- *
- *  Purpose:
- *      This function is called to return place data
- *
- *      This routine is called to fill a print team_buffer - to allow for
- *      multiple calls to this function ( before the data is used ) a number
- *      of static team_buffers are maintained
- *
- *  Parameters:
- *      num         place - if a valid time
- *      disq        Disqualified flag
- *      time        Time data is based on
- *
- *  Returns:
- *      This function returns a pointer to the character string for the
- *      number or a pointer to a status string.
- *
- *========================================================================*/
-const char       *pi_place( int num, int disq, time_t time )
-{
-    static char store[2][5];                     /* 2 stores for 4 digit numbers */
-    static int  i = 0;                           /* Current index into store */
-    static const char *dis = "D";                /* Disqualified */
-    static const char *non = "-";                /* Invalid time */
-    if( disq )                                   /* Disqualified team */
-        return ( dis );
-    if( time <= 0 )                              /* Unknown time */
-        return ( non );
-    i++;
-    if( i >= 2 )
-        i = 0;                                   /* Select next entry */
-    sprintf( store[i], "%4d", num );
-    return ( store[i] );
-}
 /*========================================================================
+ *
- *  Return place data
+ *  Return place data or NE flag
+ *
  *  Purpose:
  *      This function is called to Return place data
+ *
  *      This routine is called to fill a print team_buffer - to allow for
  *      multiple calls to this function ( before the data is used ) a number
  *      of static team_buffers are maintained
+ *
  *  Parameters:
+ *      leg         Leg number being processed or
+ *                  -1: Unplaced on any bad flag
- *      num         place - if valid
+ *      num         place - if valid time
+ *      epMode      true:  Event Time Mode - Show V and NE flags
- *      disq        Disqualified flag
+ *                  false: Leg Time Mode -
+ *      neMode      true: Display NE for NE Teams
+ *                  false: Display data for NE teams
- *      vflag       Team is vet checked
+ *      flags       Team flags
+ *
  *  Returns:
  *      This function returns a pointer to the character string for the
  *      number or a pointer to a status string.
+ *
  *========================================================================*/
-const char *pr_place( int num, int disq, bool vflag )
+const char *px_place( int leg, int num, bool epMode, bool neMode, team_flags flags )
+{
     static char store[2][5];                     /* 2 stores for 4 digit numbers */
     static int  i = 0;                           /* Current index into store */
     static const char *dis = "U";
+    static const char *alt = "NE";
     static const char *vet = "V";
-    if (vflag)
+    if (flags.bad_times || flags.disqualified || !flags.valid)
-        return (vet);
+        return dis;
-    if( disq )
+    if (leg == -1 && flags.vet_check )
-        return ( dis );
+        return vet;
-    i++;
-    if( i >= 2 )
-        i = 0;                                   /* Select next entry */
+    if (neMode && flags.non_equestrian && (leg >= config.equestrian_leg || leg == 0))
-    sprintf( store[i], "%4d", num );
-    return ( store[i] );
+        return alt;
+    if (epMode && flags.vet_check && leg >= config.equestrian_leg)
-}
+        return vet;
-/*========================================================================
- *
- *  Return place data or NE flag
- *
- *  Purpose:
- *      This function is called to Return place data
- *
- *      This routine is called to fill a print team_buffer - to allow for
- *      multiple calls to this function ( before the data is used ) a number
+    if ( flags.vet_check && (leg == config.equestrian_leg || leg == 0))
- *      of static team_buffers are maintained
- *
- *  Parameters:
- *      num         place - if valid time
- *      disq        Disqualified flag
- *      vflag       Flag VetChecked team
- *      flag        Flag NE data
- *
- *  Returns:
+        return vet;
- *      This function returns a pointer to the character string for the
- *      number or a pointer to a status string.
- *
- *========================================================================*/
-const char *pn_place( int num, int disq, bool vflag, bool flag )
-{
-    static char store[2][5];                     /* 2 stores for 4 digit numbers */
-    static int  i = 0;                           /* Current index into store */
-    static const char *dis = "U";
-    static const char *alt = "NE";
-    static const char *vet = "V";
-    if (vflag)
-        return (vet);
-    if( disq )
+    if (num <= 0)
-        return ( dis );
+        return dis;
-    if (flag)
-        return ( alt );
     i++;
     if( i >= 2 )
         i = 0;                                   /* Select next entry */
     sprintf( store[i], "%4d", num );
  *      mode            Either end or elapsed times to be tested
  *                          C_END     - Printing in Leg Finishing Time
  *                          C_DISQUAL - Interim results
  *                          C_ELAPSED - Elapsed times
+ *
- *  Returns:
- *      Returns FALSE if the report operation is to be aborted
+ *
  *========================================================================*/
-bool ck_data( int leg, int mode )
+void ck_data( int leg, int mode )
+{
     ty_s_data  *ptr;
     unsigned    i;
     int         bad = 0;
     int         k;
         // If the team is duff, then don;t include in Event or Leg Calcs
         if( !ptr->flags.valid || ptr->flags.bad_times || ptr->flags.disqualified)
+        {
-            ptr->flags.notInEP = TRUE;
             ptr->flags.notInLP = TRUE;
+        }
         else
+        {
             // If any of the leg times are duff, then don't include the leg Event Calcs
                 bad_leg = t[leg] <= 0;
+            }
             if( bad_leg )
+            {
-                ptr->flags.notInEP = TRUE;
                 if ( ! report_all )
+                {
                     qDebug( "Team with incorrect time information: %d", ptr->team  );
                     bad++;
+                }
     if( bad )
+    {
         qDebug( "%d teams with incorrect times. These have been flagged as unplaced", bad );
+    }
-    return ( FALSE );
+}
 /*========================================================================
+ *
  *  Update placing information
+ *
  *========================================================================*/
 void srt_place(void)
+{
-    if( ck_data( -1, C_ELAPSED ) )
+    ck_data( -1, C_ELAPSED );
-        return;
     do_big_sort();
     /*
      * Generate the stats
      */
         sort_team_data( i, S_L, sortWithEq );
         for( j = 1, k = 1, q = 1, ptr = sort_data; j <= sort_num; ptr++, j++ )
+        {
             sort_aux[ptr->team].team = ptr->team;
+            if (i == config.equestrian_leg || i == 0) {
+                if (ptr->flags.bad_times || ptr->flags.disqualified || ptr->flags.vet_check) {
+                    if (ptr->isNeData) {
+                        sort_aux[ptr->team].lq_place[i] = -1;
+                    } else {
+                        sort_aux[ptr->team].l_place[i] = -1;
+                    }
+                    continue;
+                }
+            }
+            // Flag as unplaced NE teams on the EQ leg
+            // Flag as unplaced in overall (leg:0) NE teams
+            if ( (i == config.equestrian_leg || i == 0 ) && ptr->flags.non_equestrian ) {
+                if (ptr->isNeData) {
+                    sort_aux[ptr->team].lq_place[i] = -1;
+                } else {
+                    sort_aux[ptr->team].l_place[i] = -1;
+                }
+                continue;
+            }
             if (ptr->isNeData) {
                 sort_aux[ptr->team].lq_place[i] = q++;
             } else {
                 sort_aux[ptr->team].l_place[i] = k++;
+            }
         **  Then save the teams place at the end of each leg
         */
         sort_team_data( i, S_LE, sortWithEq);
         for( j = 1, k = 1, q = 1, ptr = sort_data; j <= sort_num; ptr++, j++ )
+        {
+            if (i == 0 || i == config.equestrian_leg || sort_afterEquestrianLeg ) {
+                if (ptr->flags.bad_times || ptr->flags.disqualified || ptr->flags.vet_check) {
+                    if (ptr->isNeData) {
+                        sort_aux[ptr->team].leq_place[i] = -1;
+                    } else {
+                        sort_aux[ptr->team].le_place[i] = -1;
+                    }
+                    continue;
+                }
+            }
+            // Flag as unplaced NE teams on the EQ leg
+            // Flag as unplaced NE teams after the EQ leg
+            // Flag as unplaced in overall (leg:0) NE teams
+            if ( (i == config.equestrian_leg || sort_afterEquestrianLeg || i == 0 ) && ptr->flags.non_equestrian ) {
+                if (ptr->isNeData) {
+                    sort_aux[ptr->team].leq_place[i] = -1;
+                } else {
+                    sort_aux[ptr->team].le_place[i] = -1;
+                }
+                continue;
+            }
             if (ptr->isNeData) {
                 sort_aux[ptr->team].leq_place[i] = q++;
             } else {
                 sort_aux[ptr->team].le_place[i] = k++;
+            }
             else {
                 if (ptr->isNeData)
                     isNe = true;
+            }
+            // Flag as unplaced NE teams on the EQ leg
+            if (i == 0 || i == config.equestrian_leg) {
+                if (ptr->flags.bad_times || ptr->flags.disqualified || ptr->flags.vet_check) {
+                    if (isNe) {
+                        sort_aux[ptr->team].lq_place[i] = -1;
+                    } else {
+                        sort_aux[ptr->team].lc_place[i] = -1;
+                    }
+                    continue;
+                }
+            }
+            if ( i == config.equestrian_leg && ptr->flags.non_equestrian ) {
+                if (ptr->isNeData) {
+                    sort_aux[ptr->team].lq_place[i] = -1;
+                } else {
+                    sort_aux[ptr->team].lc_place[i] = -1;
+                }
+                continue;
+            }
             if (isNe) {
                 if( teamclassq != ptr->teamclass )
+                {
                     q = 1;
                     teamclassq = ptr->teamclass;
                     k = 1;
                     teamclass = ptr->teamclass;
+                }
                 sort_aux[ptr->team].lc_place[i] = k++;
+            }
+        }
         /*
         **  Sort on end time per class
         **  Then save the teams place at the end of each leg per class
             else {
                 if (ptr->isNeData)
                     isNe = true;
+            }
+            if (i == 0 || i == config.equestrian_leg || sort_afterEquestrianLeg) {
+                if (ptr->flags.bad_times || ptr->flags.disqualified || ptr->flags.vet_check) {
+                    if (isNe) {
+                        sort_aux[ptr->team].leq_place[i] = -1;
+                    } else {
+                        sort_aux[ptr->team].lec_place[i] = -1;
+                    }
+                    continue;
+                }
+            }
+            // Flag as unplaced NE teams on the EQ leg
+            // Flag as unplaced NE teams after the EQ leg
+            // Flag as unplaced in overall (leg:0) NE teams
+            if ( (i == config.equestrian_leg || sort_afterEquestrianLeg || i == 0 ) && ptr->flags.non_equestrian ) {
+                if (ptr->isNeData) {
+                    sort_aux[ptr->team].leq_place[i] = -1;
+                } else {
+                    sort_aux[ptr->team].lec_place[i] = -1;
+                }
+                continue;
+            }
             if (isNe) {
                 if( teamclassq != ptr->teamclass )
+                {
                     q = 1;
                     teamclassq = ptr->teamclass;
                     k = 1;
                     teamclass = ptr->teamclass;
+                }
                 sort_aux[ptr->team].lec_place[i] = k++;
+            }
+        }
+    }
     /*
     **  Write the place information back to disk for use in the displays
     ty_s_data  *ptr;
     sort_leg = leg;                              /* Leg is global for the comparison function */
     sort_mode = mode;                            /* Mode is global for compare function */
     sort_withEquestrian = withEq;                /* Mode is global for compare function */
+    sort_afterEquestrianLeg = ( config.equestrian_leg && leg > config.equestrian_leg);
     qsort( ( char * ) sort_data, sort_num, sizeof( ty_s_data ), sort_comp );
     /*
      * Insert "place data" into the sorted data
     for( j = 1; j <= sort_num; j++, ptr++ )
+    {
         ptr->place = j;
+    }
-    qDebug() << "sort_team_data: Leg:" << leg << ",M:" << mode << ",E:" << withEq;
+    //qDebug() << "sort_team_data: Leg:" << leg << ",M:" << mode << ",E:" << withEq;
-    //for( j = 1, ptr = sort_data; j <= sort_num; j++, ptr++ )
-    //{
-    //    qDebug() << "T:" << ptr->team << " Class:" << ptr->teamclass << " V:" << ptr->flags.valid << "NE:" << ptr->isNeData << "B:" << ptr->flags.bad_times <<"D:" << ptr->flags.disqualified <<"V:" << ptr->flags.vet_check << "LP:" << ptr->flags.notInLP << "EP:" << ptr->flags.notInEP <<"F:" << ptr->flags.notInFastest;
-    //}
+}
 /*========================================================================
+ *
         aNoSort = a->flags.notInLP;
         bNoSort = b->flags.notInLP;
+    }
     if ( sort_withEquestrian && (sort_mode == S_LC || sort_mode == S_L ) ) {
-        if (a->flags.non_equestrian || a->flags.vet_check)
+        if (a->flags.vet_check)
             aNoSort = true;
-        if (b->flags.non_equestrian || b->flags.vet_check)
+        if (b->flags.vet_check)
             bNoSort = true;
+    }
     if (a->flags.bad_times || a->flags.disqualified || !a->flags.valid)
         aNoSort = true;
             aNoSort = true;
         if (b->flags.vet_check)
             bNoSort = true;
+    }
+    // On the Equestrian Leg, vetted out teams are treated as disqualified
+    if (sort_leg == config.equestrian_leg || (sort_afterEquestrianLeg && ( sort_mode == S_LE || sort_mode == S_LEC))) {
+        if (a->flags.vet_check)
+            aNoSort = true;
+        if (b->flags.vet_check)
+            bNoSort = true;
+    }
     if (aNoSort && bNoSort)
         return ( a->team - b->team );
     if (aNoSort || bNoSort)
         return ( aNoSort ? 1 : -1 );
             /* Good times better than NE */
             return ( a->flags.non_equestrian ? 1 : -1 );
+        }
+    }
-//    if( a->flags.bad_times || b->flags.bad_times || ( sort_withEquestrian && a->flags.non_equestrian) || (sort_withEquestrian && b->flags.non_equestrian))  /* Valid data has precedence */
-//    {
-//        if( a->flags.bad_times && b->flags.bad_times )
-//        {
-//            return ( a->team - b->team );
-//        }
-//        else if( a->flags.bad_times || b->flags.bad_times )
-//        {
-//            return ( a->flags.bad_times ? 1 : -1 );
-//        }
-//        else if ( sort_leg != 0 && (sort_mode == S_L || sort_mode == S_LC))
-//        {
-//            /* */
-//        }
-//        if( sort_mode != S_FIN && sort_mode != S_IFIN )
-//        {
-//            if( a->flags.non_equestrian && b->flags.non_equestrian )
-//            {
-//                /*
-//                **  Both are non equestrian
-//                **  Let the time sort operate ...
-//                */
-//                //return ( a->team - b->team );
-//            }
-//            else
-//            {
-//                /* One is equestrian */
-//                /* Good times better than NE */
-//                return ( a->flags.non_equestrian ? 1 : -1 );
-//            }
-//        }
-//    }
     /*
     **  Before we sort on times we must determine which time to
     **  use. Finish time, Leg end times, Leg Elapsed times.
     */
                 // Add a few flags to simplify processing
                 //  Vetted out teams to be included inthe fastest calcs - except for Equestian Leg
                 //  Bodgey teams are not sorted by place - only after all places and then by team number
                 ptr->flags.notInLP = 0;
-                ptr->flags.notInEP = 0;
                 ptr->flags.notInFastest = 0;
                 if ( ptr->flags.bad_times || ptr->flags.disqualified || !ptr->flags.valid) {
                     ptr->flags.notInLP = 1;
-                    ptr->flags.notInEP = 1;
                     ptr->flags.notInFastest = 1;
+                }
-                if (ptr->flags.vet_check) {
-                    ptr->flags.notInEP = 1;
-                }
-//                if (ptr->flags.non_equestrian)
-//                    ptr->flags.disqualified = true;
-//                if (ptr->flags.vet_check)
-//                    ptr->flags.disqualified = true;
                 ptr++;
                 sort_num++;
                 /*
                     ptr->isNeData = true;
                     ptr->lege[0] = 0;
                     for( j = 0; j < MAX_LEGS + 1; j++ )
+                    {
-                        if ( j == config.equestrian_leg )
+                        if ( (short)j == config.equestrian_leg )
+                        {
                             last->lege[j] = ptr->lege[j] = 0;
                             if ( config.equestrian_leg > 1 )
                                 last->leg[j] = ptr->leg[j] = ptr->leg[j-1];
+                        }
                     last->start = ptr->start = team_buf.leg[0].start;
                     ptr->teamclass = config.nonequestrian_class;
                     ptr->real_teamclass = team_buf.teamclass;
                     ptr->flags = team_buf.flags;
-//                    ptr->flags.disqualified = false;
                     ptr++;
                     sort_num++;
+                }
 #endif
+            }
+        }
+    }
     // Debug
-    qDebug() << "--- Start ---";
+//    qDebug() << "--- Start ---";
-    sort_team_data( 0, S_L, 1 );
+//    sort_team_data( 0, S_L, 1 );
-    for( j = 1, ptr = sort_data; j <= sort_num; j++, ptr++ )
+//    for( j = 1, ptr = sort_data; j <= sort_num; j++, ptr++ )
-    {
+//    {
-        qDebug() << "T:" << ptr->team
+//        qDebug() << "T:" << ptr->team
-                << "Class:" << ptr->teamclass
+//                << "Class:" << ptr->teamclass
-                << "NEData:" << (ptr->isNeData? 1:0)
+//                << "NEData:" << (ptr->isNeData? 1:0)
-                << "iLP:" << (ptr->flags.notInLP ? 1:0)
+//                << "iLP:" << (ptr->flags.notInLP ? 1:0)
-                << "iEP:" << (ptr->flags.notInEP ? 1:0)
-                << "iF:" << (ptr->flags.notInFastest ? 1:0)
+//                << "iF:" << (ptr->flags.notInFastest ? 1:0)
-                << "Valid:" << (ptr->flags.valid ? 1:0)
+//                << "Valid:" << (ptr->flags.valid ? 1:0)
-                << "NE:" << (ptr->flags.non_equestrian? 1:0)
+//                << "NE:" << (ptr->flags.non_equestrian? 1:0)
-                << "B:" << (ptr->flags.bad_times ? 1 : 0 )
+//                << "B:" << (ptr->flags.bad_times ? 1 : 0 )
-                << "D:" << (ptr->flags.disqualified ? 1:0 )
+//                << "D:" << (ptr->flags.disqualified ? 1:0 )
-                << "V:" << (ptr->flags.vet_check ? 1:0 )
+//                << "V:" << (ptr->flags.vet_check ? 1:0 )
-                << "LE0:" << ptr->lege[0]
+//                << "LE0:" << ptr->lege[0]
-                << "L0:" << ptr->leg[0]
+//                << "L0:" << ptr->leg[0]
-                << "LE1:" << ptr->lege[3]
+//                << "LE1:" << ptr->lege[3]
-                ;
+//                ;
-    }
+//    }
-    qDebug() << "-----------------------------------End---";
+//    qDebug() << "-----------------------------------End---";
     return ( TRUE );
+}
 /*========================================================================
+ *

Subversion Repositories svn1-original

(root)/Mara/branches/alternateUploadTimeFormat/report.cpp – Rev 354 → 355