circular.h

Go to the documentation of this file.

/*
 * circular.h
 *
 * Copyright (C) 2008   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.
 *
 *
 * Template for a circular buffer
 */

#ifndef WAVEPACKET_UTIL_CIRCULAR_H__
#define WAVEPACKET_UTIL_CIRCULAR_H__


/// \ingroup util
/// Simple circular buffer.
/// You can repeatedly add samples, and this class will keep only the most
/// current N samples in the buffer.  You can ask for the number of samples in
/// the buffer, and iterate through them.  Starting at index 0 means you will
/// always walk forward from the oldest to the newest sample in the buffer.
template <class T>
class circular_buffer_t {
public:
        // constructor ---------------------------------------------------------
        circular_buffer_t(IN int size) {
                        ASSERT(size > 0, "Bad size: %d", size);
                        m_buffer.reserve(size);
                        m_idx = 0;
                        m_max = size;
                        m_size = 0;
                }

        // circular_buffer_t - public class methods ----------------------------
        void addSample(IN const T& t) {
                        m_buffer[m_idx] = t;

                        // if buffer isn't full, increment size
                        if (m_size < m_max) {
                                ++m_size;
                        }

                        // increment index
                        m_idx = (m_idx + 1) % m_max;
                }

        int size(void) const throw() { return m_size; }

        /// idx = 0 is the oldest sample, always
        const T& getSample(IN int idx) const throw() {
                        idx = this->getActualIndex(idx);
                        return m_buffer[idx];
                }

        /// idx = 0 is the oldest sample, always
        T& getSample(IN int idx) throw() {
                        idx = this->getActualIndex(idx);
                        return m_buffer[idx];
                }

private:
        typedef std::vector<T> vec_type_t;

        int getActualIndex(IN int idx) const throw() {
                        ASSERT(idx >= 0, "Bad index: %d", idx);
                        ASSERT(idx < m_size, "Bad index: %d", idx);

                        if (m_size >= m_max) {
                                idx += m_idx;
                                idx = idx % m_max;
                        }
                        return idx;
                }

        vec_type_t              m_buffer;
        int                     m_max;          ///<- max allowed size
        int                     m_idx;          ///<- current index
        int                     m_size;         ///<- current size
};



#endif  // WAVEPACKET_UTIL_CIRCULAR_H__