averagetimecalculator.h

/***************************************************************************
 * The contents of this file are subject to the Mozilla Public             *
 * License Version 1.1 (the "License"); you may not use this file          *
 * except in compliance with the License. You may obtain a copy of         *
 * the License at http://www.mozilla.org/MPL/                              *
 *                                                                         *
 * Software distributed under the License is distributed on an "AS         *
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or              *
 * implied. See the License for the specific language governing            *
 * rights and limitations under the License.                               *
 *                                                                         *
 * The Original Code is Game Network Framework (GaNeF).                    *
 *                                                                         *
 * The Initial Developers of the Original Code are                         *
 * Lars Langer and Emanuel Greisen                                         *
 * Copyright (C) 2005. Lars Langer & Emanuel Greisen                       *
 * All Rights Reserved.                                                    *
 *                                                                         *
 * Contributor(s):                                                         *
 *   none yet....                                                          *
 *                                                                         *
 ***************************************************************************/
#ifndef AVERAGETIMECALCULATOR_H
#define AVERAGETIMECALCULATOR_H

/**
@brief This template-class can summarize values and keep a running average on them.
The precision, min/max, and default are all set at compile-time.
It is intended for use with milliseconds

@author Lars Langer and Emanuel Greisen
*/

template<int precision=16, int default_value=250, int min_value=10, int max_value=3000>
class AverageTimeCalculator
{
   /// Contains the last RRT_TIME_CALCULATION_COUNT RRT-times for this client.
   unsigned int avg_data[precision];
   /// Contains the average RRT-time for this client.
   unsigned int avg_current_sum;
   /// Contains the average RRT-time for this client.
   unsigned int avg_current;
   /// Contains a cyclic counter for the RRT-calculations
   unsigned int avg_data_position;

public:
   AverageTimeCalculator()
   {
      reset();
   };

public:
   /// This will initilize/clear the RRT-info
   void reset()
   {
      // Clear the RRT-infomation data
      for(int i = 0; i < precision; i++)
      {
         avg_data[i] = default_value;
      }
      avg_current = default_value;
      avg_current_sum = default_value * precision;
      avg_data_position = 0;
   }
   /// This will add a value to the set and recalculate a new average
   void registerValue(unsigned int val)
   {
      //std::cout << min_value << "," << val << "," << max_value;
      if(val >= min_value && val <= max_value)
      {
         // Replace oldest RRT
         avg_current_sum -= avg_data[avg_data_position];
         avg_current_sum += val;
         avg_data[avg_data_position] = val;
         // Calculate new average
         avg_current = avg_current_sum / precision;
         // update cyclic position
         avg_data_position = (avg_data_position+1) % precision;
      }
      //std::cout << " [sum:" << avg_current_sum << ",avg:" << avg_current << "]" << std::endl;
   }
   /// Will return the current average
   unsigned int getAvg() const
   {
      //NONEED return (avg_current > max_value) ? max_value : ((avg_current < min_value) ? min_value : avg_current);
      return avg_current;
   }

};

#endif

---