statCollector.h

Go to the documentation of this file.

#ifndef __statCollector_h__
#define __statCollector_h__
 
namespace statCollector {
    class base {
      private:
        std::string name;
        std::string unit;
      protected:
        unsigned long long n;
      public:
        base(const std::string& aName,
             const std::string& aUnit = "s") : name(aName), unit(aUnit) {};
        virtual void print(std::ostream&) const = 0;
        virtual void reset() = 0;
        friend std::ostream& operator<<(std::ostream& stream, const base& obj) {
            obj.print(stream);
            return stream;
        }
        const std::string& getName() const {
            return name;
        };
        const std::string& getUnit() const {
            return unit;
        };
        decltype(n) getN() const {
            return n;
        };
    };
 
 
    template <typename T> class typed: public base {
      public:
        T sum;
        T min;
        T max;
        void addValue(T value) {
            sum += value;
            if (value < min) {
                min = value;
            }
            if (value > max) {
                max = value;
            }
            this->n++;
        };
        template <typename TT = T, typename std::enable_if <std::is_arithmetic<TT>::value>::type..., class ... Types>
        typed(Types ... args):
            base(args...),
            sum(0),
            min(std::numeric_limits<T>::max()),
            max(std::numeric_limits<T>::lowest()) {
        };
        template < typename TT = T, typename std::enable_if < !std::is_arithmetic<TT>::value >::type..., class ... Types >
        typed(Types ... args) :
            base(args...),
            sum(T::zero()),
            min(T::max()),
            max(T::min()) {
        };
 
    private:
        template<typename TT = T>
        typename std::enable_if < !std::is_arithmetic<TT>::value >::type
        _print(std::ostream& stream) const {
            stream << this->getName() << " avg: " << std::scientific
                   << std::chrono::duration_cast<std::chrono::duration<double>>(sum / this->n).count()
                   << this->getUnit() << ",  min: "
                   << std::chrono::duration_cast<std::chrono::duration<double>>(min).count()
                   << this->getUnit() << ",  max: "
                   << std::chrono::duration_cast<std::chrono::duration<double>>(max).count()
                   << this->getUnit();
        }
        template<typename TT = T>
        typename std::enable_if <std::is_arithmetic<TT>::value>::type
        _print(std::ostream& stream) const {
            stream << this->getName() << " avg: "
                   << sum / this->n
                   << this->getUnit() << ",  min: "
                   << min
                   << this->getUnit() << ",  max: "
                   << max
                   << this->getUnit();
        }
    public:
        void print(std::ostream& stream) const override {
            if (n) {
                _print(stream);
            } else {
                stream << this->getName() << " no values yet ";
            }
        }
    private:
        template<typename TT = T>
        typename std::enable_if < !std::is_arithmetic<TT>::value >::type
        _reset() {
            sum = T::zero();
            min =T::max();
            max = T::min();
        }
        template<typename TT = T>
        typename std::enable_if <std::is_arithmetic<TT>::value>::type
        _reset() {
            sum=0;
            min=std::numeric_limits<T>::max();
            max=std::numeric_limits<T>::lowest();
        }
    public:
        void reset() override {
            n=0;
            _reset();
        }
    };
 
    inline std::chrono::system_clock::time_point timePoint(const struct timespec& spec) {
        return std::chrono::system_clock::time_point(std::chrono::seconds(spec.tv_sec) +
                std::chrono::nanoseconds(spec.tv_nsec));
 
    }
} // end of name space statCollector
#endif