mtw.cpp

Go to the documentation of this file.

#include "nmealib/nmea0183/mtw.h"
 
#include "nmealib/detail/errorSupport.h"
#include "nmealib/detail/parse.h"
 
#include <iomanip>
#include <sstream>
#include <vector>
 
namespace nmealib {
namespace nmea0183 {
 
std::unique_ptr<MTW> MTW::create(std::unique_ptr<Message0183> baseMessage) {
    std::string context = "MTW::create";
    if (baseMessage->getSentenceType() != "MTW") {
        NMEALIB_RETURN_ERROR(NotMTWException(context, "Expected sentence type 'MTW', got " + baseMessage->getSentenceType()));
    }
 
    std::string payload = baseMessage->getPayload();
    std::istringstream ss(payload);
    std::string token;
    std::vector<std::string> fields;
 
    while (std::getline(ss, token, ',')) {
        fields.push_back(token);
    }
 
    if (!payload.empty() && payload.back() == ',') {
        fields.push_back("");
    }
 
    if (!fields.empty()) {
        fields.erase(fields.begin());
    }
 
    if (fields.size() != 2) {
        NMEALIB_RETURN_ERROR(NotMTWException(context, "Invalid fields in MTW payload: expected 2, got " + std::to_string(fields.size()) + ". Payload: " + payload));
    }
 
    double temperature = 0.0;
    if (!detail::parseOptionalDouble(fields[0], temperature)) {
        NMEALIB_RETURN_ERROR(NmeaException(context, "Error parsing MTW fields"));
    }
 
    char unit = fields[1].empty() ? '\0' : fields[1][0];
 
    return std::unique_ptr<MTW>(new MTW(std::move(*baseMessage),
                                        temperature,
                                        unit));
}
 
MTW::MTW(Message0183 baseMessage,
         double temperature,
         char unit) noexcept
    : Message0183(std::move(baseMessage)),
      temperature_(temperature),
      unit_(unit) {}
 
MTW::MTW(std::string talkerId,
         double temperature,
         char unit)
    : Message0183(*Message0183::create(composeRaw(talkerId, temperature, unit))),
      temperature_(temperature),
      unit_(unit) {}
 
std::unique_ptr<nmealib::Message> MTW::clone() const {
    return std::unique_ptr<MTW>(new MTW(*this));
}
 
std::string MTW::getStringContent(bool verbose) const noexcept {
    std::ostringstream ss;
    ss << this->toString(verbose);
    ss << std::fixed << std::setprecision(2);
 
    if (verbose) {
        ss << "\tTemperature: " << temperature_ << " " << unit_;
        ss << "\n";
    } else {
        ss << "Temperature=" << temperature_ << unit_;
    }
 
    return ss.str();
}
 
std::string MTW::composeRaw(const std::string& talkerId,
                             double temperature,
                             char unit) {
    std::ostringstream payloadStream;
    payloadStream << talkerId << "MTW,";
    payloadStream << std::fixed << std::setprecision(1) << temperature << ",";
    payloadStream << unit;
 
    std::string payload = payloadStream.str();
    return "$" + payload + "\r\n";
}
 
double MTW::getTemperature() const noexcept {
    return temperature_;
}
 
char MTW::getUnit() const noexcept {
    return unit_;
}
 
bool MTW::operator==(const MTW& other) const noexcept {
    return Message0183::operator==(other);
}
 
} // namespace nmea0183
} // namespace nmealib