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

                 /*
                 **  Ensure we have a valid team
                 **  Can't award disqualified teams
                 **  Can't award NE teams unless its a NE award
                 */
-                if ( ptr->flags.bad_times )
+                if ( ptr->flags.bad_times || ptr->flags.disqualified || ptr->flags.vet_check || !ptr->flags.valid )
                     break;
                 if ( ptr->teamclass != config.nonequestrian_class  && ptr->flags.non_equestrian )
                     break;
                     /*
                     **  Ensure we have a valid team
                     **  Can't award disqualified teams
                     **  Can't award NE teams unless its a NE award
                     */
-                    if ( ptr->flags.bad_times )
+                    if ( ptr->flags.bad_times || ptr->flags.disqualified || ptr->flags.vet_check || !ptr->flags.valid )
                         break;
                     if ( ptr->teamclass != config.nonequestrian_class  && ptr->flags.non_equestrian )
                         break;
  *      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
+ *      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 bad_times string.
+ *      number or a pointer to a status string.
+ *
  *========================================================================*/
 const char       *pi_place( int num, int disq, time_t time )
+{
  *      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
+ *      num         place - if valid
  *      disq        Disqualified flag
  *      vflag       Team is vet checked
+ *
  *  Returns:
  *      This function returns a pointer to the character string for the
- *      number or a pointer to a bad_times string.
+ *      number or a pointer to a status string.
+ *
  *========================================================================*/
 const char *pr_place( int num, int disq, bool vflag )
+{
  *      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
+ *      num         place - if valid time
  *      disq        Disqualified flag
  *      vflag       Flag VetChecked team
  *      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.
+ *      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 */
  *      and the report process can be aborted
+ *
  *  Parameters:
  *      leg             Leg to test
  *      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
+ *
  *========================================================================*/
             t = ptr->lege;
         else
             t = ptr->leg;
-        ptr->flags.bad_times = ptr->flags.disqualified;
+        // If the team is duff, then don;t include in Event or Leg Calcs
-        if( ! ptr->flags.bad_times )
+        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
             if( leg <= 0 )
+            {
                 for( k = 0; k <= config.num_legs; k++ )
+                {
                     if ( !(config.equestrian_leg && ptr->flags.non_equestrian && config.equestrian_leg == k  ))
                 bad_leg = t[leg] <= 0;
+            }
             if( bad_leg )
+            {
-                ptr->flags.bad_times = TRUE;
+                ptr->flags.notInEP = TRUE;
                 if ( ! report_all )
+                {
                     qDebug( "Team with incorrect time information: %d", ptr->team  );
                     bad++;
         sort_team_data( i, S_LE, sortWithEq);
         for( j = 1, k = 1, q = 1, ptr = sort_data; j <= sort_num; ptr++, j++ )
+        {
             if (ptr->isNeData) {
                 sort_aux[ptr->team].leq_place[i] = q++;
-            }
-            else {
+            } else {
                 sort_aux[ptr->team].le_place[i] = k++;
+            }
+        }
         /*
     for( j = 1; j <= sort_num; j++, ptr++ )
+    {
         ptr->place = j;
+    }
+    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;
+    //}
+}
 /*========================================================================
+ *
  *  qsort comparison function
     **
     **  If not sorting within a class (ie Overall), then Non_Equestrian
     **  is better than a bad time. Places NE before disqualified
     **
     */
+    bool aNoSort = false;
+    bool bNoSort = false;
+    if ( sort_leg != 0 && (sort_mode == S_LC || sort_mode == S_L ) ) {
+        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)
+            aNoSort = true;
+        if (b->flags.non_equestrian || b->flags.vet_check)
+            bNoSort = true;
+    }
+    if (a->flags.bad_times || a->flags.disqualified || !a->flags.valid)
+        aNoSort = true;
-    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 (b->flags.bad_times || b->flags.disqualified || !b->flags.valid)
+        bNoSort = true;
+    if ( sort_mode == S_FIN || sort_mode == S_IFIN ) {
+        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 );
+    if( sort_withEquestrian && sort_mode != S_FIN && sort_mode != S_IFIN )
+    {
-        if( a->flags.bad_times && b->flags.bad_times )
+        if( a->flags.non_equestrian && b->flags.non_equestrian )
-        {
-            return ( a->team - b->team );
-        }
-        else if( a->flags.bad_times || b->flags.bad_times )
+        {
+            /*
+            **  Both are non equestrian
+            **  Let the time sort operate ...
+            */
-            return ( a->flags.bad_times ? 1 : -1 );
+            //return ( a->team - b->team );
+        }
-        if( sort_mode != S_FIN && sort_mode != S_IFIN )
+        else 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 */
+            /* One is equestrian */
-                /* Good times better than NE */
+            /* Good times better than NE */
-                return ( a->flags.non_equestrian ? 1 : -1 );
+            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.
     */
     /*
      ** 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 );
+    }
 bool load_report_data(void)
+{
     ty_s_data  *ptr;                             /* pointer to sort data type */
     ty_s_data  *last;
-    int         j;
+    unsigned    j;
     unsigned    num;
     team_type   team_buf;
     /*
      * Fetch memory for the data store
                 ptr->flags = team_buf.flags;
                 // 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.notInSort = 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.notInSort = 1;
+                    ptr->flags.notInEP = 1;
                     ptr->flags.notInFastest = 1;
+                }
                 if (ptr->flags.vet_check) {
-                    ptr->flags.notInSort = 1;
+                    ptr->flags.notInEP = 1;
+                }
 //                if (ptr->flags.non_equestrian)
 //                    ptr->flags.disqualified = true;
-                if (ptr->flags.vet_check)
+//                if (ptr->flags.vet_check)
-                    ptr->flags.disqualified = true;
+//                    ptr->flags.disqualified = true;
                 ptr++;
                 sort_num++;
+                }
 #endif
+            }
+        }
+    }
+    // Debug
+    qDebug() << "--- Start ---";
+    sort_team_data( 0, S_L, 1 );
+    for( j = 1, ptr = sort_data; j <= sort_num; j++, ptr++ )
+    {
+        qDebug() << "T:" << ptr->team
+                << "Class:" << ptr->teamclass
+                << "NEData:" << (ptr->isNeData? 1:0)
+                << "iLP:" << (ptr->flags.notInLP ? 1:0)
+                << "iEP:" << (ptr->flags.notInEP ? 1:0)
+                << "iF:" << (ptr->flags.notInFastest ? 1:0)
+                << "Valid:" << (ptr->flags.valid ? 1:0)
+                << "NE:" << (ptr->flags.non_equestrian? 1:0)
+                << "B:" << (ptr->flags.bad_times ? 1 : 0 )
+                << "D:" << (ptr->flags.disqualified ? 1:0 )
+                << "V:" << (ptr->flags.vet_check ? 1:0 )
+                << "LE0:" << ptr->lege[0]
+                << "L0:" << ptr->leg[0]
+                << "LE1:" << ptr->lege[3]
+                ;
+    }
+    qDebug() << "-----------------------------------End---";
     return ( TRUE );
+}
 /*========================================================================
+ *

Subversion Repositories svn1-original

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