WebSVN – svn1 – Diff – /Mara/branches/QtMain/report.cpp

     "Eleventh"
 };
 int         sort_leg;
 int         sort_mode;
+bool        sort_withEquestrian;
 report_type report_html = text;
 bool        report_all = FALSE;
 /* Parameters used by the sort routine to govern its actions */
 #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 */
 #define C_END       2                            /* Check end times */
      * Sort the data in finishing order
      */
     if( ck_data( leg, C_END ) )
         return;                                  /* Check data for this leg */
-    sort_team_data( leg, S_FIN );                /* Sort the data */
+    sort_team_data( leg, S_FIN, true );         /* Sort the data */
     /*
      * Now print the data on the printer
      */
      * Sort the data in finishing order
      */
     if( ck_data( leg, C_ELAPSED ) )
         return;                                  /* Check data for this leg */
-    sort_team_data( leg, S_IFIN );               /* Sort the data on elapsed time */
+    sort_team_data( leg, S_IFIN, true );               /* Sort the data on elapsed time */
     /*
      * Now print the data on the printer
      */
     unsigned    i;
     int         j, last_class;
     char        *report_title;
     bool        class_done[MAX_CLASS+1];
     int         lcount;
+    bool        isNeClass = false;
+    int         place;
     if( ck_data( -1, C_ELAPSED ) )
         return;
     /*
     **  Sort on every thing
      * Print out the data
      */
     print_class_header( -1, TRUE );                      /* Print the header */
     ptr = sort_data;
-    sort_team_data( 0, S_L );                     /* Re-sort on elapsed time */
+    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 )
             continue;
         g_record( ptr->team, &team_buf );
         /*
+        ** If this is a NE team then dummy up some of the data that hasn't been stored in team_buf
+        */
+        if (ptr->flags.non_equestrian)
+        {
+            team_buf.leg[0].l_place = sort_aux[ptr->team].leq_place[0];
+            team_buf.leg[0].lc_place = sort_aux[ptr->team].lq_place[0];;
+        }
+        /*
         **  If printing an HTML report then we need to mark
         **  the entry with a reference so that we can link to it
         */
         if ( report_html == html )
+        {
         **      - 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 || ptr->flags.non_equestrian ) );
+        print( "%4.4s ", pn_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 );
         **      - Leg place
         **      - 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 ( j == config.equestrian_leg && team_buf.flags.non_equestrian )
+            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].l_place, ptr->flags.bad_times || ptr->flags.non_equestrian ),
+                    pr_place( team_buf.leg[j].l_place, ptr->flags.bad_times ),
-                    pr_place( team_buf.leg[j].le_place,ptr->flags.bad_times || ptr->flags.non_equestrian )
+                    pn_place( team_buf.leg[j].le_place,ptr->flags.bad_times, afterEquestrianLeg )
                   );
+            }
+        }
        /*
         */
 //        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( team_buf.leg[0].lc_place, ptr->flags.bad_times ) );
+        print( "%-4.4s", pn_place( team_buf.leg[0].lc_place, ptr->flags.bad_times, ptr->flags.non_equestrian && 0 ) );
         if ( report_html == html ) print( "</A>" );
         if ( report_html == printed && lcount %5 == 4 ) print_underline( FALSE );
         lcount++;
         print( "\n" );
+    }
     /*
      * Now produce a breakdown on a class by class basis
      * Now print out the class placement information
      */
-    sort_team_data( 0, S_LC );                 /* Generate class placement data */
+    sort_team_data( 0, S_LC, true );           /* Generate class placement data */
     last_class = -1;                           /* Invalid class to start with */
     memset ( class_done, 0, sizeof(class_done));
+    place = 1;
     for( ptr = sort_data, i = 0; i < sort_num; i++, ptr++ )
