Mqtt.cpp File Reference

#include "Mqtt.h"
#include <iot/mqtt/Topic.h>
#include <iot/mqtt/packets/Connack.h>
#include <iot/mqtt/packets/Publish.h>
#include <iot/mqtt/packets/Suback.h>
#include <nlohmann/json.hpp>

Include dependency graph for Mqtt.cpp:

Go to the source code of this file.

Namespaces
namespace	mqtt
namespace	mqtt::mqttcli
namespace	mqtt::mqttcli::lib

Functions
static int	getTerminalWidth ()
static std::vector< std::string >	wrapParagraph (const std::string &text, std::size_t width)
static std::vector< std::string >	myformat (const std::string &prefix, const std::string &headLine, const std::string &message, std::size_t initialPrefixLength=0)
static const std::string	formatAsLogString (const std::string &prefix, const std::string &headLine, const std::string &message)
static uint8_t	mqtt::mqttcli::lib::getQos (const std::string &qoSString)

Function Documentation

formatAsLogString()

const std::string formatAsLogString ( const std::string & prefix, const std::string & headLine, const std::string & message )

static

Definition at line 204 of file Mqtt.cpp.

                                                                                                                       {
    std::ostringstream formatAsLogStringStream;
 
    for (const std::string& line : myformat(prefix, headLine, message, 34)) {
        formatAsLogStringStream << (formatAsLogStringStream.view().empty() ? "" : "                                  ") << line << "\n";
    }
 
    std::string formatStr = formatAsLogStringStream.str();
 
    formatStr.pop_back();
 
    return formatStr;
}

References myformat().

Referenced by mqtt::mqttcli::lib::Mqtt::onPublish().

Here is the call graph for this function:

Here is the caller graph for this function:

getTerminalWidth()

int getTerminalWidth ( )

static

Definition at line 76 of file Mqtt.cpp.

                              {
    int termWidth = 80;
 
    struct winsize w;
    if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) == 0 && w.ws_col > 0) {
        termWidth = w.ws_col;
    }
 
    return termWidth;
}

Referenced by myformat().

Here is the caller graph for this function:

myformat()

std::vector< std::string > myformat ( const std::string & prefix, const std::string & headLine, const std::string & message, std::size_t initialPrefixLength = 0 )

static

Formats: prefix ┬ headLine ├ <first message line> │ <middle lines> └ <last message line>

If message parses as JSON, we pretty‐print it (indent=2). Otherwise we wrap it to the terminal width.

Returns the whole formatted string (with trailing newline on each line).

Definition at line 122 of file Mqtt.cpp.

                                                                            {
    // how many spaces before the box‐drawing char on subsequent lines?
    const size_t prefixLen = prefix.size();
    const size_t indentCount = prefixLen + 1; // +1 for the space before ┬, +33 for easylogging++ prefix format
    const std::string indent(indentCount, ' ');
 
    std::vector<std::string> lines;
 
    const int termWidth = getTerminalWidth();
 
    size_t avail = (termWidth > int(indentCount + 2)) ? static_cast<std::size_t>(termWidth) - (indentCount + 2) : 20u;
 
    auto wrapped = wrapParagraph(prefix + " ┬ " + headLine, avail - (prefix.length() + 2));
 
    if (wrapped.empty()) {
        wrapped.push_back("");
    }
 
    //    lines.insert(lines.end(), wrapped.begin(), wrapped.end());
 
    bool first = true;
    for (const auto& line : wrapped) {
        lines.emplace_back((first ? "" : indent + "│ ") + line);
        first = false;
    }
 
    // try parsing as JSON
    try {
        auto j = json::parse(message);
        // pretty‐print with 2-space indent
        std::string pretty = j.dump(2);
        // split into lines
        std::istringstream prettyIStringStream(pretty);
 
        for (auto [line, lineNumnber] = std::tuple{std::string(""), 0}; std::getline(prettyIStringStream, line); lineNumnber++) {
            if (lineNumnber == 0 && !prettyIStringStream.eof()) {
                lines.push_back(indent + "├ " + line);
            } else if (prettyIStringStream.eof()) {
                lines.push_back(indent + "└ " + line);
            } else {
                lines.push_back(indent + "│ " + line);
            }
        }
    } catch (json::parse_error&) {
        // not JSON → wrap text
 
        // break original message on hard newlines and wrap each paragraph
        std::istringstream messageIStringStream(message);
        std::vector<std::string> allLines;
        for (std::string line; std::getline(messageIStringStream, line);) {
            wrapped = wrapParagraph(line, avail - initialPrefixLength);
 
            if (wrapped.empty()) {
                wrapped.push_back("");
            }
 
            allLines.insert(allLines.end(), wrapped.begin(), wrapped.end());
        }
 
        if (!allLines.empty() && allLines.back().empty()) {
            allLines.pop_back();
        }
 
        // emit with ├, │ and └
        for (std::size_t lineNumber = 0; lineNumber < allLines.size(); ++lineNumber) {
            if (lineNumber == 0 && lineNumber + 1 != allLines.size()) {
                lines.push_back(indent + "├ " + allLines[lineNumber]);
            } else if (lineNumber + 1 == allLines.size()) {
                lines.push_back(indent + "└ " + allLines[lineNumber]);
            } else {
                lines.push_back(indent + "│ " + allLines[lineNumber]);
            }
        }
    }
 
    return lines;
}

References getTerminalWidth(), and wrapParagraph().

Referenced by formatAsLogString().

Here is the call graph for this function:

Here is the caller graph for this function:

wrapParagraph()

std::vector< std::string > wrapParagraph ( const std::string & text, std::size_t width )

static

Definition at line 88 of file Mqtt.cpp.

                                                                                  {
    std::istringstream words(text);
    std::string word, line;
    std::vector<std::string> lines;
    while (words >> word) {
        if (line.empty()) {
            line = word;
        } else if (line.size() + 1 + word.size() <= width) {
            line += ' ' + word;
        } else {
            lines.push_back(line);
            line = word;
        }
    }
 
    if (!line.empty()) {
        lines.push_back(line);
    }
 
    return lines;
}

Referenced by myformat().

Here is the caller graph for this function: