flocore-node/include/boost/log/attributes/counter.hpp

/*
 *          Copyright Andrey Semashev 2007 - 2014.
 * Distributed under the Boost Software License, Version 1.0.
 *    (See accompanying file LICENSE_1_0.txt or copy at
 *          http://www.boost.org/LICENSE_1_0.txt)
 */
/*!
 * \file   counter.hpp
 * \author Andrey Semashev
 * \date   01.05.2007
 *
 * The header contains implementation of the counter attribute.
 */

#ifndef BOOST_LOG_ATTRIBUTES_COUNTER_HPP_INCLUDED_
#define BOOST_LOG_ATTRIBUTES_COUNTER_HPP_INCLUDED_

#include <boost/static_assert.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/log/detail/config.hpp>
#include <boost/log/attributes/attribute.hpp>
#include <boost/log/attributes/attribute_cast.hpp>
#include <boost/log/attributes/attribute_value_impl.hpp>
#ifndef BOOST_LOG_NO_THREADS
#include <boost/detail/atomic_count.hpp>
#endif // BOOST_LOG_NO_THREADS
#include <boost/log/detail/header.hpp>

#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif

namespace boost {

BOOST_LOG_OPEN_NAMESPACE

namespace attributes {

/*!
 * \brief A class of an attribute that counts an integral value
 *
 * This type of attribute acts as a counter, that is, it returns a monotonously
 * changing value each time requested. The attribute value type can be specified
 * as a template parameter. However, the type must be an integral type of size no
 * more than <tt>sizeof(long)</tt>.
 */
template< typename T >
class counter :
    public attribute
{
    //  For now only integral types up to long are supported
    BOOST_STATIC_ASSERT_MSG(is_integral< T >::value && sizeof(T) <= sizeof(long), "Boost.Log: Only integral types up to long are supported by counter attribute");

public:
    //! A counter value type
    typedef T value_type;

protected:
    //! Base class for factory implementation
    class BOOST_LOG_NO_VTABLE BOOST_SYMBOL_VISIBLE impl :
        public attribute::impl
    {
    };

    //! Generic factory implementation
    class impl_generic;
#ifndef BOOST_LOG_NO_THREADS
    //! Increment-by-one factory implementation
    class impl_inc;
    //! Decrement-by-one factory implementation
    class impl_dec;
#endif

public:
    /*!
     * Constructor
     *
     * \param initial Initial value of the counter
     * \param step Changing step of the counter. Each value acquired from the attribute
     *        will be greater than the previous one to this amount.
     */
    explicit counter(value_type initial = (value_type)0, long step = 1) :
#ifndef BOOST_LOG_NO_THREADS
        attribute()
    {
        if (step == 1)
            this->set_impl(new impl_inc(initial));
        else if (step == -1)
            this->set_impl(new impl_dec(initial));
        else
            this->set_impl(new impl_generic(initial, step));
    }
#else
        attribute(new impl_generic(initial, step))
    {
    }
#endif
    /*!
     * Constructor for casting support
     */
    explicit counter(cast_source const& source) :
        attribute(source.as< impl >())
    {
    }
};

#ifndef BOOST_LOG_NO_THREADS

template< typename T >
class counter< T >::impl_generic :
    public impl
{
private:
    //! Initial value
    const value_type m_Initial;
    //! Step value
    const long m_Step;
    //! The counter
    boost::detail::atomic_count m_Counter;

public:
    /*!
     * Initializing constructor
     */
    impl_generic(value_type initial, long step) : m_Initial(initial), m_Step(step), m_Counter(-1)
    {
    }

    attribute_value get_value()
    {
        const unsigned long next_counter = static_cast< unsigned long >(++m_Counter);
        value_type next = static_cast< value_type >(m_Initial + (next_counter * m_Step));
        return make_attribute_value(next);
    }
};

template< typename T >
class counter< T >::impl_inc :
    public impl
{
private:
    //! The counter
    boost::detail::atomic_count m_Counter;

public:
    /*!
     * Initializing constructor
     */
    explicit impl_inc(value_type initial) : m_Counter(initial - 1)
    {
    }

    attribute_value get_value()
    {
        return make_attribute_value(static_cast< value_type >(++m_Counter));
    }
};

template< typename T >
class counter< T >::impl_dec :
    public impl
{
private:
    //! The counter
    boost::detail::atomic_count m_Counter;

public:
    /*!
     * Initializing constructor
     */
    explicit impl_dec(value_type initial) : m_Counter(initial + 1)
    {
    }

    attribute_value get_value()
    {
        return make_attribute_value(static_cast< value_type >(--m_Counter));
    }
};

#else // BOOST_LOG_NO_THREADS

template< typename T >
class counter< T >::impl_generic :
    public impl
{
private:
    //! Step value
    const long m_Step;
    //! The counter
    value_type m_Counter;

public:
    /*!
     * Initializing constructor
     */
    impl_generic(value_type initial, long step) : m_Step(step), m_Counter(initial - step)
    {
    }

    attribute_value get_value()
    {
        m_Counter += m_Step;
        return make_attribute_value(m_Counter);
    }
};

#endif // BOOST_LOG_NO_THREADS

} // namespace attributes

BOOST_LOG_CLOSE_NAMESPACE // namespace log

} // namespace boost

#include <boost/log/detail/footer.hpp>

#endif // BOOST_LOG_ATTRIBUTES_COUNTER_HPP_INCLUDED_