concurrent_counter.hpp

Go to the documentation of this file.

#pragma once
 
#include "commons/base_includes.hpp"
#include "commons/platform_macros.hpp"
#include "commons/reader_writer_lock_shim.hpp"
 
namespace corelink
{
    namespace utils
    {
        template<class numeric_type = uint32_t>
        class CORELINK_EXPORT concurrent_counter
        {
        private:
            std::atomic<numeric_type> m_counter;
            const numeric_type m_reset_value;
            const numeric_type m_upper_bound;
            const numeric_type m_lower_bound;
 
        public:
            typedef numeric_type counter_type;
 
            // make sure that the type is an integral type
            static_assert(std::is_integral<numeric_type>::value, "Not a integer numeric type");
 
            explicit concurrent_counter()
                    : m_counter(0), m_reset_value(0), m_lower_bound(0),
                      m_upper_bound(std::numeric_limits<numeric_type>::max())
            {}
 
            explicit concurrent_counter(numeric_type upper_bound, numeric_type lower_bound)
                    : m_counter(0), m_reset_value(0), m_upper_bound(upper_bound), m_lower_bound(lower_bound)
            {
            }
 
            concurrent_counter(numeric_type reset_value, numeric_type upper_bound, numeric_type lower_bound)
                    : m_counter(0), m_reset_value(reset_value), m_upper_bound(upper_bound), m_lower_bound(lower_bound)
            {
            }
 
            concurrent_counter(numeric_type initial_value, numeric_type reset_value,
                               numeric_type upper_bound, numeric_type lower_bound)
                    : m_counter(initial_value), m_reset_value(reset_value), m_upper_bound(upper_bound),
                      m_lower_bound(lower_bound)
            {
            }
 
            virtual ~concurrent_counter() = default;
 
            inline std::atomic<numeric_type> &operator()()
            {
                return m_counter;
            }
 
            inline numeric_type operator++(int32_t)
            {
                if (m_counter < (m_upper_bound - 1)) return m_counter.fetch_add(1);
 
                m_counter.store(m_reset_value);
                return m_counter;
            }
 
            inline numeric_type operator++()
            {
                if (m_counter < (m_upper_bound - 1)) ++m_counter;
                else m_counter.store(m_reset_value);
                return m_counter;
            }
 
            inline numeric_type operator--(int32_t)
            {
                if (m_counter > m_lower_bound) return m_counter.fetch_sub(1);
 
                m_counter.store(m_reset_value);
                return m_counter;
            }
 
            inline numeric_type operator--()
            {
                if (m_counter > m_lower_bound) --m_counter;
                else m_counter.store(m_reset_value);
                return m_counter;
            }
 
            inline explicit operator numeric_type() const
            {
                return m_counter.load();
            }
 
            inline void reset()
            {
                m_counter.store(m_reset_value);
            }
 
            friend std::ostream &operator<<(std::ostream &os, const concurrent_counter &rhs)
            {
                os << rhs.m_counter;
                return os;
            }
        };
    }
}