+    {
         int flags = 0;
+        bool eflags;
         /*
         **  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
                 print_class_stats( last_class, TRUE );
                 print_legend( last_class, 1 );
                 close_printer();
+            }
+            /*
+            ** Determine if this is the crazy dummy Non-equestrian class
+            */
+            isNeClass = (ptr->teamclass == config.nonequestrian_class );
+            place = 1;
             report_title = tprintf( "Category results for : %-*s", LEN_CLASS_NAME, ptr->teamclass == 0 ? "" : config.team_class[ptr->teamclass - 1].full_name );
             if( !open_printer( "", config.team_class[ptr->teamclass - 1].abr, 132, report_html, report_title ) )
                 continue;
             print_class_header( last_class = ptr->teamclass, TRUE );
         /*
         **  Now read in the team record
         */
         g_record( ptr->team, &team_buf );
         flags = ptr->flags.bad_times;
-        if ( ptr->teamclass != config.nonequestrian_class )
+        eflags = (ptr->teamclass != config.nonequestrian_class && ptr->flags.non_equestrian);
+        /*
+        ** Dummy up the data for the dummy nonEquestrian Class
+        ** Its not stored in the team_buf for backwards compatability
+        */
+        if( isNeClass)
+        {
+            for( j = 0; j <= config.num_legs; j++ )
+            {
+                team_buf.leg[j].lc_place = sort_aux[ptr->team].lq_place[j];
+                team_buf.leg[j].lec_place = sort_aux[ptr->team].leq_place[j];;
+            }
+        }
+        else
+        {
-            flags |= ptr->flags.non_equestrian;
+            if (ptr->flags.non_equestrian)
+            {
+                team_buf.leg[0].lc_place =  place++; //sort_aux[ptr->team].lq_place[0];
+                team_buf.leg[0].lec_place = sort_aux[ptr->team].leq_place[0];
+                eflags = false;
+            }
+        }
         /*
         **  If printing an HTML report then we need to mark
         **  the entry with a reference so that we can link to it
         */
         if ( report_html == html )
         **      - 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, flags ) );
+        print( "%4.4s ", pn_place( team_buf.leg[0].lc_place, flags , eflags ) );
         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 ( j == config.equestrian_leg && (ptr->teamclass == config.nonequestrian_class || ptr->flags.non_equestrian) )
+            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 ),
-                       pr_place( team_buf.leg[j].lec_place, flags ) );
+                       pn_place( team_buf.leg[j].lec_place, flags, afterEquestrianLeg ) );
+            }
+        }
         /*
         **  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, flags || (ptr->teamclass == config.nonequestrian_class)));
+        print( "%4.4s", pn_place( team_buf.leg[0].l_place, flags , ptr->flags.non_equestrian));
         if ( report_html == html ) print( "</A>" );
         if ( report_html == printed && lcount %5 == 4 ) print_underline( FALSE );
         lcount++;
         print( "\n" );
     if ( report_html == html ) print( "</A>" );
     /*
     **  Sort the data by class
     */
-    sort_team_data( 0, S_LC );     /* Generate class placement data */
+    sort_team_data( 0, S_LC, true );     /* Generate class placement data */
     last_class = -1;                /* Invalid class to start with */
     /*
     **  Process each category
     */
         header_done = false;
         /*
         **  Sort the data by class with NE data sorted by real class
         */
-        sort_team_data( 0, S_LC_NE );      /* Generate class placement data */
+        sort_team_data( 0, S_LC_NE, true );      /* Generate class placement data */
         last_class = -1;                   /* Invalid class to start with */
         /*
         **  Only process the Non Equestrian teams in this pass
         */
      * Print out the data
      */
     print_class_header( -1, FALSE );                     /* Print the header */
     ptr = sort_data;
-    sort_team_data( 0, S_TEAM );                   /* Re-sort on team number */
+    sort_team_data( 0, S_TEAM, true );                   /* Re-sort on team number */
     for( ptr = sort_data, i = 0; i < sort_num; i++, ptr++ )
