common/history.cc

Go to the documentation of this file.

//
// history.cc - the definition of the History class
//
// ***** BEGIN LICENSE BLOCK *****
// Version: MPL 1.1/GPL 2.0/LGPL 2.1
// 
// The contents of this file are subject to the Mozilla Public License
// Version 1.1 (the "License"); you may not use this file except in
// compliance with the License. You may obtain a copy of the License at
// http://www.mozilla.org/MPL/
// 
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
// the License for the specific language governing rights and limitations
// under the License.
// 
// The Original Code is the consmgr network/serial-line monitoring package.
// 
// The Initial Developer of the Original Code is Chris P. Ross.
// Portions created by the Initial Developer are Copyright (C) 2000-2008
// the Initial Developer.  All Rights Reserved.
// 
// Contributor(s):
// 
// Alternatively, the contents of this file may be used under the terms of
// either the GNU General Public License Version 2 or later (the "GPL"), or
// the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
// in which case the provisions of the GPL or the LGPL are applicable instead
// of those above. If you wish to allow use of your version of this file only
// under the terms of either the GPL or the LGPL, and not to allow others to
// use your version of this file under the terms of the MPL, indicate your
// decision by deleting the provisions above and replace them with the notice
// and other provisions required by the GPL or the LGPL. If you do not delete
// the provisions above, a recipient may use your version of this file under
// the terms of any one of the MPL, the GPL or the LGPL.
// 
// ***** END LICENSE BLOCK *****

#include <sstream>

#include "consmgr.h"
#include "history.h"
#include "guard.h"

History::History(const int size) : lines(size), start_a_new_line(true)
{
    // XXX - set up circular buffer?  Read from somewhere?
    Guard::initialize_mutex(buf_mutex);
    return;
}

History::~History()
{
    disconnect();
    Guard::destroy_mutex(buf_mutex);
}

#if 0
void
History::notify_on_disconnect(const Messageable *owner)
{
    add_recipient(owner);
}
#endif

std::string
History::get_id(void) const
{
    std::ostringstream  id_str;

    id_str << "History(" << lines.size() << "/" << lines.max_size() << ")";

    return(id_str.str());
}

Data *
History::read()
{
    throw(fireball(28, "History::read() not implemented [yet]!"));
}

ssize_t
History::write(const Data &d)
{
    const u_char        *dptr = d.data(), *end = (dptr + d.len());
    int         ret;

    clog << "History::write()" << endl;
    
    // Lock the mutex protecting the CircBuffer<>
    ret = pthread_mutex_lock(&buf_mutex);
    PTHREAD_CHECK_AND_THROW(ret, "mutex_lock(buf_mutex)");

    //clog << "should now be storing " << b->len() << " bytes of data:"
    // << string(reinterpret_cast<const char *>(b->data()), b->len()) << endl;

    string      last_line;

    if (start_a_new_line || lines.empty())
        last_line = "";
    else {
        // Store a copy of the partial-line, and remove it from
        // the vector<>.
        last_line = lines.back();
        lines.pop_back();
    }

    // sol - Byte that starts the line
    // eol - Byte *after* the last byte of the line 
    u_char      *sol = NULL;

    for ( u_char *eol = const_cast<u_char*>(dptr) ; eol <= end ; eol++ ) {
        if (sol == NULL)
            sol = eol;
        if (*eol == '\n') {
            // Should I do something more complicated to match multiple
            // possible EOL sequences?  Should I just assume some protocol
            // will cope with that for me?
            while ((eol > sol) && (*(eol-1) == '\r'))
                eol--;

            //clog << "last_line.length() == " << last_line.length() << endl;
            if (last_line.length() > 0) {
                //clog << "Appending new line to old '" << last_line << "'" << endl;
                lines.push_back(last_line +
                                string(reinterpret_cast<const char*>(sol),
                                       (eol-sol)));
                last_line = "";
            } else
                lines.push_back(string(reinterpret_cast<const char*>(sol),
                                       (eol-sol)));

            while (*eol == '\r')
                eol++;
            sol = NULL;
        }
    }
    // If it didn't end evenly on an EOL, then put the partial line
    // into the vector<>.  In either case, mark whether or not the
    // next line should be a new line.
    if (sol == NULL)
        start_a_new_line = true;
    else {
        lines.push_back(last_line +
                        string(reinterpret_cast<const char*>(sol), (end-sol)));
        start_a_new_line = false;
    }

    // We're done changing the contents of the CircBuffer, so unlock the mutex.
    ret = pthread_mutex_unlock(&buf_mutex);
    PTHREAD_CHECK_AND_THROW(ret, "mutex_unlock(buf_mutex)");

    // XXX - should this debugging/logging be done while the mutex is locked?
    clog << "Now " << lines.size() << " lines in " << this->get_id()
         << ": [[[" << endl;
    for (std::vector<string>::iterator vi = lines.begin() ; vi < lines.end() ;
         vi++)
        clog << "  |" << *vi << "|" << endl;
    clog << "]]]" << endl;

    return d.len();
}

void
History::disconnect(void)
{
    Guard       locker(&buf_mutex);
    
    lines.clear();

    return;
}

---