threadsafe_counter.h

Go to the documentation of this file.

/*
 * threadsafe_counter.h
 *
 * Copyright (C) 2008,2009  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Implementation of a basic threadsafe counter, and a refcounter that uses it.
 */

#ifndef WAVEPACKET_THREADSAFE_REFCOUNT_H__
#define WAVEPACKET_THREADSAFE_REFCOUNT_H__

// includes --------------------------------------------------------------------
#include "common/common.h"
#include "smart_mutex.h"


/// \ingroup threadsafe
/*@{*/

///     Simple synchronized counter.  Handy for any sort of counting that needs
///     to be bumped up/down by different threads.
class threadsafe_counter {
public:
        threadsafe_counter(void) throw() : m_counter(0) { }

        // public class methods ------------------------------------------------

        /// returns the authoritative count after the increment
        long increment(void) throw() {
                        mlock l(m_mutex);
                        ++m_counter;
                        return m_counter;
                }

        /// returns the authoritative count after the decrement
        long decrement(void) throw() {
                        mlock l(m_mutex);
                        --m_counter;
                        return m_counter;
                }

        /// currently non-authoritative!  Not sure of a use case where that
        /// would help (other threads can change the count anyway)
        long getCount(void) const throw() {
                        // any point in synchronizing here?  Don't think so...
                        return m_counter;
                }

private:
        // private member data -------------------------------------------------
        smart_mutex             m_mutex;
        long                    m_counter;
};



/// put one of these on the stack to automatically increment/decrement a counter
class counter_ref {
public:
        counter_ref(IN threadsafe_counter * ptc) throw() {
                        ASSERT(ptc, "null");
                        m_ptc = ptc;
                        m_ptc->increment();
                }

        ~counter_ref(void) throw() {
                        ASSERT(m_ptc, "null");
                        m_ptc->decrement();
                }

private:
        // private member data -------------------------------------------------
        threadsafe_counter *    m_ptc;
};



class threadsafe_refcount {
public:
        // constructor, destructors --------------------------------------------
        threadsafe_refcount(void) throw() : m_pcounter(NULL) { this->init(); }
        threadsafe_refcount(IN const threadsafe_refcount& trc) throw() : 
                m_pcounter(NULL) { this->attach(trc); }
        ~threadsafe_refcount(void) throw() { this->release(); }

        // public class methods ------------------------------------------------
        long getRefCount(void) const throw() {
                        if (!m_pcounter) {
                                return 0;
                        }
                        return m_pcounter->getCount();
                }

private:
        // private helper methods ----------------------------------------------
        void release(void) throw() {
                        if (m_pcounter) {
                                long l = m_pcounter->decrement();
                                if (l < 1) {
                                        delete m_pcounter;
                                }
                                m_pcounter = 0;
                        }
                }

        void init(void) throw() {
                        this->release();
                        m_pcounter = new threadsafe_counter;
                        ASSERT(m_pcounter, "null");
                        m_pcounter->increment();
                }

        void attach(IN const threadsafe_refcount& trc) throw() {
                        threadsafe_counter * ptc = trc.m_pcounter;
                        ASSERT(ptc, "null");
                        m_pcounter = ptc;
                        m_pcounter->increment();
                }

        // private member data -------------------------------------------------
        threadsafe_counter *            m_pcounter;
};


#endif  // WAVEPACKET_THREADSAFE_REFCOUNT_H__