src/Statistics.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2002-2008 Merkur ( devs@emule-project.net / http://www.emule-project.net )
   6 // Copyright (c) 2005-2008 Dévai Tamás ( gonosztopi@amule.org )
   7 //
   8 // Any parts of this program derived from the xMule, lMule or eMule project,
   9 // or contributed by third-party developers are copyrighted by their
  10 // respective authors.
  11 //
  12 // This program is free software; you can redistribute it and/or modify
  13 // it under the terms of the GNU General Public License as published by
  14 // the Free Software Foundation; either version 2 of the License, or
  15 // (at your option) any later version.
  16 //
  17 // This program is distributed in the hope that it will be useful,
  18 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 // GNU General Public License for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License
  23 // along with this program; if not, write to the Free Software
  24 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  25 //
  26
  27 #ifndef STATISTICS_H
  28 #define STATISTICS_H
  29
  30 #include "StatTree.h"           // Needed for CStatTreeItem* classes
  31 #include "GetTickCount.h"       // Needed for GetTickCount64()
  32
  33 #include <deque>                // Needed for std::deque
  34
  35 enum StatsGraphType {
  36         GRAPH_INVALID = 0,
  37         GRAPH_DOWN,
  38         GRAPH_UP,
  39         GRAPH_CONN,
  40         GRAPH_KAD
  41 };
  42
  43 typedef struct UpdateInfo {
  44         double timestamp;
  45         float downloads[3];
  46         float uploads[3];
  47         float connections[3];
  48         float kadnodes[3];
  49 } GraphUpdateInfo;
  50
  51 typedef struct HistoryRecord {
  52         double          kBytesSent;
  53         double          kBytesReceived;
  54         float           kBpsUpCur;
  55         float           kBpsDownCur;
  56         double          sTimestamp;
  57         uint16          cntDownloads;
  58         uint16          cntUploads;
  59         uint16          cntConnections;
  60         uint16          kadNodesCur;
  61         uint64          kadNodesTotal;
  62 } HR;
  63
  64
  65 #ifndef EC_REMOTE
  66
  67 /**
  68  * Counts precise rate/average on added bytes/values.
  69  *
  70  * @note This class is MT-safe.
  71  */
  72 class CPreciseRateCounter {
  73         friend class CStatistics;       // for playing dirty tricks to compute running average :P
  74  public:
  75
  76         /**
  77          * Constructor
  78          *
  79          * @param timespan Desired timespan for rate calculations.
  80          * @param count_average Counts average instead of rate.
  81          */
  82         CPreciseRateCounter(uint32_t timespan, bool count_average = false)
  83                 : m_timespan(timespan), m_total(0), m_rate(0.0), m_max_rate(0.0), m_tmp_sum(0), m_count_average(count_average)
  84                 {
  85                         if (!count_average) {
  86                                 uint64_t cur_time = GetTickCount64();
  87                                 uint64_t target_time = cur_time - timespan;
  88                                 while (cur_time > target_time) {
  89                                         m_tick_history.push_front(cur_time);
  90                                         m_byte_history.push_front(0);
  91                                         cur_time -= 100;        // default update period
  92                                 }
  93                                 m_tick_history.push_front(cur_time);
  94                         }
  95                 }
  96
  97         /**
  98          * Calculate current rate.
  99          *
 100          * This function should be called reasonably often, to
 101          * keep rates up-to-date, and prevent history growing
 102          * to the skies.
 103          */
 104         void    CalculateRate(uint64_t now);
 105
 106         /**
 107          * Get current rate.
 108          *
 109          * @return Current rate in bytes/second.
 110          */
 111         double  GetRate()                       { wxMutexLocker lock(m_mutex); return m_rate; };
 112
 113         /**
 114          * Gets ever seen maximal rate.
 115          *
 116          * @return The maximal rate which occured.
 117          */
 118         double  GetMaxRate()                    { wxMutexLocker lock(m_mutex); return m_max_rate; }
 119
 120         /**
 121          * Sets desired timespan for rate calculations.
 122          *
 123          * If new timespan is greater than the old was, then the change
 124          * takes effect with time. The exact time needed for the change
 125          * to take effect is new minus old value of the timespan.
 126          *
 127          * If the new timespan is lower than the old, the change takes
 128          * effect immediately at the next call to CalculateRate().
 129          */
 130         void    SetTimespan(uint32_t timespan)  { wxMutexLocker lock(m_mutex); m_timespan = timespan; }
 131
 132         /**
 133          * Add bytes to be tracked for rate-counting.
 134          */
 135         void    operator+=(uint32_t bytes)      { wxMutexLocker lock(m_mutex); m_tmp_sum += bytes; }
 136
 137  protected:
 138
 139         std::deque<uint32>      m_byte_history;
 140         std::deque<uint64>      m_tick_history;
 141         uint32_t        m_timespan;
 142         uint32_t        m_total;
 143         double          m_rate;
 144         double          m_max_rate;
 145         uint32_t        m_tmp_sum;
 146         wxMutex         m_mutex;
 147         bool            m_count_average;
 148 };
 149
 150
 151 class CECTag;
 152
 153 /**
 154  * Stat tree item for rates/averages.
 155  */
 156 class CStatTreeItemRateCounter : public CStatTreeItemBase, public CPreciseRateCounter {
 157  public:
 158
 159         /**
 160          * @see CStatTreeItemBase::CStatTreeItemBase, CPreciseRateCounter::CPreciseRateCounter
 161          *
 162          * @param show_maxrate If true, shows max rate instead of current rate.
 163          */
 164         CStatTreeItemRateCounter(const wxString& label, bool show_maxrate, uint32_t timespan, bool count_average = false)
 165                 : CStatTreeItemBase(label, stNone), CPreciseRateCounter(timespan, count_average), m_show_maxrate(show_maxrate)
 166                 {}
 167
 168 #ifndef AMULE_DAEMON
 169         /**
 170          * @see CStatTreeItemBase::GetDisplayString()
 171          */
 172         virtual wxString GetDisplayString() const;
 173 #endif
 174
 175  protected:
 176         /**
 177          * Add values to EC tag being generated.
 178          *
 179          * @param tag The tag to which values should be added.
 180          *
 181          * @see CStatTreeItemBase::AddECValues
 182          */
 183         virtual void    AddECValues(CECTag* tag) const;
 184
 185         //! Whether to show max rate instead of actual rate.
 186         bool    m_show_maxrate;
 187 };
 188
 189
 190 /**
 191  * Stat tree item for Peak Connections.
 192  */
 193 class CStatTreeItemPeakConnections : public CStatTreeItemBase {
 194  public:
 195
 196         /**
 197          * @see CStatTreeItemBase::CStatTreeItemBase
 198          */
 199         CStatTreeItemPeakConnections(const wxString& label)
 200                 : CStatTreeItemBase(label)
 201                 {}
 202
 203 #ifndef AMULE_DAEMON
 204         /**
 205          * @see CStatTreeItemBase::GetDisplayString()
 206          */
 207         virtual wxString GetDisplayString() const;
 208 #endif
 209
 210  protected:
 211         /**
 212          * Add values to EC tag being generated.
 213          *
 214          * @param tag The tag to which values should be added.
 215          *
 216          * @see CStatTreeItemBase::AddECValues
 217          */
 218         virtual void    AddECValues(CECTag* tag) const;
 219 };
 220
 221
 222 class CUpDownClient;
 223
 224 class CStatistics {
 225         friend class CStatisticsDlg;    // to access CStatistics::GetTreeRoot()
 226  public:
 227         CStatistics();
 228         ~CStatistics();
 229
 230         /* Statistics graph functions */
 231
 232         void     RecordHistory();
 233         unsigned GetHistoryForWeb(unsigned cntPoints, double sStep, double *sStart, uint32 **graphData);
 234         unsigned GetHistory(unsigned cntPoints, double sStep, double sFinal, const std::vector<float *> &ppf, StatsGraphType which_graph);
 235         GraphUpdateInfo GetPointsForUpdate();
 236
 237         /* Statistics tree functions */
 238
 239         void UpdateStatsTree();
 240
 241         /* Access to the tree */
 242
 243         // uptime
 244         static  uint64  GetUptimeMillis()                       { return s_uptime->GetTimerValue(); }
 245         static  uint64  GetUptimeSeconds()                      { return s_uptime->GetTimerSeconds(); }
 246         static  uint64  GetStartTime()                          { return s_uptime->GetTimerStart(); }
 247
 248         // Upload
 249         static  uint64  GetSessionSentBytes()                   { return (*s_sessionUpload); }
 250         static  void    AddUpOverheadFileRequest(uint32 size)   { (*s_fileReqUpOverhead) += size; (*s_upOverheadRate) += size; }
 251         static  void    AddUpOverheadSourceExchange(uint32 size){ (*s_sourceXchgUpOverhead) += size; (*s_upOverheadRate) += size; }
 252         static  void    AddUpOverheadServer(uint32 size)        { (*s_serverUpOverhead) += size; (*s_upOverheadRate) += size; }
 253         static  void    AddUpOverheadKad(uint32 size)           { (*s_kadUpOverhead) += size; (*s_upOverheadRate) += size; }
 254         static  void    AddUpOverheadCrypt(uint32_t size)       { (*s_cryptUpOverhead) += size; }
 255         static  void    AddUpOverheadOther(uint32 size)         { (*s_totalUpOverhead) += size; (*s_upOverheadRate) += size; }
 256         static  double  GetUpOverheadRate()                     { return s_upOverheadRate->GetRate(); }
 257         static  void    AddSuccessfulUpload()                   { ++(*s_totalSuccUploads); }
 258         static  void    AddFailedUpload()                       { ++(*s_totalFailedUploads); }
 259         static  void    AddUploadTime(uint32 time)              { (*s_totalUploadTime) += time; }
 260         static  void    AddUploadingClient()                    { ++(*s_activeUploads); }
 261         static  void    RemoveUploadingClient()                 { --(*s_activeUploads); }
 262         static  uint32  GetActiveUploadsCount()                 { return (*s_activeUploads); }
 263         static  void    AddWaitingClient()                      { ++(*s_waitingUploads); }
 264         static  void    RemoveWaitingClient()                   { --(*s_waitingUploads); }
 265         static  uint32  GetWaitingUserCount()                   { return (*s_waitingUploads); }
 266         static  double  GetUploadRate()                         { return s_uploadrate->GetRate(); }
 267
 268         // Download
 269         static  uint64  GetSessionReceivedBytes()               { return (*s_sessionDownload); }
 270         static  void    AddDownOverheadFileRequest(uint32 size) { (*s_fileReqDownOverhead) += size; (*s_downOverheadRate) += size; }
 271         static  void    AddDownOverheadSourceExchange(uint32 size){ (*s_sourceXchgDownOverhead) += size; (*s_downOverheadRate) += size; }
 272         static  void    AddDownOverheadServer(uint32 size)      { (*s_serverDownOverhead) += size; (*s_downOverheadRate) += size; }
 273         static  void    AddDownOverheadKad(uint32 size)         { (*s_kadDownOverhead) += size; (*s_downOverheadRate) += size; }
 274         static  void    AddDownOverheadCrypt(uint32_t size)     { (*s_cryptDownOverhead) += size; }
 275         static  void    AddDownOverheadOther(uint32 size)       { (*s_totalDownOverhead) += size; (*s_downOverheadRate) += size; }
 276         static  double  GetDownOverheadRate()                   { return s_downOverheadRate->GetRate(); }
 277         static  void    AddFoundSource()                        { ++(*s_foundSources); }
 278         static  void    RemoveFoundSource()                     { --(*s_foundSources); }
 279         static  uint32  GetFoundSources()                       { return (*s_foundSources); }
 280         static  void    AddSourceOrigin(unsigned origin);
 281         static  void    RemoveSourceOrigin(unsigned origin);
 282         static  void    AddDownloadingSource()                  { ++(*s_activeDownloads); }
 283         static  void    RemoveDownloadingSource()               { --(*s_activeDownloads); }
 284         static  uint32  GetDownloadingSources()                 { return (*s_activeDownloads); }
 285         static  double  GetDownloadRate()                       { return s_downloadrate->GetRate(); }
 286
 287         // Connection
 288         static  CStatTreeItemTimer* GetServerConnectTimer()     { return s_sinceConnected; }
 289         static  void    AddReconnect()                          { ++(*s_reconnects); }
 290         static  void    AddActiveConnection()                   { ++(*s_activeConnections); }
 291         static  void    RemoveActiveConnection()                { --(*s_activeConnections); }
 292         static  uint32  GetActiveConnections()                  { return s_activeConnections->GetValue(); }
 293         static  uint32  GetPeakConnections()                    { return s_activeConnections->GetMaxValue(); }
 294         static  void    AddMaxConnectionLimitReached()          { ++(*s_limitReached); }
 295
 296         // Clients
 297         static  void    AddFilteredClient()                     { ++(*s_filtered); }
 298         static  void    AddUnknownClient()                      { ++(*s_unknown); }
 299         static  void    RemoveUnknownClient()                   { --(*s_unknown); }
 300         static  void    AddKnownClient(CUpDownClient *pClient);
 301         static  void    RemoveKnownClient(uint32 clientSoft, uint32 clientVersion, const wxString& OSInfo);
 302 #ifdef __DEBUG__
 303         static  void    SocketAssignedToClient()                { ++(*s_hasSocket); }
 304         static  void    SocketUnassignedFromClient()            { --(*s_hasSocket); }
 305 #endif
 306         static  uint32  GetBannedCount()                        { return (*s_banned); }
 307         static  void    AddBannedClient()                       { ++(*s_banned); }
 308         static  void    RemoveBannedClient()                    { --(*s_banned); }
 309
 310         // Servers
 311         static  void    AddServer()                             { ++(*s_totalServers); }
 312         static  void    DeleteServer()                          { ++(*s_deletedServers); --(*s_totalServers); }
 313         static  void    DeleteAllServers()                      { (*s_deletedServers) += (*s_totalServers); (*s_totalServers) = 0; }
 314         static  void    AddFilteredServer()                     { ++(*s_filteredServers); }
 315
 316         // Shared files
 317         static  void    ClearSharedFilesInfo()                  { (*s_numberOfShared) = 0; (*s_sizeOfShare) = 0; }
 318         static  void    AddSharedFile(uint64 size)              { ++(*s_numberOfShared); (*s_sizeOfShare) += size; }
 319         static  void    RemoveSharedFile(uint64 size)           { --(*s_numberOfShared); (*s_sizeOfShare) -= size; }
 320         static  uint32  GetSharedFileCount()                    { return (*s_numberOfShared); }
 321
 322         // Kad nodes
 323         static void             AddKadNode()                                    { ++s_kadNodesCur; }
 324         static void             RemoveKadNode()                                 { --s_kadNodesCur; }
 325
 326
 327         // Other
 328         static  void    CalculateRates();
 329
 330         static  void    AddReceivedBytes(uint32 bytes)
 331                 {
 332                         if (!s_sinceFirstTransfer->IsRunning()) {
 333                                 s_sinceFirstTransfer->StartTimer();
 334                         }
 335
 336                         (*s_sessionDownload) += bytes;
 337                         (*s_downloadrate) += bytes;
 338                 }
 339
 340         static  void    AddSentBytes(uint32 bytes)
 341                 {
 342                         if (!s_sinceFirstTransfer->IsRunning()) {
 343                                 s_sinceFirstTransfer->StartTimer();
 344                         }
 345
 346                         (*s_sessionUpload) += bytes;
 347                         (*s_uploadrate) += bytes;
 348                 }
 349
 350         static  void    AddDownloadFromSoft(uint8 SoftType, uint32 bytes);
 351         static  void    AddUploadToSoft(uint8 SoftType, uint32 bytes);
 352
 353         // EC
 354         static  CECTag* GetECStatTree(uint8 tree_capping_value) { return s_statTree->CreateECTag(tree_capping_value); }
 355
 356         void SetAverageMinutes(uint8 minutes) { average_minutes = minutes; }
 357
 358  private:
 359         std::list<HR>   listHR;
 360         typedef std::list<HR>::iterator         listPOS;
 361         typedef std::list<HR>::reverse_iterator listRPOS;
 362
 363         /* Graph-related functions */
 364
 365         void ComputeAverages(HR **pphr, listRPOS pos, unsigned cntFilled,
 366                 double sStep, const std::vector<float *> &ppf, StatsGraphType which_graph);
 367
 368         int GetPointsPerRange()
 369         {
 370                 return (1280/2) - 80; // This used to be a calc. based on GUI width
 371         }
 372
 373         /* Graphs-related vars */
 374
 375         CPreciseRateCounter     m_graphRunningAvgDown;
 376         CPreciseRateCounter     m_graphRunningAvgUp;
 377         CPreciseRateCounter     m_graphRunningAvgKad;
 378
 379
 380         uint8 average_minutes;
 381         int     nHistRanges;
 382         int     bitsHistClockMask;
 383         int     nPointsPerRange;
 384         listPOS*        aposRecycle;
 385
 386         HR hrInit;
 387
 388         /* Rate/Average counters */
 389         static  CPreciseRateCounter*            s_upOverheadRate;
 390         static  CPreciseRateCounter*            s_downOverheadRate;
 391         static  CStatTreeItemRateCounter*       s_uploadrate;
 392         static  CStatTreeItemRateCounter*       s_downloadrate;
 393
 394         /* Tree-related functions */
 395
 396         static  void    InitStatsTree();
 397
 398         static  CStatTreeItemBase*      GetTreeRoot()   { return s_statTree; }
 399
 400         /* Tree-related vars */
 401
 402         // the tree
 403         static  CStatTreeItemBase*              s_statTree;
 404
 405         // Uptime
 406         static  CStatTreeItemTimer*             s_uptime;
 407
 408         // Upload
 409         static  CStatTreeItemUlDlCounter*       s_sessionUpload;
 410         static  CStatTreeItemPacketTotals*      s_totalUpOverhead;
 411         static  CStatTreeItemPackets*           s_fileReqUpOverhead;
 412         static  CStatTreeItemPackets*           s_sourceXchgUpOverhead;
 413         static  CStatTreeItemPackets*           s_serverUpOverhead;
 414         static  CStatTreeItemPackets*           s_kadUpOverhead;
 415         static  CStatTreeItemCounter*           s_cryptUpOverhead;
 416         static  CStatTreeItemNativeCounter*     s_activeUploads;
 417         static  CStatTreeItemNativeCounter*     s_waitingUploads;
 418         static  CStatTreeItemCounter*           s_totalSuccUploads;
 419         static  CStatTreeItemCounter*           s_totalFailedUploads;
 420         static  CStatTreeItemCounter*           s_totalUploadTime;
 421
 422         // Download
 423         static  CStatTreeItemUlDlCounter*       s_sessionDownload;
 424         static  CStatTreeItemPacketTotals*      s_totalDownOverhead;
 425         static  CStatTreeItemPackets*           s_fileReqDownOverhead;
 426         static  CStatTreeItemPackets*           s_sourceXchgDownOverhead;
 427         static  CStatTreeItemPackets*           s_serverDownOverhead;
 428         static  CStatTreeItemPackets*           s_kadDownOverhead;
 429         static  CStatTreeItemCounter*           s_cryptDownOverhead;
 430         static  CStatTreeItemNativeCounter*     s_foundSources;
 431         static  CStatTreeItemNativeCounter*     s_activeDownloads;
 432
 433         // Connection
 434         static  CStatTreeItemReconnects*        s_reconnects;
 435         static  CStatTreeItemTimer*             s_sinceFirstTransfer;
 436         static  CStatTreeItemTimer*             s_sinceConnected;
 437         static  CStatTreeItemCounterMax*        s_activeConnections;
 438         static  CStatTreeItemMaxConnLimitReached* s_limitReached;
 439         static  CStatTreeItemSimple*            s_avgConnections;
 440
 441         // Clients
 442         static  CStatTreeItemHiddenCounter*     s_clients;
 443         static  CStatTreeItemCounter*           s_unknown;
 444         //static        CStatTreeItem                   s_lowID;
 445         //static        CStatTreeItem                   s_secIdentOnOff;
 446 #ifdef __DEBUG__
 447         static  CStatTreeItemNativeCounter*     s_hasSocket;
 448 #endif
 449         static  CStatTreeItemNativeCounter*     s_filtered;
 450         static  CStatTreeItemNativeCounter*     s_banned;
 451
 452         // Servers
 453         static  CStatTreeItemSimple*            s_workingServers;
 454         static  CStatTreeItemSimple*            s_failedServers;
 455         static  CStatTreeItemNativeCounter*     s_totalServers;
 456         static  CStatTreeItemNativeCounter*     s_deletedServers;
 457         static  CStatTreeItemNativeCounter*     s_filteredServers;
 458         static  CStatTreeItemSimple*            s_usersOnWorking;
 459         static  CStatTreeItemSimple*            s_filesOnWorking;
 460         static  CStatTreeItemSimple*            s_totalUsers;
 461         static  CStatTreeItemSimple*            s_totalFiles;
 462         static  CStatTreeItemSimple*            s_serverOccupation;
 463
 464         // Shared files
 465         static  CStatTreeItemCounter*           s_numberOfShared;
 466         static  CStatTreeItemCounter*           s_sizeOfShare;
 467
 468         // Kad nodes
 469         static uint64 s_kadNodesTotal;
 470         static uint16 s_kadNodesCur;
 471 };
 472
 473 #else /* EC_REMOTE == CLIENT_GUI */
 474
 475 class CECPacket;
 476 class CRemoteConnect;
 477
 478 enum StatDataIndex {
 479         sdUpload,
 480         sdUpOverhead,
 481         sdDownload,
 482         sdDownOverhead,
 483         sdWaitingClients,
 484         sdBannedClients,
 485         sdED2KUsers,
 486         sdKadUsers,
 487         sdED2KFiles,
 488         sdKadFiles,
 489         sdKadFirewalledUDP,
 490         sdKadIndexedSources,
 491         sdKadIndexedKeywords,
 492         sdKadIndexedNotes,
 493         sdKadIndexedLoad,
 494         sdKadIPAdress,
 495         sdBuddyStatus,
 496         sdBuddyIP,
 497         sdBuddyPort,
 498
 499         sdTotalItems
 500 };
 501
 502 class CStatistics {
 503         friend class CStatisticsDlg;    // to access CStatistics::GetTreeRoot()
 504
 505 private:
 506         CRemoteConnect &m_conn;
 507         static CStatTreeItemBase* s_statTree;
 508         static uint64 s_start_time;
 509         static uint64 s_statData[sdTotalItems];
 510         uint8 average_minutes;
 511
 512  public:
 513         CStatistics(CRemoteConnect &conn);
 514         ~CStatistics();
 515
 516         static  uint64  GetUptimeMillis()                       { return GetTickCount64() - s_start_time; }
 517         static  uint64  GetUptimeSeconds()                      { return (GetTickCount64() - s_start_time) / 1000; }
 518
 519         static  uint64  GetSessionSentBytes()                   { return 0; } // TODO
 520         static  double  GetUploadRate()                         { return (double)s_statData[sdUpload]; }
 521         static  double  GetUpOverheadRate()                     { return (double)s_statData[sdUpOverhead]; }
 522
 523         static  uint64  GetSessionReceivedBytes()               { return 0; } // TODO
 524         static  double  GetDownloadRate()                       { return (double)s_statData[sdDownload]; }
 525         static  double  GetDownOverheadRate()                   { return (double)s_statData[sdDownOverhead]; }
 526
 527         static  uint32  GetWaitingUserCount()                   { return s_statData[sdWaitingClients]; }
 528         static  uint32  GetBannedCount()                        { return s_statData[sdBannedClients]; }
 529
 530         static  uint32  GetSharedFileCount()                    { return 0; } // TODO
 531
 532         static  uint32  GetED2KUsers()                  { return s_statData[sdED2KUsers]; }
 533         static  uint32  GetKadUsers()                   { return s_statData[sdKadUsers]; }
 534         static  uint32  GetED2KFiles()                  { return s_statData[sdED2KFiles]; }
 535         static  uint32  GetKadFiles()                   { return s_statData[sdKadFiles]; }
 536
 537         static  bool    IsFirewalledKadUDP()    { return s_statData[sdKadFirewalledUDP] != 0; }
 538         static  uint32  GetKadIndexedSources()  { return s_statData[sdKadIndexedSources]; }
 539         static  uint32  GetKadIndexedKeywords() { return s_statData[sdKadIndexedKeywords]; }
 540         static  uint32  GetKadIndexedNotes()    { return s_statData[sdKadIndexedNotes]; }
 541         static  uint32  GetKadIndexedLoad()             { return s_statData[sdKadIndexedLoad]; }
 542         static  uint32  GetKadIPAdress()                { return s_statData[sdKadIPAdress]; }
 543         static  uint8   GetBuddyStatus()                { return s_statData[sdBuddyStatus]; }
 544         static  uint32  GetBuddyIP()                    { return s_statData[sdBuddyIP]; }
 545         static  uint32  GetBuddyPort()                  { return s_statData[sdBuddyPort]; }
 546
 547         static  void    UpdateStats(const CECPacket* stats);
 548
 549                 void    UpdateStatsTree();
 550                 void    SetAverageMinutes(uint8 minutes)        { average_minutes = minutes; }
 551
 552  private:
 553         static  CStatTreeItemBase*      GetTreeRoot()           { return s_statTree; }
 554 };
 555
 556 #endif /* !EC_REMOTE / EC_REMOTE */
 557
 558
 559 /**
 560  * Shortcut for CStatistics
 561  */
 562 typedef CStatistics     theStats;
 563
 564 #endif // STATISTICS_H
 565 // File_checked_for_headers