cmnLODMultiplexerStreambuf.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-05-17

  (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 _cmnLODMultiplexerStreambuf_h
#define _cmnLODMultiplexerStreambuf_h

#include <cisstCommon/cmnForwardDeclarations.h>
#include <cisstCommon/cmnPortability.h>
#include <cisstCommon/cmnLogLoD.h>


#include <list>
#include <algorithm>
#include <fstream>

template <class _element, class _trait = std::char_traits<_element> >
class cmnLODMultiplexerStreambuf : public std::basic_streambuf<_element, _trait>
{
    friend class cmnMultiplexerStreambufProxy<_element, _trait>;

public:

    typedef cmnLODMultiplexerStreambuf<_element, _trait> ThisType;
    typedef std::basic_streambuf<_element, _trait> BaseClassType;
    typedef std::basic_streambuf<_element, _trait> ChannelType;

    typedef std::pair<ChannelType *, cmnLogMask> ElementType;

    typedef std::list<ElementType> ChannelContainerType;
    typedef typename ChannelContainerType::iterator IteratorType;
    typedef typename ChannelContainerType::const_iterator ConstIteratorType;

    typedef std::list<ThisType *> MultiplexerContainerType;
    typedef typename MultiplexerContainerType::iterator MultiplexerIteratorType;
    typedef typename MultiplexerContainerType::const_iterator MultiplexerConstIteratorType;

    cmnLODMultiplexerStreambuf(std::ofstream & fileStream) {
        this->AddChannel(fileStream.rdbuf(), CMN_LOG_ALLOW_ALL);
    }

    cmnLODMultiplexerStreambuf()
    {}


    bool AddChannel(ChannelType * channel, cmnLogMask mask);


    inline bool AddChannel(std::ostream & outstream, cmnLogMask mask) {
        return AddChannel(outstream.rdbuf(), mask);
    }


    bool AddMultiplexer(ThisType * multiplexer);


    void RemoveChannel(ChannelType * channel);


    void RemoveMultiplexer(ThisType * multiplexer);


    inline void RemoveChannel(std::ostream & outstream) {
        RemoveChannel(outstream.rdbuf());
    }


    void RemoveAllChannels(void);


    bool SetChannelMask(ChannelType * channel, cmnLogMask mask);


    bool GetChannelMask(const ChannelType * channel, cmnLogMask & mask) const;

    const ChannelContainerType & GetChannels(void) const {
        return Channels;
    }

    // Here we provide basic_streambuf namesame methods for multiplexing.
    // This part is declared 'protected' following the declarations of
    // basic_streambuf. See basic_streambuf documentation for more
    // details.
protected:
    typedef typename std::basic_streambuf<_element, _trait>::int_type int_type;

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

    virtual int sync();

    virtual int_type overflow(int_type c, cmnLogLevel level);

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

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

//private:
    ChannelContainerType Channels;

    IteratorType FindChannel(const ChannelType * channel);

    ConstIteratorType FindChannel(const ChannelType * channel) const;

    MultiplexerContainerType Multiplexers;

    MultiplexerIteratorType FindMultiplexer(const ThisType * multiplexer);

    MultiplexerConstIteratorType FindMultiplexer(const ThisType * multiplexer) const;
};



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


template <class _element, class _trait>
bool cmnLODMultiplexerStreambuf<_element, _trait>::AddChannel(ChannelType * channel, cmnLogMask mask)
{
    IteratorType it = FindChannel(channel);

    if (it == Channels.end()) {
        Channels.insert(it, ElementType(channel, mask));
        return true;
    }
    return false;
}


template <class _element, class _trait>
bool cmnLODMultiplexerStreambuf<_element, _trait>::AddMultiplexer(ThisType * multiplexer)
{
    MultiplexerIteratorType it = FindMultiplexer(multiplexer);

    if (it == Multiplexers.end()) {
        Multiplexers.insert(it, multiplexer);
        return true;
    }
    return false;
}


template <class _element, class _trait>
void cmnLODMultiplexerStreambuf<_element, _trait>::RemoveChannel(ChannelType * channel)
{
    IteratorType it = FindChannel(channel);

    if (it != Channels.end()) {
        Channels.erase(it);
    }
}


template <class _element, class _trait>
void cmnLODMultiplexerStreambuf<_element, _trait>::RemoveMultiplexer(ThisType * multiplexer)
{
    MultiplexerIteratorType it = FindMultiplexer(multiplexer);

    if (it != Multiplexers.end()) {
        Multiplexers.erase(it);
    }
}


template <class _element, class _trait>
void cmnLODMultiplexerStreambuf<_element, _trait>::RemoveAllChannels(void)
{
    Channels.clear();
    Multiplexers.clear();
}


template <class _element, class _trait>
bool cmnLODMultiplexerStreambuf<_element, _trait>::SetChannelMask(ChannelType * channel, cmnLogMask mask)
{
    IteratorType it = FindChannel(channel);
    if (it != Channels.end()) {
        (*it).second = mask;
        return true;
    }
    return false;
}


template <class _element, class _trait>
bool cmnLODMultiplexerStreambuf<_element, _trait>::GetChannelMask(const ChannelType * channel, cmnLogMask & mask) const
{
    ConstIteratorType it = FindChannel(channel);
    if (it != Channels.end()) {
        mask = (*it).second;
        return true;
    }
    return false;
}


template <class _element, class _trait>
std::streamsize cmnLODMultiplexerStreambuf<_element, _trait>::xsputn(const _element * s, std::streamsize n, cmnLogLevel level)
{
    // for channels, compare to channel's mask
    std::streamsize ssize(0);
    IteratorType channelIt;
    const IteratorType channelEnd = Channels.end(); 
    for (channelIt = Channels.begin();
         channelIt != channelEnd;
         ++channelIt) {
        if (level & ((*channelIt).second)) {
            ssize = ((*channelIt).first)->sputn(s, n);
        }
    }
    // for multiplexers, just send message along with log level
    MultiplexerIteratorType multiplexerIt;
    const MultiplexerIteratorType multiplexerEnd = Multiplexers.end();
    for (multiplexerIt = Multiplexers.begin();
         multiplexerIt != multiplexerEnd;
         ++multiplexerIt) {
        ssize = (*multiplexerIt)->xsputn(s, n, level);
    }
    return ssize;
}


template <class _element, class _trait>
int cmnLODMultiplexerStreambuf<_element, _trait>::sync(void)
{
    IteratorType channelIt;
    // synchronize all channels
    const IteratorType channelEnd = Channels.end(); 
    for (channelIt = Channels.begin();
         channelIt != channelEnd;
         ++channelIt) {
        ((*channelIt).first)->pubsync();
    }
    // synchronize all multiplexers
    MultiplexerIteratorType multiplexerIt;
    const MultiplexerIteratorType multiplexerEnd = Multiplexers.end();
    for (multiplexerIt = Multiplexers.begin();
         multiplexerIt != multiplexerEnd;
         ++multiplexerIt) {
        (*multiplexerIt)->sync();
    }
    return 0;
}


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

    // multiplexing
    IteratorType channelIt;
    const IteratorType channelEnd = Channels.end(); 
    for (channelIt = Channels.begin();
         channelIt != channelEnd;
         ++channelIt) {
        if (level & ((*channelIt).second)) {
            ((*channelIt).first)->sputc(_trait::to_char_type(c));
        }
    }
    // for multiplexers, just send message along with log level
    MultiplexerIteratorType multiplexerIt;
    const MultiplexerIteratorType multiplexerEnd = Multiplexers.end();
    for (multiplexerIt = Multiplexers.begin();
         multiplexerIt != multiplexerEnd;
         ++multiplexerIt) {
        (*multiplexerIt)->overflow(c, level);
    }
    // follow the basic_streambuf standard
    return _trait::not_eof(c);
}


