cmnMultiplexerStreambuf.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):  Ofri Sadowsky
  Created on: 2002-04-19

  (C) Copyright 2002-2007 Johns Hopkins University (JHU), All Rights
  Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---

*/


#pragma once

#ifndef _cmnMultiplexerStreambuf_h
#define _cmnMultiplexerStreambuf_h

#include <cisstCommon/cmnPortability.h>

#include <list>
#include <algorithm>

template<class _element, class _trait = std::char_traits<_element> >
class cmnMultiplexerStreambuf : public std::basic_streambuf<_element, _trait>
{
    public:

    typedef std::basic_streambuf<_element, _trait> ChannelType;
    typedef typename std::basic_streambuf<_element, _trait>::int_type int_type;

    typedef std::list<ChannelType *> ChannelContainerType;

    cmnMultiplexerStreambuf()
    {}

    void AddChannel(ChannelType *channel);

    void RemoveChannel(ChannelType * channel);

    const ChannelContainerType & GetChannels() const
    {
        return m_ChannelContainer;
    }


    // Here we override the basic_streambuf methods for multiplexing.
    // This part is declared 'protected' following the declarations of
    // basic_streambuf. See basic_streambuf documentation for more
    // details.
    protected:

    virtual std::streamsize xsputn(const _element *s, std::streamsize n);

    virtual int sync();

    virtual int_type overflow(int_type c = _trait::eof());

    private:
    ChannelContainerType m_ChannelContainer;

};


//********************************
// Template method implementation
//********************************


template<class _element, class _trait>
void cmnMultiplexerStreambuf<_element, _trait>::AddChannel(ChannelType * channel)
{
    typename ChannelContainerType::iterator it = find(m_ChannelContainer.begin(), m_ChannelContainer.end(),
                                                      channel);

    if (it == m_ChannelContainer.end()) {
        m_ChannelContainer.insert(it, channel);
    }
}


template<class _element, class _trait>
void cmnMultiplexerStreambuf<_element, _trait>::RemoveChannel(ChannelType * channel)
{
    m_ChannelContainer.remove(channel);
}


template<class _element, class _trait>
std::streamsize cmnMultiplexerStreambuf<_element, _trait>::xsputn(const _element *s, std::streamsize n)
{
    std::streamsize ssize;
    typename ChannelContainerType::iterator it;
    for (it = m_ChannelContainer.begin(); it != m_ChannelContainer.end(); it++) {
        ssize = (*it)->sputn(s, n);
    }
    return ssize;
}


template<class _element, class _trait>
int cmnMultiplexerStreambuf<_element, _trait>::sync()
{
    typename ChannelContainerType::iterator it;
    // synchronize all the channels
    for (it = m_ChannelContainer.begin(); it != m_ChannelContainer.end(); it++) {
        (*it)->pubsync();
    }
    return 0;
}


template<class _element, class _trait>
typename cmnMultiplexerStreambuf<_element, _trait>::int_type
cmnMultiplexerStreambuf<_element, _trait>::overflow(int_type c)
{
    // follow the basic_streambuf standard
    if (_trait::eq_int_type(_trait::eof(), c))
        return (_trait::not_eof(c));

    typename ChannelContainerType::iterator it;

    // multiplexing
    for (it = m_ChannelContainer.begin(); it != m_ChannelContainer.end(); it++) {
        (*it)->sputc(_trait::to_char_type(c));
    }

    // follow the basic_streambuf standard
    return _trait::not_eof(c);
}


#endif // _cmnMultiplexerStreambuf_h