00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #ifndef __BASIC_DATA_CALCULATORS_H__
00022 #define __BASIC_DATA_CALCULATORS_H__
00023
00024 #include "data-calculator.h"
00025 #include "data-output-interface.h"
00026
00027 namespace ns3 {
00028
00029
00030
00031 template <typename T = uint32_t>
00032 class MinMaxAvgTotalCalculator : public DataCalculator {
00033 public:
00034 MinMaxAvgTotalCalculator();
00035 virtual ~MinMaxAvgTotalCalculator();
00036
00037 void Update(const T i);
00038
00039 virtual void Output(DataOutputCallback &callback) const;
00040
00041 protected:
00042 virtual void DoDispose(void);
00043
00044 uint32_t m_count;
00045 T m_total, m_min, m_max;
00046
00047
00048 };
00049
00050
00051 template <typename T>
00052 MinMaxAvgTotalCalculator<T>::MinMaxAvgTotalCalculator()
00053 {
00054 m_count = 0;
00055 m_total = 0;
00056 m_min = ~0;
00057 m_max = 0;
00058 }
00059
00060 template <typename T>
00061 MinMaxAvgTotalCalculator<T>::~MinMaxAvgTotalCalculator()
00062 {
00063 }
00064 template <typename T>
00065 void
00066 MinMaxAvgTotalCalculator<T>::DoDispose(void)
00067 {
00068 DataCalculator::DoDispose();
00069
00070 }
00071
00072 template <typename T>
00073 void
00074 MinMaxAvgTotalCalculator<T>::Update(const T i)
00075 {
00076 if (m_enabled) {
00077 m_total += i;
00078
00079 if (i < m_min)
00080 m_min = i;
00081
00082 if (i > m_max)
00083 m_max = i;
00084
00085 m_count++;
00086 }
00087
00088 }
00089 template <typename T>
00090 void
00091 MinMaxAvgTotalCalculator<T>::Output(DataOutputCallback &callback) const
00092 {
00093 callback.OutputSingleton(m_key, "count", m_count);
00094 if (m_count > 0) {
00095 callback.OutputSingleton(m_key, "total", m_total);
00096 callback.OutputSingleton(m_key, "average", m_total/m_count);
00097 callback.OutputSingleton(m_key, "max", m_max);
00098 callback.OutputSingleton(m_key, "min", m_min);
00099 }
00100
00101 }
00102
00103
00104
00105
00106
00107
00108 template <typename T = uint32_t>
00109 class CounterCalculator : public DataCalculator {
00110 public:
00111 CounterCalculator();
00112 virtual ~CounterCalculator();
00113
00114 void Update();
00115 void Update(const T i);
00116
00117 T GetCount() const;
00118
00119 virtual void Output(DataOutputCallback &callback) const;
00120
00121 protected:
00122 virtual void DoDispose(void);
00123
00124 T m_count;
00125
00126
00127 };
00128
00129
00130
00131 template <typename T>
00132 CounterCalculator<T>::CounterCalculator() :
00133 m_count(0)
00134 {
00135 }
00136
00137 template <typename T>
00138 CounterCalculator<T>::~CounterCalculator()
00139 {
00140 }
00141 template <typename T>
00142 void
00143 CounterCalculator<T>::DoDispose(void)
00144 {
00145 DataCalculator::DoDispose();
00146
00147 }
00148
00149 template <typename T>
00150 void
00151 CounterCalculator<T>::Update()
00152 {
00153 if (m_enabled) {
00154 m_count++;
00155 }
00156
00157 }
00158
00159 template <typename T>
00160 void
00161 CounterCalculator<T>::Update(const T i)
00162 {
00163 if (m_enabled) {
00164 m_count += i;
00165 }
00166
00167 }
00168
00169 template <typename T>
00170 T
00171 CounterCalculator<T>::GetCount() const
00172 {
00173 return m_count;
00174
00175 }
00176
00177 template <typename T>
00178 void
00179 CounterCalculator<T>::Output(DataOutputCallback &callback) const
00180 {
00181 callback.OutputSingleton(m_key, "count", m_count);
00182
00183 }
00184
00185
00186 };
00187
00188
00189 #endif // __BASIC_DATA_CALCULATORS_H__