WebSVN – svn1-original – Diff – /Mara/trunk/report.cpp

 #define S_LEC   4                                /* Leg end time per class */
 #define S_FIN   5                                /* Sort on finish time at given leg */
 #define S_TEAM  6                                /* Sort on team order */
 #define S_CLASS 7                                /* Sort on class/team order */
 #define S_LC_NE 8                                /* Elapsed times per class, with NE sorted by real class */
+#define S_IFIN  9                                /* Sort on elapsed time at given leg */
 /*
 **  Various checking modes
 */
 #define C_ELAPSED   1                            /* Check elapsed times */
      * Sort the data in finishing order
      */
     if( ck_data( leg, C_ELAPSED ) )
         return;                                  /* Check data for this leg */
-    sort_team_data( leg, S_L );                  /* Sort the data on elapsed time */
+    sort_team_data( leg, S_IFIN );               /* Sort the data on elapsed time */
     /*
      * Now print the data on the printer
      */
         **      - 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 ", pr_place( team_buf.leg[0].l_place, ptr->flags.bad_times ) );
+        print( "%4.4s ", pr_place( team_buf.leg[0].l_place, ptr->flags.bad_times || ptr->flags.non_equestrian ) );
         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 );
+            }
             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 ),
+                    pr_place( team_buf.leg[j].l_place, ptr->flags.bad_times || ptr->flags.non_equestrian ),
-                    pr_place( team_buf.leg[j].le_place,ptr->flags.bad_times )
+                    pr_place( team_buf.leg[j].le_place,ptr->flags.bad_times || ptr->flags.non_equestrian )
                   );
+            }
+        }
        /*
         */
 //        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", pr_place_ne( team_buf.leg[0].lc_place, ptr->flags.bad_times, ptr->flags.non_equestrian ) );
+        print( "%-4.4s", pr_place( team_buf.leg[0].lc_place, ptr->flags.bad_times ) );
         if ( report_html == html ) print( "</A>" );
         if ( report_html == printed && lcount %5 == 4 ) print_underline( FALSE );
         lcount++;
         print( "\n" );
+    }
     memset ( class_done, 0, sizeof(class_done));
     for( ptr = sort_data, i = 0; i < sort_num; i++, ptr++ )
