LogStore.cpp

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* @package    ArmarX::
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#include "LogStore.h"
 
#include <IceUtil/Time.h>
 
namespace armarx
{
    namespace
    {
        // Format the time column (0) value, guarding the substr against a missing space
        // (which would otherwise throw).
        QString
        formatTime(Ice::Long timeMicroSeconds)
        {
            IceUtil::Time time = IceUtil::Time::microSeconds(timeMicroSeconds);
            std::string timeStr = time.toDateTime();
            const auto spacePos = timeStr.find(' ');
            if (spacePos != std::string::npos)
            {
                timeStr = timeStr.substr(spacePos);
            }
            return QString::fromStdString(timeStr);
        }
 
        // Build the message column (4) display string (truncated to a maximum number of
        // lines) and report how many display lines it spans.
        QString
        buildDisplayMessage(const LogMessage& entry, int& lineCount)
        {
            QString whatStr = entry.backtrace.empty()
                                  ? QString::fromStdString(entry.what)
                                  : QString::fromStdString(entry.what + "\nBacktrace:\n...");
 
            constexpr int maxLinesToShow = 50;
            int lines = 0;
            int pos = 0;
            for (int i = 0; i < whatStr.length(); i++)
            {
                if (whatStr.at(i) == '\n')
                {
                    lines++;
                }
                if (lines == maxLinesToShow)
                {
                    break;
                }
                pos++;
            }
            if (lines >= maxLinesToShow)
            {
                whatStr.truncate(pos);
                whatStr += "\n...";
            }
 
            lineCount = whatStr.count('\n') + 1;
            return whatStr;
        }
    } // namespace
 
    LogStore::LogStore(std::size_t maxEntries) : maxEntries(maxEntries)
    {
    }
 
    LogSeq
    LogStore::append(const LogMessage& message)
    {
        StoredLogEntry entry;
        entry.message = message;
        entry.timeString = formatTime(message.time);
        entry.displayMessage = buildDisplayMessage(message, entry.lineCount);
 
        const LogSeq seq = endSeq();
        entries.push_back(std::move(entry));
        return seq;
    }
 
    bool
    LogStore::trim()
    {
        if (maxEntries == 0 || entries.size() <= maxEntries)
        {
            return false;
        }
 
        const std::size_t removeCount = entries.size() - maxEntries;
        entries.erase(entries.begin(), entries.begin() + removeCount);
        first += removeCount;
        return true;
    }
 
    LogSeq
    LogStore::firstSeq() const
    {
        return first;
    }
 
    LogSeq
    LogStore::endSeq() const
    {
        return first + entries.size();
    }
 
    bool
    LogStore::contains(LogSeq seq) const
    {
        return seq >= first && seq < endSeq();
    }
 
    const StoredLogEntry&
    LogStore::at(LogSeq seq) const
    {
        return entries[seq - first];
    }
 
    std::size_t
    LogStore::size() const
    {
        return entries.size();
    }
 
    void
    LogStore::clear()
    {
        // Keep counting sequence numbers up rather than resetting to 0, so that any
        // reference still held to a discarded entry stays invalid instead of silently
        // aliasing a future one.
        first = endSeq();
        entries.clear();
    }
} // namespace armarx