+    {
         if ( ptr->teamclass == config.nonequestrian_class )
             continue;
     /*
      * Now produce a breakdown on a class by class basis
      * Now print out the class placement information
      */
-    sort_team_data( 0, S_CLASS );              /* Generate class placement data */
+    sort_team_data( 0, S_CLASS, true );              /* Generate class placement data */
     last_class = -1;                             /* Invalid class to start with */
     for( ptr = sort_data, i = 0; i < sort_num; i++, ptr++ )
+    {
         /*
+}
 /*========================================================================
+ *
+ *  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:
+ *      num         place - if not bad_times
+ *      disq        Disqualified flag
+ *      flag        Flag NE data
+ *
+ *  Returns:
+ *      This function returns a pointer to the character string for the
+ *      number or a pointer to a bad_times string.
+ *
+ *========================================================================*/
+const char *pn_place( int num, int disq, 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";
+    if( disq )
+        return ( dis );
+    if (flag)
+        return ( alt );
+    i++;
+    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
+ *
  *========================================================================*/
 void do_big_sort(void)
+{
-    int         i, k;                            /* Looooopy things */
+    int         i, k, q;                             /* Looooopy things */
     unsigned    j;
-    ty_s_data  *ptr;                             /* Pointer to sort data */
+    ty_s_data  *ptr;                                 /* Pointer to sort data */
     int         teamclass;                           /* Current class */
+    int         teamclassq;                          /* Current class */
     team_type   team_buf;
     for( i = 0; i <= config.num_legs; i++ )
+    {
+        bool sortWithEq =  (i == 0);
         /*
         **  Sort on leg elapsed time
         **  Then save the teams elapsed place in each leg
         */
-        sort_team_data( i, S_L );
+        sort_team_data( i, S_L, sortWithEq );
-        for( j = 1, k = 1, ptr = sort_data; j <= sort_num; ptr++, j++ )
+        for( j = 1, k = 1, q = 1, ptr = sort_data; j <= sort_num; ptr++, j++ )
+        {
-            if ( ptr->teamclass == config.nonequestrian_class )
-                continue;
-            sort_aux[ptr->team].l_place[i] = k++;
             sort_aux[ptr->team].team = ptr->team;
+            if (ptr->isNeData) {
+                sort_aux[ptr->team].lq_place[i] = q++;
+            } else {
+                sort_aux[ptr->team].l_place[i] = k++;
+            }
+        }
         /*
         **  Sort on leg end time
         **  Then save the teams place at the end of each leg
         */
-        sort_team_data( i, S_LE );
+        sort_team_data( i, S_LE, sortWithEq);
-        for( j = 1, k = 1, ptr = sort_data; j <= sort_num; ptr++, j++ )
+        for( j = 1, k = 1, q = 1, ptr = sort_data; j <= sort_num; ptr++, j++ )
+        {
-            if ( ptr->teamclass == config.nonequestrian_class )
+            if (ptr->isNeData) {
-                continue;
+                sort_aux[ptr->team].leq_place[i] = q++;
+            }
+            else {
-            sort_aux[ptr->team].le_place[i] = k++;
+                sort_aux[ptr->team].le_place[i] = k++;
+            }
+        }
         /*
         **  Sort on elapsed time per class
-        **  The save the teams elapsed place in each leg per class
+        **  Then save the teams elapsed place in each leg per class
         */
-        sort_team_data( i, S_LC );
+        sort_team_data( i, S_LC, sortWithEq );
         teamclass = -1;
+        teamclassq = -1;
-        for( k = 1, j = 1, ptr = sort_data; j <= sort_num; j++, ptr++ )
+        for( k = 1, j = 1, q = 1, ptr = sort_data; j <= sort_num; j++, ptr++ )
+        {
+            bool isNe = false;
+            if ( sortWithEq && ptr->teamclass == config.nonequestrian_class  ) {
+                if ( !ptr->isNeData)
+                    isNe = true;
+            }
+            else {
+                if (ptr->isNeData)
+                    isNe = true;
+            }
+            if (isNe) {
-            if( teamclass != ptr->teamclass )
+                if( teamclassq != ptr->teamclass )
+                {
+                    q = 1;
+                    teamclassq = ptr->teamclass;
+                }
+                sort_aux[ptr->team].lq_place[i] = q++;
-            {
+            }
+            else {
+                if( teamclass != ptr->teamclass )
+                {
-                k = 1;
+                    k = 1;
-                teamclass = ptr->teamclass;
+                    teamclass = ptr->teamclass;
+                }
+                sort_aux[ptr->team].lc_place[i] = k++;
+            }
-            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
         */
-        sort_team_data( i, S_LEC );
+        sort_team_data( i, S_LEC, sortWithEq );
         teamclass = -1;
+        teamclassq = -1;
-        for( k = 1, j = 1, ptr = sort_data; j <= sort_num; j++, ptr++ )
+        for( k = 1, j = 1, q = 1, ptr = sort_data; j <= sort_num; j++, ptr++ )
+        {
+            bool isNe = false;
+            if ( sortWithEq &&  ptr->teamclass == config.nonequestrian_class  ) {
+                if ( !ptr->isNeData)
+                    isNe = true;
+            }
+            else {
+                if (ptr->isNeData)
+                    isNe = true;
+            }
+            if (isNe) {
-            if( teamclass != ptr->teamclass )
+                if( teamclassq != ptr->teamclass )
+                {
+                    q = 1;
+                    teamclassq = ptr->teamclass;
+                }
+                sort_aux[ptr->team].leq_place[i] = q++;
-            {
+            }
+            else {
+                if( teamclass != ptr->teamclass )
+                {
-                k = 1;
+                    k = 1;
-                teamclass = ptr->teamclass;
+                    teamclass = ptr->teamclass;
+                }
+                sort_aux[ptr->team].lec_place[i] = k++;
+            }
-            sort_aux[ptr->team].lec_place[i] = k++;
+        }
+    }
     /*
     **  Write the place information back to disk for use in the displays
  *      This function is called to Sort in memory buffer
+ *
  *  Parameters:
  *      leg         Requested leg
  *      mode        Defines the sort mode
+ *      withEq      Sort with equestrian data (True=Normal)
+ *
  *  Returns:
  *      Nothing
+ *
  *========================================================================*/
-void sort_team_data( int leg, int mode )
+void sort_team_data( int leg, int mode, bool withEq )
+{
     unsigned    j;
     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 */
     qsort( ( char * ) sort_data, sort_num, sizeof( ty_s_data ), sort_comp );
     /*
      * Insert "place data" into the sorted data
     /*
     **  Sorting within a class
     **  First sort on the class
     */
-    if( sort_mode == S_LEC || sort_mode == S_LC || sort_mode == S_LC_NE )   /* Sort within a class */
+    if( sort_mode == S_LEC || sort_mode == S_LC || sort_mode == S_LC_NE ) {  /* Sort within a class */
-        if( a->teamclass != b->teamclass )
+        if (a->teamclass != b->teamclass)
             return ( a->teamclass - b->teamclass );
+    }
     /*
     **  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 ( sort_withEquestrian && ( 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
             return ( a->teamclass == config.nonequestrian_class ? 1 : -1 );
+        }
+    }
     /*
     **  Now we need to examine the times as we have sorted
     **  on every thing else.
     **
     **  If one of the teams has bad_times, then that team is placed
     **
     **  If not sorting within a class (ie Overall), then Non_Equestrian
     **  is better than a bad time. Places NE before disqualified
     **
     */
-    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 || ( 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 );
+        }
       default:
         return ( 0 );
+    }
     /*
+     ** If we are ignore Equestrian config then place the Equestrian data last
+    */
+#if 0
+    if (a->isNeData != b->isNeData) {
+         return ( a->isNeData ? 1 : -1 );
+    }
+#endif
+#if 1
+    if (sort_withEquestrian) {
+        if (a->isNeData != b->isNeData)
+            return ( a->isNeData ? 1 : -1 );
+    }
+#endif
+    if ( a->team == b->team) {
+        return ( a->isNeData ? 1 : -1 );
+    }
+    /*
     **  Finally. Compare the required team times
     */
     if( ta == tb )
         return ( a->team - b->team );
     if( ( ta > 0 ) && ( tb > 0 ) )
             g_record( team, &team_buf );
             if( team_buf.flags.valid )
+            {
                 last = ptr;
                 ptr->team = team;
+                ptr->isNeData = false;
                 for( j = 0; j < MAX_LEGS + 1; j++ )
+                {
                     ptr->lege[j] = team_buf.leg[j].elapsed;
                     ptr->leg[j] = team_buf.leg[j].end;
+                }
                 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)
 //                    ptr->flags.disqualified = true;
                 if (ptr->flags.vet_check)
                     ptr->flags.disqualified = true;
                 */
 #if 1
                 if ( config.nonequestrian_class && team_buf.flags.non_equestrian )
+                {
                     ptr->team = team;
+                    ptr->isNeData = true;
                     ptr->lege[0] = 0;
                     for( j = 0; j < MAX_LEGS + 1; j++ )
+                    {
                         if ( j == config.equestrian_leg )

Subversion Repositories svn1

(root)/Mara/branches/QtMain/report.cpp – Rev 315 → 357