template <class _element, class _trait>
std::streamsize cmnLODMultiplexerStreambuf<_element, _trait>::xsputn(const _element *s, std::streamsize n)
{
    std::streamsize ssize(0);
    // channels
    IteratorType channelIt;
    const IteratorType channelEnd = Channels.end(); 
    for (channelIt = Channels.begin();
         channelIt != channelEnd;
         ++channelIt) {
        ssize = ((*channelIt).first)->sputn(s, n);
    }
    // for multiplexers, just send message along
    MultiplexerIteratorType multiplexerIt;
    const MultiplexerIteratorType multiplexerEnd = Multiplexers.end();
    for (multiplexerIt = Multiplexers.begin();
         multiplexerIt != multiplexerEnd;
         ++multiplexerIt) {
        ssize = (*multiplexerIt)->xsputn(s, n);
    }
    return ssize;
}


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

    // channels
    IteratorType channelIt;
    const IteratorType channelEnd = Channels.end(); 
    for (channelIt = Channels.begin();
         channelIt != channelEnd;
         ++channelIt) {
        ((*channelIt).first)->sputc(_trait::to_char_type(c));
    }
    // for multiplexers, just send message along
    MultiplexerIteratorType multiplexerIt;
    const MultiplexerIteratorType multiplexerEnd = Multiplexers.end();
    for (multiplexerIt = Multiplexers.begin();
         multiplexerIt != multiplexerEnd;
         ++multiplexerIt) {
        (*multiplexerIt)->overflow(c);
    }

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


template <class _element, class _trait>
typename cmnLODMultiplexerStreambuf<_element, _trait>::IteratorType
cmnLODMultiplexerStreambuf<_element, _trait>::FindChannel(const ChannelType * channel)
{
    IteratorType it = Channels.begin();
    while (it != Channels.end()) {
        if ((*it).first == channel) {
            break;
        }
        ++it;
    }
    return it;
}


template <class _element, class _trait>
typename cmnLODMultiplexerStreambuf<_element, _trait>::ConstIteratorType
cmnLODMultiplexerStreambuf<_element, _trait>::FindChannel(const ChannelType * channel) const
{
    ConstIteratorType it = Channels.begin();
    while (it != Channels.end()) {
        if ((*it).first == channel) {
            break;
        }
        ++it;
    }
    return it;
}


template <class _element, class _trait>
typename cmnLODMultiplexerStreambuf<_element, _trait>::MultiplexerIteratorType
cmnLODMultiplexerStreambuf<_element, _trait>::FindMultiplexer(const ThisType * multiplexer)
{
    MultiplexerIteratorType it = Multiplexers.begin();
    while (it != Multiplexers.end()) {
        if ((*it) == multiplexer) {
            break;
        }
        ++it;
    }
    return it;
}


template <class _element, class _trait>
typename cmnLODMultiplexerStreambuf<_element, _trait>::MultiplexerConstIteratorType
cmnLODMultiplexerStreambuf<_element, _trait>::FindMultiplexer(const ThisType * multiplexer) const
{
    MultiplexerConstIteratorType it = Multiplexers.begin();
    while (it != Multiplexers.end()) {
        if ((*it) == multiplexer) {
            break;
        }
        ++it;
    }
    return it;
}


#endif