vwr.cpp

Go to the documentation of this file.

#include "nmealib/nmea0183/vwr.h"
 
#include "nmealib/detail/errorSupport.h"
#include "nmealib/detail/parse.h"
 
#include <iomanip>
#include <sstream>
#include <vector>
 
namespace nmealib {
namespace nmea0183 {
 
std::unique_ptr<VWR> VWR::create(std::unique_ptr<Message0183> baseMessage) {
    std::string context = "VWR::create";
    if (baseMessage->getSentenceType() != "VWR") {
        NMEALIB_RETURN_ERROR(NotVWRException(context, "Expected sentence type 'VWR', 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() != 8) {
        NMEALIB_RETURN_ERROR(NotVWRException(context, "Invalid fields in VWR payload: expected 8, got " + std::to_string(fields.size()) + ". Payload: " + payload));
    }
 
    double windAngle = 0.0;
    double speedKnots = 0.0;
    double speedMps = 0.0;
    double speedKph = 0.0;
    if (!detail::parseOptionalDouble(fields[0], windAngle) ||
        !detail::parseOptionalDouble(fields[2], speedKnots) ||
        !detail::parseOptionalDouble(fields[4], speedMps) ||
        !detail::parseOptionalDouble(fields[6], speedKph)) {
        NMEALIB_RETURN_ERROR(NmeaException(context, "Error parsing VWR fields"));
    }
 
    char windSide = fields[1].empty() ? '\0' : fields[1][0];
    char speedKnotsUnit = fields[3].empty() ? '\0' : fields[3][0];
    char speedMpsUnit = fields[5].empty() ? '\0' : fields[5][0];
    char speedKphUnit = fields[7].empty() ? '\0' : fields[7][0];
 
    return std::unique_ptr<VWR>(new VWR(std::move(*baseMessage),
                                        windAngle,
                                        windSide,
                                        speedKnots,
                                        speedKnotsUnit,
                                        speedMps,
                                        speedMpsUnit,
                                        speedKph,
                                        speedKphUnit));
}
 
VWR::VWR(Message0183 baseMessage,
         double windAngle,
         char windSide,
         double speedKnots,
         char speedKnotsUnit,
         double speedMps,
         char speedMpsUnit,
         double speedKph,
         char speedKphUnit) noexcept
    : Message0183(std::move(baseMessage)),
      windAngle_(windAngle),
      windSide_(windSide),
      speedKnots_(speedKnots),
      speedKnotsUnit_(speedKnotsUnit),
      speedMps_(speedMps),
      speedMpsUnit_(speedMpsUnit),
      speedKph_(speedKph),
      speedKphUnit_(speedKphUnit) {}
 
VWR::VWR(std::string talkerId,
         double windAngle,
         char windSide,
         double speedKnots,
         double speedMps,
         double speedKph)
    : Message0183(*Message0183::create(composeRaw(talkerId,
                                                  windAngle,
                                                  windSide,
                                                  speedKnots,
                                                  speedMps,
                                                  speedKph))),
      windAngle_(windAngle),
      windSide_(windSide),
      speedKnots_(speedKnots),
      speedKnotsUnit_('N'),
      speedMps_(speedMps),
      speedMpsUnit_('M'),
      speedKph_(speedKph),
      speedKphUnit_('K') {}
 
std::unique_ptr<nmealib::Message> VWR::clone() const {
    return std::unique_ptr<VWR>(new VWR(*this));
}
 
std::string VWR::getStringContent(bool verbose) const noexcept {
    std::ostringstream ss;
    ss << this->toString(verbose);
    ss << std::fixed << std::setprecision(2);
 
    if (verbose) {
        ss << "\tWind Angle: " << windAngle_ << "\n";
        ss << "\tWind Side: " << windSide_ << "\n";
        ss << "\tSpeed: " << speedKnots_ << "kts\n";
        ss << "\tSpeed: " << speedMps_ << " m/s\n";
        ss << "\tSpeed: " << speedKph_ << " kph";
        ss << "\n";
    } else {
        ss << "Angle=" << windAngle_ << windSide_
           << ", Knots=" << speedKnots_
           << ", m/s=" << speedMps_
           << ", KPH=" << speedKph_;
    }
 
    return ss.str();
}
 
std::string VWR::composeRaw(const std::string& talkerId,
                            double windAngle,
                            char windSide,
                            double speedKnots,
                            double speedMps,
                            double speedKph) {
    std::ostringstream payloadStream;
    payloadStream << talkerId << "VWR,";
    payloadStream << std::fixed << std::setprecision(1) << windAngle << ",";
    payloadStream << windSide << ",";
    payloadStream << std::fixed << std::setprecision(1) << speedKnots << ",N,";
    payloadStream << std::fixed << std::setprecision(1) << speedMps << ",M,";
    payloadStream << std::fixed << std::setprecision(1) << speedKph << ",K";
 
    std::string payload = payloadStream.str();
    return "$" + payload + "\r\n";
}
 
double VWR::getWindAngle() const noexcept {
    return windAngle_;
}
 
char VWR::getWindSide() const noexcept {
    return windSide_;
}
 
double VWR::getSpeedKnots() const noexcept {
    return speedKnots_;
}
 
char VWR::getSpeedKnotsUnit() const noexcept {
    return speedKnotsUnit_;
}
 
double VWR::getSpeedMps() const noexcept {
    return speedMps_;
}
 
char VWR::getSpeedMpsUnit() const noexcept {
    return speedMpsUnit_;
}
 
double VWR::getSpeedKph() const noexcept {
    return speedKph_;
}
 
char VWR::getSpeedKphUnit() const noexcept {
    return speedKphUnit_;
}
 
bool VWR::operator==(const VWR& other) const noexcept {
    return Message0183::operator==(other);
}
 
} // namespace nmea0183
} // namespace nmealib