SWGLimeSdrOutputReport.cpp

Go to the documentation of this file.

#include "SWGLimeSdrOutputReport.h"

#include "SWGHelpers.h"

#include <QJsonDocument>
#include <QJsonArray>
#include <QObject>
#include <QDebug>

namespace SWGSDRangel {

SWGLimeSdrOutputReport::SWGLimeSdrOutputReport(QString* json) {
    init();
    this->fromJson(*json);
}

SWGLimeSdrOutputReport::SWGLimeSdrOutputReport() {
    success = 0;
    m_success_isSet = false;
    stream_active = 0;
    m_stream_active_isSet = false;
    fifo_size = 0;
    m_fifo_size_isSet = false;
    fifo_fill = 0;
    m_fifo_fill_isSet = false;
    underrun_count = 0;
    m_underrun_count_isSet = false;
    overrun_count = 0;
    m_overrun_count_isSet = false;
    dropped_packets_count = 0;
    m_dropped_packets_count_isSet = false;
    link_rate = 0.0f;
    m_link_rate_isSet = false;
    hw_timestamp = 0;
    m_hw_timestamp_isSet = false;
    temperature = 0.0f;
    m_temperature_isSet = false;
    gpio_dir = 0;
    m_gpio_dir_isSet = false;
    gpio_pins = 0;
    m_gpio_pins_isSet = false;
}

SWGLimeSdrOutputReport::~SWGLimeSdrOutputReport() {
    this->cleanup();
}

void
SWGLimeSdrOutputReport::init() {
    success = 0;
    m_success_isSet = false;
    stream_active = 0;
    m_stream_active_isSet = false;
    fifo_size = 0;
    m_fifo_size_isSet = false;
    fifo_fill = 0;
    m_fifo_fill_isSet = false;
    underrun_count = 0;
    m_underrun_count_isSet = false;
    overrun_count = 0;
    m_overrun_count_isSet = false;
    dropped_packets_count = 0;
    m_dropped_packets_count_isSet = false;
    link_rate = 0.0f;
    m_link_rate_isSet = false;
    hw_timestamp = 0;
    m_hw_timestamp_isSet = false;
    temperature = 0.0f;
    m_temperature_isSet = false;
    gpio_dir = 0;
    m_gpio_dir_isSet = false;
    gpio_pins = 0;
    m_gpio_pins_isSet = false;
}

void
SWGLimeSdrOutputReport::cleanup() {












}

SWGLimeSdrOutputReport*
SWGLimeSdrOutputReport::fromJson(QString &json) {
    QByteArray array (json.toStdString().c_str());
    QJsonDocument doc = QJsonDocument::fromJson(array);
    QJsonObject jsonObject = doc.object();
    this->fromJsonObject(jsonObject);
    return this;
}

void
SWGLimeSdrOutputReport::fromJsonObject(QJsonObject &pJson) {
    ::SWGSDRangel::setValue(&success, pJson["success"], "qint32", "");
    
    ::SWGSDRangel::setValue(&stream_active, pJson["streamActive"], "qint32", "");
    
    ::SWGSDRangel::setValue(&fifo_size, pJson["fifoSize"], "qint32", "");
    
    ::SWGSDRangel::setValue(&fifo_fill, pJson["fifoFill"], "qint32", "");
    
    ::SWGSDRangel::setValue(&underrun_count, pJson["underrunCount"], "qint32", "");
    
    ::SWGSDRangel::setValue(&overrun_count, pJson["overrunCount"], "qint32", "");
    
    ::SWGSDRangel::setValue(&dropped_packets_count, pJson["droppedPacketsCount"], "qint32", "");
    
    ::SWGSDRangel::setValue(&link_rate, pJson["linkRate"], "float", "");
    
    ::SWGSDRangel::setValue(&hw_timestamp, pJson["hwTimestamp"], "qint32", "");
    
    ::SWGSDRangel::setValue(&temperature, pJson["temperature"], "float", "");
    
    ::SWGSDRangel::setValue(&gpio_dir, pJson["gpioDir"], "qint32", "");
    
    ::SWGSDRangel::setValue(&gpio_pins, pJson["gpioPins"], "qint32", "");
    
}

QString
SWGLimeSdrOutputReport::asJson ()
{
    QJsonObject* obj = this->asJsonObject();

    QJsonDocument doc(*obj);
    QByteArray bytes = doc.toJson();
    delete obj;
    return QString(bytes);
}

QJsonObject*
SWGLimeSdrOutputReport::asJsonObject() {
    QJsonObject* obj = new QJsonObject();
    if(m_success_isSet){
        obj->insert("success", QJsonValue(success));
    }
    if(m_stream_active_isSet){
        obj->insert("streamActive", QJsonValue(stream_active));
    }
    if(m_fifo_size_isSet){
        obj->insert("fifoSize", QJsonValue(fifo_size));
    }
    if(m_fifo_fill_isSet){
        obj->insert("fifoFill", QJsonValue(fifo_fill));
    }
    if(m_underrun_count_isSet){
        obj->insert("underrunCount", QJsonValue(underrun_count));
    }
    if(m_overrun_count_isSet){
        obj->insert("overrunCount", QJsonValue(overrun_count));
    }
    if(m_dropped_packets_count_isSet){
        obj->insert("droppedPacketsCount", QJsonValue(dropped_packets_count));
    }
    if(m_link_rate_isSet){
        obj->insert("linkRate", QJsonValue(link_rate));
    }
    if(m_hw_timestamp_isSet){
        obj->insert("hwTimestamp", QJsonValue(hw_timestamp));
    }
    if(m_temperature_isSet){
        obj->insert("temperature", QJsonValue(temperature));
    }
    if(m_gpio_dir_isSet){
        obj->insert("gpioDir", QJsonValue(gpio_dir));
    }
    if(m_gpio_pins_isSet){
        obj->insert("gpioPins", QJsonValue(gpio_pins));
    }

    return obj;
}

qint32
SWGLimeSdrOutputReport::getSuccess() {
    return success;
}
void
SWGLimeSdrOutputReport::setSuccess(qint32 success) {
    this->success = success;
    this->m_success_isSet = true;
}

qint32
SWGLimeSdrOutputReport::getStreamActive() {
    return stream_active;
}
void
SWGLimeSdrOutputReport::setStreamActive(qint32 stream_active) {
    this->stream_active = stream_active;
    this->m_stream_active_isSet = true;
}

qint32
SWGLimeSdrOutputReport::getFifoSize() {
    return fifo_size;
}
void
SWGLimeSdrOutputReport::setFifoSize(qint32 fifo_size) {
    this->fifo_size = fifo_size;
    this->m_fifo_size_isSet = true;
}

qint32
SWGLimeSdrOutputReport::getFifoFill() {
    return fifo_fill;
}
void
SWGLimeSdrOutputReport::setFifoFill(qint32 fifo_fill) {
    this->fifo_fill = fifo_fill;
    this->m_fifo_fill_isSet = true;
}

qint32
SWGLimeSdrOutputReport::getUnderrunCount() {
    return underrun_count;
}
void
SWGLimeSdrOutputReport::setUnderrunCount(qint32 underrun_count) {
    this->underrun_count = underrun_count;
    this->m_underrun_count_isSet = true;
}

qint32
SWGLimeSdrOutputReport::getOverrunCount() {
    return overrun_count;
}
void
SWGLimeSdrOutputReport::setOverrunCount(qint32 overrun_count) {
    this->overrun_count = overrun_count;
    this->m_overrun_count_isSet = true;
}

qint32
SWGLimeSdrOutputReport::getDroppedPacketsCount() {
    return dropped_packets_count;
}
void
SWGLimeSdrOutputReport::setDroppedPacketsCount(qint32 dropped_packets_count) {
    this->dropped_packets_count = dropped_packets_count;
    this->m_dropped_packets_count_isSet = true;
}

float
SWGLimeSdrOutputReport::getLinkRate() {
    return link_rate;
}
void
SWGLimeSdrOutputReport::setLinkRate(float link_rate) {
    this->link_rate = link_rate;
    this->m_link_rate_isSet = true;
}

qint32
SWGLimeSdrOutputReport::getHwTimestamp() {
    return hw_timestamp;
}
void
SWGLimeSdrOutputReport::setHwTimestamp(qint32 hw_timestamp) {
    this->hw_timestamp = hw_timestamp;
    this->m_hw_timestamp_isSet = true;
}

float
SWGLimeSdrOutputReport::getTemperature() {
    return temperature;
}
void
SWGLimeSdrOutputReport::setTemperature(float temperature) {
    this->temperature = temperature;
    this->m_temperature_isSet = true;
}

qint32
SWGLimeSdrOutputReport::getGpioDir() {
    return gpio_dir;
}
void
SWGLimeSdrOutputReport::setGpioDir(qint32 gpio_dir) {
    this->gpio_dir = gpio_dir;
    this->m_gpio_dir_isSet = true;
}

qint32
SWGLimeSdrOutputReport::getGpioPins() {
    return gpio_pins;
}
void
SWGLimeSdrOutputReport::setGpioPins(qint32 gpio_pins) {
    this->gpio_pins = gpio_pins;
    this->m_gpio_pins_isSet = true;
}


bool
SWGLimeSdrOutputReport::isSet(){
    bool isObjectUpdated = false;
    do{
        if(m_success_isSet){ isObjectUpdated = true; break;}
        if(m_stream_active_isSet){ isObjectUpdated = true; break;}
        if(m_fifo_size_isSet){ isObjectUpdated = true; break;}
        if(m_fifo_fill_isSet){ isObjectUpdated = true; break;}
        if(m_underrun_count_isSet){ isObjectUpdated = true; break;}
        if(m_overrun_count_isSet){ isObjectUpdated = true; break;}
        if(m_dropped_packets_count_isSet){ isObjectUpdated = true; break;}
        if(m_link_rate_isSet){ isObjectUpdated = true; break;}
        if(m_hw_timestamp_isSet){ isObjectUpdated = true; break;}
        if(m_temperature_isSet){ isObjectUpdated = true; break;}
        if(m_gpio_dir_isSet){ isObjectUpdated = true; break;}
        if(m_gpio_pins_isSet){ isObjectUpdated = true; break;}
    }while(false);
    return isObjectUpdated;
}
}