cmnCallbackStreambuf.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):  Peter Kazanzides
  Created on: 2006-01-13
 
  (C) Copyright 2006-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 _cmnCallbackStreambuf_h
#define _cmnCallbackStreambuf_h
 
#include <cisstCommon/cmnPortability.h>
#include <iostream>

 
template<class _element, class _trait = std::char_traits<_element> >
class cmnCallbackStreambuf : public std::basic_streambuf<_element, _trait>
{
public:
    typedef typename std::basic_streambuf<_element, _trait>::int_type int_type;
    typedef _element ElementType;
    typedef void (*CallbackType)(const ElementType *, int len);

    cmnCallbackStreambuf(CallbackType func) : Idx(0), Callback(func) { }
 
protected:
 
    ElementType Buffer[256];
    unsigned int Idx;
    CallbackType Callback;

    virtual void PrintLine() {  Buffer[Idx] = 0; Callback(Buffer, Idx); Idx = 0; }

    virtual int_type overflow( int_type c)
    {
        // follow the basic_streambuf standard
        if (_trait::eq_int_type(_trait::eof(), c))
            return (_trait::not_eof(c));
 
        // This code assumes that the buffer can never be full
        // on entry because full buffers are always printed.
        Buffer[Idx++] = c;
        if (c == '\n')
            PrintLine();   // We got a newline, print the buffer
        else if (Idx >= sizeof(Buffer)-1)
            PrintLine();   // Buffer is full, print it
 
        // follow the basic_streambuf standard
        return _trait::not_eof(c);
    }

    virtual std::streamsize xsputn(const ElementType* s, std::streamsize n)
    {
        std::streamsize todo = n;
        while (todo > 0) {
            std::streamsize tmp = static_cast<std::streamsize>(sizeof(Buffer)-Idx-1);
            std::streamsize limit = (todo < tmp) ? todo : tmp;
            for (std::streamsize i=0; i < limit; i++) {
                Buffer[Idx++] = *s;
                if (*s == '\n')
                    PrintLine();
                s++;
            }
            todo -= limit;
            // If buffer is full, print it
            if (Idx >= sizeof(Buffer)-1)
                PrintLine();
        }
        // If buffer is full, print it
        if (Idx >= sizeof(Buffer)-1)
            PrintLine();
        return n;
    }

    virtual int sync()
    {
        if (Idx > 0)
            PrintLine();
        return 0;
    }
};
 
#endif // _cmnCallbackStreambuf_h