+    {
+        int flags = 0;
         /*
         **  Detect a change in the "class"
         **  All data is within the one array of data
         **  Use the in-memory class as this MAY differ from that stored
         **  The non-equestrian class does this.
         /*
         **  Now read in the team record
         */
         g_record( ptr->team, &team_buf );
+        flags = ptr->flags.bad_times;
+        if ( ptr->teamclass != config.nonequestrian_class )
+        {
+            flags |= ptr->flags.non_equestrian;
+        }
         /*
         **  If printing an HTML report then we need to mark
         **  the entry with a reference so that we can link to it
         */
         **      - Team number - with HTML reference to team file
         **      - Class
         */
         if ( report_html == printed && lcount %5 == 4 ) print_underline( TRUE );
-        print( "%4.4s ", pr_place( team_buf.leg[0].lc_place, ptr->flags.bad_times ) );
+        print( "%4.4s ", pr_place( team_buf.leg[0].lc_place, 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 );
                 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,  ptr->flags.bad_times ),
+                       pr_place( team_buf.leg[j].lc_place,  flags ),
-                       pr_place( team_buf.leg[j].lec_place, ptr->flags.bad_times ) );
+                       pr_place( team_buf.leg[j].lec_place, 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", pr_place( team_buf.leg[0].l_place, ptr->flags.bad_times || (ptr->teamclass == config.nonequestrian_class)));
+        print( "%4.4s", pr_place( team_buf.leg[0].l_place, flags || (ptr->teamclass == config.nonequestrian_class)));
         if ( report_html == html ) print( "</A>" );
         if ( report_html == printed && lcount %5 == 4 ) print_underline( FALSE );
         lcount++;
         print( "\n" );
     csv_print( "%s", "Total Team Age");
     csv_print( "%s", "Flag:valid Team");
     csv_print( "%s", "Flag:bad_times" );
     csv_print( "%s", "Flag:disqualified" );
     csv_print( "%s", "Flag:non_equestrian" );
+    csv_print( "%s", "Flag:vet_check" );
     csv_print("\n");
     for( i = config.min_team; i <= config.max_team; i++ )
+    {
             csv_print( "%d", age_sum );
             csv_print( "%d", team_buf.flags.valid );
             csv_print( "%d", team_buf.flags.bad_times );
             csv_print( "%d", team_buf.flags.disqualified );
             csv_print( "%d", team_buf.flags.non_equestrian );
+            csv_print( "%d", team_buf.flags.vet_check );
 //How about class placings
             csv_print( "\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 not bad_times
- *      disq        Disqualified flag
- *      ne          Non Equestrian Flag
- *
- *  Returns:
- *      This function returns a pointer to the character string for the
- *      number or a pointer to a bad_times string.
- *
- *========================================================================*/
-const char *pr_place_ne( int num, int disq, int ne )
-{
-    static char store[2][5];                     /* 2 stores for 4 digit numbers */
-    static int  i = 0;                           /* Current index into store */
-    static const char *dis = "U";
-    if( disq && ! ne )
-         return ( dis );
-    if( ++i >= 2 )
-        i = 0;                                   /* Select next entry */
-    sprintf( store[i], "%4d", num );
-    return ( store[i] );
-}
-/*========================================================================
- *
  *  Check data for bad times
+ *
  *  Purpose:
  *      This function is called to Check data for bad times
  *      Scan the sort data structure and locate entries that have incorrect
             t = ptr->lege;
         else
             t = ptr->leg;
-        if ( leg >= 0 )
-        {
-            ptr->flags.bad_times = (ptr->flags.disqualified && ! ptr->flags.non_equestrian );
+        ptr->flags.bad_times = ptr->flags.disqualified;
-        }
-        else
-        {
-            ptr->flags.bad_times = ptr->flags.disqualified /*|| ptr->flags.non_equestrian */;
-        }
         if( ! ptr->flags.bad_times )
+        {
             if( leg <= 0 )
+            {
                 for( k = 0; k <= config.num_legs; k++ )
      * This simply the index into the array of data - after its been
      * sorted.
      */
     ptr = sort_data;
     for( j = 1; j <= sort_num; j++, ptr++ )
+    {
         ptr->place = j;
+    }
+}
 /*========================================================================
+ *
  *      a       - 1st record
  *      b       - 2nd record
+ *
  *  Returns:
  *      value to qsort
+ *      Return negative if 'a' is less than 'b',
+ *             zero if 'a' == 'b'
+ *             positive if 'a' > 'b'
+ *
  *========================================================================*/
 int sort_comp( const void * aa, const void * bb )
+{
     */
     if( sort_mode == S_LEC || sort_mode == S_LC || sort_mode == S_LC_NE )   /* Sort within a class */
         if( a->teamclass != b->teamclass )
             return ( a->teamclass - b->teamclass );
-#if 1
     /*
     **  Always put the nonequestrian_class at the end
     **  Simplifies the creation of ordered lists as these
     **  Entries are not present in the main body
     */
     if ( a->teamclass == config.nonequestrian_class ||  b->teamclass == config.nonequestrian_class )
+    {
         if ( a->teamclass == config.nonequestrian_class &&  b->teamclass == config.nonequestrian_class )
+        {
+            /*
+            **  Both are non equestrian
+            **      S_LC_NE - Elapsed times per class, with NE sorted by real class
+            **                Only used in awards
+            */
             if (sort_mode == S_LC_NE )
+            {
                 if ( a->real_teamclass != b->real_teamclass )
+                {
                     return ( a->real_teamclass - b->real_teamclass );
+                }
+            }
+        }
         else
+        {
+            /*
+            **  Only one in non-equestrian
+            **  Place Non-equestrian AFTER equestrian
+            */
             return ( a->teamclass == config.nonequestrian_class ? 1 : -1 );
+        }
+    }
-#endif
     /*
     **  Now we need to examine the times as we have sorted
     **  on every thing else.
     **
     **  team number
     **
     **  If not sorting within a class (ie Overall), then Non_Equestrian
     **  is better than a bad time. Places NE before disqualified
     **
-    **
-    **  Note: NE also have bad_times set
     */
-#if 1
-    if( a->flags.bad_times || b->flags.bad_times )  /* Valid data has precedence */
+    if( a->flags.bad_times || b->flags.bad_times || a->flags.non_equestrian || b->flags.non_equestrian)  /* Valid data has precedence */
+    {
         if( a->flags.bad_times && b->flags.bad_times )
+        {
-            if( a->flags.non_equestrian || b->flags.non_equestrian )
-            {
-                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 );
-                }
-            }
-            else
-            {
-                /* Neither is equestrian */
-                return ( a->team - b->team );
-            }
-        }
-        else
-            return ( a->flags.bad_times ? 1 : -1 );
-    }
-#else
-    if( a->flags.bad_times || b->flags.bad_times )  /* 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 )
-        else
+        {
             return ( a->flags.bad_times ? 1 : -1 );
-    }
+        }
-    /*
-    **  Not sorting within a class ie: Overall
-    **  Non-Equestrian is at the end, so that it doesn't get counted in the
-    **  finishing order
-    */
-    if( sort_mode == S_LE || sort_mode == S_L )     /* Sort NOT within a class */
+        if( sort_mode != S_FIN && sort_mode != S_IFIN )
-    {
-        if( a->flags.non_equestrian || b->flags.non_equestrian )
+        {
             if( a->flags.non_equestrian && b->flags.non_equestrian )
+            {
+                /*
+                **  Both are non equestrian
+                **  Let the time sort operate ...
+                */
-                return ( a->team - b->team );
+                //return ( a->team - b->team );
+            }
             else
+            {
+                /* One is equestrian */
+                /* Good times better than NE */
                 return ( a->flags.non_equestrian ? 1 : -1 );
+            }
+        }
+    }
-#endif
     /*
     **  Before we sort on times we must determine which time to
     **  use. Finish time, Leg end times, Leg Elapsed times.
     */
       **    Sort on Elapsed times
       */
       case S_LC_NE:
       case S_LC:
       case S_L:
+      case S_IFIN:
         ta = a->lege[sort_leg];
         tb = b->lege[sort_leg];
         break;
       /*
                 ptr->start = team_buf.leg[0].start;
                 ptr->teamclass = team_buf.teamclass;
                 ptr->real_teamclass = team_buf.teamclass;
                 ptr->flags = team_buf.flags;
-                if (ptr->flags.non_equestrian)
+//                if (ptr->flags.non_equestrian)
-                    ptr->flags.disqualified = true;
+//                    ptr->flags.disqualified = true;
                 if (ptr->flags.vet_check)
                     ptr->flags.disqualified = true;
                 ptr++;
                 sort_num++;
                 /*
                 **  If non-equestrian support is enabled then
                 **  duplicate and modify data for the non-equestrian teams
                 **      - Change the class
                 **      - Modify the leg time
                     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->flags.disqualified = false;
                     ptr++;
                     sort_num++;
+                }
 #endif
         **  of the data can be trusted.
         **
         **  If the team has been disqualified, then don't use any
         **  of the data.
         */
-        if( ptr->flags.bad_times || ptr->flags.disqualified )
+        if( ptr->flags.bad_times || ptr->flags.disqualified  )
             continue;
+        /*
+        **  Ignore non-Equestrian, unless we are processing the psuedo NE class
+        */
+        if ( ptr->teamclass != config.nonequestrian_class && ptr->flags.non_equestrian)
+            continue;
         for( j = 0; j <= config.num_legs; j++ )
+        {
             if( ptr->lege[j] <= 0 )              /* Ignore bad data */
                 continue;

Subversion Repositories svn1-original

(root)/Mara/trunk/report.cpp – Rev 246 → 250