Line data    Source code

       1             : // Copyright (c) 2014-2018 The Bitcoin Core developers
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #ifndef BITCOIN_TIMEDATA_H
       6             : #define BITCOIN_TIMEDATA_H
       7             : 
       8             : #include <algorithm>
       9             : #include <assert.h>
      10             : #include <stdint.h>
      11             : #include <vector>
      12             : 
      13             : static const int64_t DEFAULT_MAX_TIME_ADJUSTMENT = 70 * 60;
      14             : 
      15             : class CNetAddr;
      16             : 
      17             : /**
      18             :  * Median filter over a stream of values.
      19             :  * Returns the median of the last N numbers
      20             :  */
      21             : template <typename T>
      22         604 : class CMedianFilter
      23             : {
      24             : private:
      25             :     std::vector<T> vValues;
      26             :     std::vector<T> vSorted;
      27             :     unsigned int nSize;
      28             : 
      29             : public:
      30         604 :     CMedianFilter(unsigned int _size, T initial_value) : nSize(_size)
      31         302 :     {
      32         302 :         vValues.reserve(_size);
      33         302 :         vValues.push_back(initial_value);
      34         302 :         vSorted = vValues;
      35         604 :     }
      36             : 
      37         506 :     void input(T value)
      38             :     {
      39         506 :         if (vValues.size() == nSize) {
      40           3 :             vValues.erase(vValues.begin());
      41           3 :         }
      42         506 :         vValues.push_back(value);
      43             : 
      44         506 :         vSorted.resize(vValues.size());
      45         506 :         std::copy(vValues.begin(), vValues.end(), vSorted.begin());
      46         506 :         std::sort(vSorted.begin(), vSorted.end());
      47         506 :     }
      48             : 
      49         105 :     T median() const
      50             :     {
      51         105 :         int vSortedSize = vSorted.size();
      52         105 :         assert(vSortedSize > 0);
      53         105 :         if (vSortedSize & 1) // Odd number of elements
      54             :         {
      55         103 :             return vSorted[vSortedSize / 2];
      56             :         } else // Even number of elements
      57             :         {
      58           2 :             return (vSorted[vSortedSize / 2 - 1] + vSorted[vSortedSize / 2]) / 2;
      59             :         }
      60         105 :     }
      61             : 
      62        1197 :     int size() const
      63             :     {
      64        1197 :         return vValues.size();
      65             :     }
      66             : 
      67          98 :     std::vector<T> sorted() const
      68             :     {
      69          98 :         return vSorted;
      70             :     }
      71             : };
      72             : 
      73             : /** Functions to keep track of adjusted P2P time */
      74             : int64_t GetTimeOffset();
      75             : int64_t GetAdjustedTime();
      76             : void AddTimeData(const CNetAddr& ip, int64_t nTime);
      77             : 
      78             : #endif // BITCOIN_TIMEDATA_H