serial::xml_serializer_utils Namespace Reference

Functions
void	addChildWithText (const XmlElement &parent, const std::string &name, const std::string &text)
	Adds a child element with the specified text content.
void	setAttributeFromBool (const XmlElement &element, const std::string &name, bool value)
	Sets a boolean attribute on an XML element.
void	serializeSchedule (const std::vector< radar::SchedulePeriod > &schedule, const XmlElement &parent)
	Serializes a schedule (active periods) into a parent XML element.
void	serializeParameters (const XmlElement &parent, const params::Parameters &p)
	Serializes a Parameters object into a parent XML element.
void	serializeWaveform (const fers_signal::RadarSignal &waveform, const XmlElement &parent)
	Serializes a waveform into a parent XML element.
void	serializeTiming (const timing::PrototypeTiming &timing, const XmlElement &parent)
	Serializes a timing object into a parent XML element.
void	serializeAntenna (const antenna::Antenna &antenna, const XmlElement &parent)
	Serializes an antenna into a parent XML element.
void	serializeMotionPath (const math::Path &path, const XmlElement &parent)
	Serializes a motion path into a parent XML element.
void	serializeRotation (const math::RotationPath &rotPath, const XmlElement &parent)
	Serializes a rotation path into a parent XML element.
void	serializeTransmitter (const radar::Transmitter &tx, const XmlElement &parent)
	Serializes a transmitter into a parent XML element.
void	serializeReceiver (const radar::Receiver &rx, const XmlElement &parent)
	Serializes a receiver into a parent XML element.
void	serializeMonostatic (const radar::Transmitter &tx, const radar::Receiver &rx, const XmlElement &parent)
	Serializes a monostatic radar setup containing both a transmitter and receiver.
void	serializeTarget (const radar::Target &target, const XmlElement &parent)
	Serializes a target into a parent XML element.
void	serializePlatform (const radar::Platform &platform, const core::World &world, const XmlElement &parent)
	Serializes a platform and its attached components into a parent XML element.
template<typename T >
void	addChildWithNumber (const XmlElement &parent, const std::string &name, T value)
	Adds a child element with the specified numeric content.

Function Documentation

addChildWithNumber()

template<typename T >

void serial::xml_serializer_utils::addChildWithNumber	(	const XmlElement &	parent,
		const std::string &	name,
		T	value
	)

Adds a child element with the specified numeric content.

Template Parameters

T	The numeric type (automatically deduced).

Parameters

parent	The parent XML element.
name	The name of the child element to create.
value	The numeric value to set for the child element.

Definition at line 79 of file xml_serializer_utils.h.

    {
        if constexpr (std::is_floating_point_v<T>)
        {
            std::array<char, 64> buffer{};
            if (auto [ptr, ec] = std::to_chars(buffer.data(), buffer.data() + buffer.size(), value); ec == std::errc())
            {
                const auto length = static_cast<std::string::size_type>(ptr - buffer.data());
                addChildWithText(parent, name, std::string(buffer.data(), length));
            }
            else
            {
                // This only executes if std::to_chars(...) returns ec != std::errc()
                // which will practically never happen unless the output buffer is too small
                // to hold the formatted value, or the standard library implementation fails
                // to support/format the given floating-point value.
                std::stringstream ss;
                ss << std::setprecision(std::numeric_limits<T>::max_digits10) << value;
                addChildWithText(parent, name, ss.str());
            }
        }
        else
        {
            addChildWithText(parent, name, std::to_string(value));
        }
    }

References addChildWithText().

Referenced by serializeAntenna(), serializeMonostatic(), serializeMotionPath(), serializeParameters(), serializeReceiver(), serializeRotation(), serializeTarget(), serializeTiming(), serializeTransmitter(), and serializeWaveform().

Here is the call graph for this function:

Here is the caller graph for this function:

addChildWithText()

void serial::xml_serializer_utils::addChildWithText	(	const XmlElement &	parent,
		const std::string &	name,
		const std::string &	text
	)

Adds a child element with the specified text content.

Parameters

parent	The parent XML element.
name	The name of the child element to create.
text	The text content to set for the child element.

Definition at line 27 of file xml_serializer_utils.cpp.

    {
        parent.addChild(name).setText(text);
    }

References XmlElement::addChild(), and XmlElement::setText().

Referenced by addChildWithNumber(), and serializeParameters().

Here is the call graph for this function:

Here is the caller graph for this function:

serializeAntenna()

void serial::xml_serializer_utils::serializeAntenna	(	const antenna::Antenna &	antenna,
		const XmlElement &	parent
	)

Serializes an antenna into a parent XML element.

Parameters

antenna	The antenna object to serialize.
parent	The parent XML element.

Definition at line 158 of file xml_serializer_utils.cpp.

    {
        parent.setAttribute("name", antenna.getName());
 
        if (const auto* sinc = dynamic_cast<const antenna::Sinc*>(&antenna))
        {
            parent.setAttribute("pattern", "sinc");
            addChildWithNumber(parent, "alpha", sinc->getAlpha());
            addChildWithNumber(parent, "beta", sinc->getBeta());
            addChildWithNumber(parent, "gamma", sinc->getGamma());
        }
        else if (const auto* gaussian = dynamic_cast<const antenna::Gaussian*>(&antenna))
        {
            parent.setAttribute("pattern", "gaussian");
            addChildWithNumber(parent, "azscale", gaussian->getAzimuthScale());
            addChildWithNumber(parent, "elscale", gaussian->getElevationScale());
        }
        else if (const auto* sh = dynamic_cast<const antenna::SquareHorn*>(&antenna))
        {
            parent.setAttribute("pattern", "squarehorn");
            addChildWithNumber(parent, "diameter", sh->getDimension());
        }
        else if (const auto* parabolic = dynamic_cast<const antenna::Parabolic*>(&antenna))
        {
            parent.setAttribute("pattern", "parabolic");
            addChildWithNumber(parent, "diameter", parabolic->getDiameter());
        }
        else if (const auto* xml_ant = dynamic_cast<const antenna::XmlAntenna*>(&antenna))
        {
            parent.setAttribute("pattern", "xml");
            parent.setAttribute("filename", xml_ant->getFilename());
        }
        else if (const auto* h5_ant = dynamic_cast<const antenna::H5Antenna*>(&antenna))
        {
            parent.setAttribute("pattern", "file");
            parent.setAttribute("filename", h5_ant->getFilename());
        }
        else
        {
            parent.setAttribute("pattern", "isotropic");
        }
 
        if (antenna.getEfficiencyFactor() != 1.0)
        {
            addChildWithNumber(parent, "efficiency", antenna.getEfficiencyFactor());
        }
    }

References addChildWithNumber(), and XmlElement::setAttribute().

Referenced by serial::world_to_xml_string().

Here is the call graph for this function:

Here is the caller graph for this function:

serializeMonostatic()

void serial::xml_serializer_utils::serializeMonostatic	(	const radar::Transmitter &	tx,
		const radar::Receiver &	rx,
		const XmlElement &	parent
	)

Serializes a monostatic radar setup containing both a transmitter and receiver.

Parameters

tx	The transmitter object.
rx	The receiver object.
parent	The parent XML element.

Definition at line 338 of file xml_serializer_utils.cpp.

    {
        const XmlElement mono_elem = parent.addChild("monostatic");
        mono_elem.setAttribute("name", tx.getName());
        mono_elem.setAttribute("antenna", (tx.getAntenna() != nullptr) ? tx.getAntenna()->getName() : "");
        mono_elem.setAttribute("waveform", (tx.getSignal() != nullptr) ? tx.getSignal()->getName() : "");
        mono_elem.setAttribute("timing", tx.getTiming() ? tx.getTiming()->getName() : "");
        setAttributeFromBool(mono_elem, "nodirect", rx.checkFlag(radar::Receiver::RecvFlag::FLAG_NODIRECT));
        setAttributeFromBool(mono_elem, "nopropagationloss", rx.checkFlag(radar::Receiver::RecvFlag::FLAG_NOPROPLOSS));
 
        if (tx.getMode() == radar::OperationMode::PULSED_MODE)
        {
            const XmlElement mode_elem = mono_elem.addChild("pulsed_mode");
            addChildWithNumber(mode_elem, "prf", tx.getPrf());
            addChildWithNumber(mode_elem, "window_skip", rx.getWindowSkip());
            addChildWithNumber(mode_elem, "window_length", rx.getWindowLength());
        }
        else
        {
            (void)mono_elem.addChild("cw_mode");
        }
 
        if (rx.getNoiseTemperature() > 0)
        {
            addChildWithNumber(mono_elem, "noise_temp", rx.getNoiseTemperature());
        }
 
        serializeSchedule(tx.getSchedule(), mono_elem);
    }

References XmlElement::addChild(), addChildWithNumber(), radar::Receiver::checkFlag(), radar::Receiver::FLAG_NODIRECT, radar::Receiver::FLAG_NOPROPLOSS, radar::Radar::getAntenna(), radar::Transmitter::getMode(), antenna::Antenna::getName(), radar::Object::getName(), fers_signal::RadarSignal::getName(), radar::Receiver::getNoiseTemperature(), radar::Transmitter::getPrf(), radar::Transmitter::getSchedule(), radar::Transmitter::getSignal(), radar::Radar::getTiming(), radar::Receiver::getWindowLength(), radar::Receiver::getWindowSkip(), radar::PULSED_MODE, serializeSchedule(), XmlElement::setAttribute(), and setAttributeFromBool().

Referenced by serializePlatform().

Here is the call graph for this function:

Here is the caller graph for this function:

serializeMotionPath()

void serial::xml_serializer_utils::serializeMotionPath	(	const math::Path &	path,
		const XmlElement &	parent
	)

Serializes a motion path into a parent XML element.

Parameters

path	The motion path object to serialize.
parent	The parent XML element.

Definition at line 206 of file xml_serializer_utils.cpp.

    {
        switch (path.getType())
        {
        case math::Path::InterpType::INTERP_STATIC:
            parent.setAttribute("interpolation", "static");
            break;
        case math::Path::InterpType::INTERP_LINEAR:
            parent.setAttribute("interpolation", "linear");
            break;
        case math::Path::InterpType::INTERP_CUBIC:
            parent.setAttribute("interpolation", "cubic");
            break;
        }
 
        for (const auto& [pos, t] : path.getCoords())
        {
            XmlElement wp_elem = parent.addChild("positionwaypoint");
            addChildWithNumber(wp_elem, "x", pos.x);
            addChildWithNumber(wp_elem, "y", pos.y);
            addChildWithNumber(wp_elem, "altitude", pos.z);
            addChildWithNumber(wp_elem, "time", t);
        }
    }

References XmlElement::addChild(), addChildWithNumber(), math::Path::getCoords(), math::Path::getType(), math::Path::INTERP_CUBIC, math::Path::INTERP_LINEAR, math::Path::INTERP_STATIC, and XmlElement::setAttribute().

Referenced by serializePlatform().

Here is the call graph for this function:

Here is the caller graph for this function:

serializeParameters()

void serial::xml_serializer_utils::serializeParameters	(	const XmlElement &	parent,
		const params::Parameters &	p
	)

Serializes a Parameters object into a parent XML element.

Parameters

parent	The parent XML element.
p	The parameter struct to serialize.

Definition at line 52 of file xml_serializer_utils.cpp.

    {
        addChildWithNumber(parent, "starttime", p.start);
        addChildWithNumber(parent, "endtime", p.end);
        addChildWithNumber(parent, "rate", p.rate);
 
        if (p.c != params::Parameters::DEFAULT_C)
        {
            addChildWithNumber(parent, "c", p.c);
        }
        if (p.sim_sampling_rate != 1000.0)
        {
            addChildWithNumber(parent, "simSamplingRate", p.sim_sampling_rate);
        }
        if (p.random_seed)
        {
            addChildWithNumber(parent, "randomseed", *p.random_seed);
        }
        if (p.adc_bits != 0)
        {
            addChildWithNumber(parent, "adc_bits", p.adc_bits);
        }
        if (p.oversample_ratio != 1)
        {
            addChildWithNumber(parent, "oversample", p.oversample_ratio);
        }
        if (p.rotation_angle_unit != params::RotationAngleUnit::Degrees)
        {
            addChildWithText(parent, "rotationangleunit",
                             std::string(params::rotationAngleUnitToken(p.rotation_angle_unit)));
        }
 
        const XmlElement origin = parent.addChild("origin");
        origin.setAttribute("latitude", std::to_string(p.origin_latitude));
        origin.setAttribute("longitude", std::to_string(p.origin_longitude));
        origin.setAttribute("altitude", std::to_string(p.origin_altitude));
 
        const XmlElement cs = parent.addChild("coordinatesystem");
        switch (p.coordinate_frame)
        {
        case params::CoordinateFrame::ENU:
            cs.setAttribute("frame", "ENU");
            break;
        case params::CoordinateFrame::UTM:
            cs.setAttribute("frame", "UTM");
            cs.setAttribute("zone", std::to_string(p.utm_zone));
            cs.setAttribute("hemisphere", p.utm_north_hemisphere ? "N" : "S");
            break;
        case params::CoordinateFrame::ECEF:
            cs.setAttribute("frame", "ECEF");
            break;
        }
    }

References params::Parameters::adc_bits, XmlElement::addChild(), addChildWithNumber(), addChildWithText(), params::Parameters::c, params::Parameters::coordinate_frame, params::Parameters::DEFAULT_C, params::Degrees, params::ECEF, params::Parameters::end, params::ENU, params::Parameters::origin_altitude, params::Parameters::origin_latitude, params::Parameters::origin_longitude, params::Parameters::oversample_ratio, params::Parameters::random_seed, params::Parameters::rate, params::Parameters::rotation_angle_unit, params::rotationAngleUnitToken(), XmlElement::setAttribute(), params::Parameters::sim_sampling_rate, params::Parameters::start, params::UTM, params::Parameters::utm_north_hemisphere, and params::Parameters::utm_zone.

Referenced by serial::world_to_xml_string().

Here is the call graph for this function:

Here is the caller graph for this function:

serializePlatform()

void serial::xml_serializer_utils::serializePlatform	(	const radar::Platform &	platform,
		const core::World &	world,
		const XmlElement &	parent
	)

Serializes a platform and its attached components into a parent XML element.

Parameters

platform	The platform object to serialize.
world	The simulation world containing global state.
parent	The parent XML element.

Definition at line 397 of file xml_serializer_utils.cpp.

    {
        parent.setAttribute("name", platform.getName());
 
        const XmlElement motion_elem = parent.addChild("motionpath");
        serializeMotionPath(*platform.getMotionPath(), motion_elem);
 
        serializeRotation(*platform.getRotationPath(), parent);
 
        for (const auto& tx : world.getTransmitters())
        {
            if (tx->getPlatform() == &platform)
            {
                if (tx->getAttached() != nullptr)
                {
                    serializeMonostatic(*tx, *dynamic_cast<const radar::Receiver*>(tx->getAttached()), parent);
                }
                else
                {
                    serializeTransmitter(*tx, parent);
                }
            }
        }
 
        for (const auto& rx : world.getReceivers())
        {
            if (rx->getPlatform() == &platform && (rx->getAttached() == nullptr))
            {
                serializeReceiver(*rx, parent);
            }
        }
 
        for (const auto& target : world.getTargets())
        {
            if (target->getPlatform() == &platform)
            {
                serializeTarget(*target, parent);
            }
        }
    }

References XmlElement::addChild(), radar::Platform::getMotionPath(), radar::Platform::getName(), core::World::getReceivers(), radar::Platform::getRotationPath(), core::World::getTargets(), core::World::getTransmitters(), serializeMonostatic(), serializeMotionPath(), serializeReceiver(), serializeRotation(), serializeTarget(), serializeTransmitter(), and XmlElement::setAttribute().

Referenced by serial::world_to_xml_string().

Here is the call graph for this function:

Here is the caller graph for this function:

serializeReceiver()

void serial::xml_serializer_utils::serializeReceiver	(	const radar::Receiver &	rx,
		const XmlElement &	parent
	)

Serializes a receiver into a parent XML element.

Parameters

rx	The receiver object to serialize.
parent	The parent XML element.

Definition at line 309 of file xml_serializer_utils.cpp.

    {
        const XmlElement rx_elem = parent.addChild("receiver");
        rx_elem.setAttribute("name", rx.getName());
        rx_elem.setAttribute("antenna", (rx.getAntenna() != nullptr) ? rx.getAntenna()->getName() : "");
        rx_elem.setAttribute("timing", rx.getTiming() ? rx.getTiming()->getName() : "");
        setAttributeFromBool(rx_elem, "nodirect", rx.checkFlag(radar::Receiver::RecvFlag::FLAG_NODIRECT));
        setAttributeFromBool(rx_elem, "nopropagationloss", rx.checkFlag(radar::Receiver::RecvFlag::FLAG_NOPROPLOSS));
 
        if (rx.getMode() == radar::OperationMode::PULSED_MODE)
        {
            const XmlElement mode_elem = rx_elem.addChild("pulsed_mode");
            addChildWithNumber(mode_elem, "prf", rx.getWindowPrf());
            addChildWithNumber(mode_elem, "window_skip", rx.getWindowSkip());
            addChildWithNumber(mode_elem, "window_length", rx.getWindowLength());
        }
        else
        {
            (void)rx_elem.addChild("cw_mode");
        }
 
        if (rx.getNoiseTemperature() > 0)
        {
            addChildWithNumber(rx_elem, "noise_temp", rx.getNoiseTemperature());
        }
 
        serializeSchedule(rx.getSchedule(), rx_elem);
    }

References XmlElement::addChild(), addChildWithNumber(), radar::Receiver::checkFlag(), radar::Receiver::FLAG_NODIRECT, radar::Receiver::FLAG_NOPROPLOSS, radar::Radar::getAntenna(), radar::Receiver::getMode(), antenna::Antenna::getName(), radar::Object::getName(), radar::Receiver::getNoiseTemperature(), radar::Receiver::getSchedule(), radar::Radar::getTiming(), radar::Receiver::getWindowLength(), radar::Receiver::getWindowPrf(), radar::Receiver::getWindowSkip(), radar::PULSED_MODE, serializeSchedule(), XmlElement::setAttribute(), and setAttributeFromBool().

Referenced by serializePlatform().

Here is the call graph for this function:

Here is the caller graph for this function:

serializeRotation()

void serial::xml_serializer_utils::serializeRotation	(	const math::RotationPath &	rotPath,
		const XmlElement &	parent
	)

Serializes a rotation path into a parent XML element.

Parameters

rotPath	The rotation path object to serialize.
parent	The parent XML element.

Definition at line 231 of file xml_serializer_utils.cpp.

    {
        if (rotPath.getType() == math::RotationPath::InterpType::INTERP_CONSTANT)
        {
            const XmlElement fixed_elem = parent.addChild("fixedrotation");
            const auto start = rotPath.getStart();
            const auto rate = rotPath.getRate();
            const auto unit = params::rotationAngleUnit();
 
            RealType start_az = rotation_angle_utils::internal_azimuth_to_external(start.azimuth, unit);
            if (unit == params::RotationAngleUnit::Degrees)
            {
                start_az = std::fmod(start_az + 360.0, 360.0);
            }
            const RealType start_el = rotation_angle_utils::internal_elevation_to_external(start.elevation, unit);
            const RealType rate_az = rotation_angle_utils::internal_azimuth_rate_to_external(rate.azimuth, unit);
            const RealType rate_el = rotation_angle_utils::internal_elevation_rate_to_external(rate.elevation, unit);
 
            addChildWithNumber(fixed_elem, "startazimuth", start_az);
            addChildWithNumber(fixed_elem, "startelevation", start_el);
            addChildWithNumber(fixed_elem, "azimuthrate", rate_az);
            addChildWithNumber(fixed_elem, "elevationrate", rate_el);
        }
        else
        {
            const XmlElement rot_elem = parent.addChild("rotationpath");
            switch (rotPath.getType())
            {
            case math::RotationPath::InterpType::INTERP_STATIC:
                rot_elem.setAttribute("interpolation", "static");
                break;
            case math::RotationPath::InterpType::INTERP_LINEAR:
                rot_elem.setAttribute("interpolation", "linear");
                break;
            case math::RotationPath::InterpType::INTERP_CUBIC:
                rot_elem.setAttribute("interpolation", "cubic");
                break;
            default:
                break;
            }
            const auto unit = params::rotationAngleUnit();
            for (const auto& wp : rotPath.getCoords())
            {
                XmlElement wp_elem = rot_elem.addChild("rotationwaypoint");
                RealType azimuth = rotation_angle_utils::internal_azimuth_to_external(wp.azimuth, unit);
                if (unit == params::RotationAngleUnit::Degrees)
                {
                    azimuth = std::fmod(azimuth + 360.0, 360.0);
                }
                const RealType elevation = rotation_angle_utils::internal_elevation_to_external(wp.elevation, unit);
                addChildWithNumber(wp_elem, "azimuth", azimuth);
                addChildWithNumber(wp_elem, "elevation", elevation);
                addChildWithNumber(wp_elem, "time", wp.t);
            }
        }
    }

References XmlElement::addChild(), addChildWithNumber(), params::Degrees, math::RotationPath::getCoords(), math::RotationPath::getRate(), math::RotationPath::getStart(), math::RotationPath::getType(), serial::rotation_angle_utils::internal_azimuth_rate_to_external(), serial::rotation_angle_utils::internal_azimuth_to_external(), serial::rotation_angle_utils::internal_elevation_rate_to_external(), serial::rotation_angle_utils::internal_elevation_to_external(), math::RotationPath::INTERP_CONSTANT, math::RotationPath::INTERP_CUBIC, math::RotationPath::INTERP_LINEAR, math::RotationPath::INTERP_STATIC, params::rotationAngleUnit(), and XmlElement::setAttribute().

Referenced by serializePlatform().

Here is the call graph for this function:

Here is the caller graph for this function:

serializeSchedule()

void serial::xml_serializer_utils::serializeSchedule	(	const std::vector< radar::SchedulePeriod > &	schedule,
		const XmlElement &	parent
	)

Serializes a schedule (active periods) into a parent XML element.

Parameters

schedule	The schedule periods to serialize.
parent	The parent XML element.

Definition at line 37 of file xml_serializer_utils.cpp.

    {
        if (schedule.empty())
        {
            return;
        }
        const XmlElement sched_elem = parent.addChild("schedule");
        for (const auto& period : schedule)
        {
            XmlElement p_elem = sched_elem.addChild("period");
            p_elem.setAttribute("start", std::to_string(period.start));
            p_elem.setAttribute("end", std::to_string(period.end));
        }
    }

References XmlElement::addChild(), and XmlElement::setAttribute().

Referenced by serializeMonostatic(), serializeReceiver(), and serializeTransmitter().

Here is the call graph for this function:

Here is the caller graph for this function:

serializeTarget()

void serial::xml_serializer_utils::serializeTarget	(	const radar::Target &	target,
		const XmlElement &	parent
	)

Serializes a target into a parent XML element.

Parameters

target	The target object to serialize.
parent	The parent XML element.

Definition at line 368 of file xml_serializer_utils.cpp.

    {
        const XmlElement target_elem = parent.addChild("target");
        target_elem.setAttribute("name", target.getName());
 
        const XmlElement rcs_elem = target_elem.addChild("rcs");
        if (const auto* iso = dynamic_cast<const radar::IsoTarget*>(&target))
        {
            rcs_elem.setAttribute("type", "isotropic");
            addChildWithNumber(rcs_elem, "value", iso->getConstRcs());
        }
        else if (const auto* file_target = dynamic_cast<const radar::FileTarget*>(&target))
        {
            rcs_elem.setAttribute("type", "file");
            rcs_elem.setAttribute("filename", file_target->getFilename());
        }
 
        // Serialize fluctuation model if present
        if (const auto* model = target.getFluctuationModel())
        {
            if (const auto* chi = dynamic_cast<const radar::RcsChiSquare*>(model))
            {
                XmlElement model_elem = target_elem.addChild("model");
                model_elem.setAttribute("type", "chisquare");
                addChildWithNumber(model_elem, "k", chi->getK());
            }
        }
    }

References XmlElement::addChild(), addChildWithNumber(), radar::Target::getFluctuationModel(), radar::Object::getName(), and XmlElement::setAttribute().

Referenced by serializePlatform().

Here is the call graph for this function:

Here is the caller graph for this function:

serializeTiming()

void serial::xml_serializer_utils::serializeTiming	(	const timing::PrototypeTiming &	timing,
		const XmlElement &	parent
	)

Serializes a timing object into a parent XML element.

Parameters

timing	The timing object to serialize.
parent	The parent XML element.

Definition at line 125 of file xml_serializer_utils.cpp.

    {
        parent.setAttribute("name", timing.getName());
        setAttributeFromBool(parent, "synconpulse", timing.getSyncOnPulse());
 
        addChildWithNumber(parent, "frequency", timing.getFrequency());
        if (const auto val = timing.getFreqOffset())
        {
            addChildWithNumber(parent, "freq_offset", *val);
        }
        if (const auto val = timing.getRandomFreqOffsetStdev())
        {
            addChildWithNumber(parent, "random_freq_offset_stdev", *val);
        }
        if (const auto val = timing.getPhaseOffset())
        {
            addChildWithNumber(parent, "phase_offset", *val);
        }
        if (const auto val = timing.getRandomPhaseOffsetStdev())
        {
            addChildWithNumber(parent, "random_phase_offset_stdev", *val);
        }
 
        std::vector<RealType> alphas, weights;
        timing.copyAlphas(alphas, weights);
        for (size_t i = 0; i < alphas.size(); ++i)
        {
            XmlElement entry = parent.addChild("noise_entry");
            addChildWithNumber(entry, "alpha", alphas[i]);
            addChildWithNumber(entry, "weight", weights[i]);
        }
    }

References XmlElement::addChild(), addChildWithNumber(), XmlElement::setAttribute(), and setAttributeFromBool().

Referenced by serial::world_to_xml_string().

Here is the call graph for this function:

Here is the caller graph for this function:

serializeTransmitter()

void serial::xml_serializer_utils::serializeTransmitter	(	const radar::Transmitter &	tx,
		const XmlElement &	parent
	)

Serializes a transmitter into a parent XML element.

Parameters

tx	The transmitter object to serialize.
parent	The parent XML element.

Definition at line 288 of file xml_serializer_utils.cpp.

    {
        const XmlElement tx_elem = parent.addChild("transmitter");
        tx_elem.setAttribute("name", tx.getName());
        tx_elem.setAttribute("waveform", (tx.getSignal() != nullptr) ? tx.getSignal()->getName() : "");
        tx_elem.setAttribute("antenna", (tx.getAntenna() != nullptr) ? tx.getAntenna()->getName() : "");
        tx_elem.setAttribute("timing", tx.getTiming() ? tx.getTiming()->getName() : "");
 
        if (tx.getMode() == radar::OperationMode::PULSED_MODE)
        {
            const XmlElement mode_elem = tx_elem.addChild("pulsed_mode");
            addChildWithNumber(mode_elem, "prf", tx.getPrf());
        }
        else
        {
            (void)tx_elem.addChild("cw_mode");
        }
 
        serializeSchedule(tx.getSchedule(), tx_elem);
    }

References XmlElement::addChild(), addChildWithNumber(), radar::Radar::getAntenna(), radar::Transmitter::getMode(), antenna::Antenna::getName(), radar::Object::getName(), fers_signal::RadarSignal::getName(), radar::Transmitter::getPrf(), radar::Transmitter::getSchedule(), radar::Transmitter::getSignal(), radar::Radar::getTiming(), radar::PULSED_MODE, serializeSchedule(), and XmlElement::setAttribute().

Referenced by serializePlatform().

Here is the call graph for this function:

Here is the caller graph for this function:

serializeWaveform()

void serial::xml_serializer_utils::serializeWaveform	(	const fers_signal::RadarSignal &	waveform,
		const XmlElement &	parent
	)

Serializes a waveform into a parent XML element.

Parameters

waveform	The waveform object to serialize.
parent	The parent XML element.

Definition at line 106 of file xml_serializer_utils.cpp.

    {
        parent.setAttribute("name", waveform.getName());
 
        addChildWithNumber(parent, "power", waveform.getPower());
        addChildWithNumber(parent, "carrier_frequency", waveform.getCarrier());
 
        if (dynamic_cast<const fers_signal::CwSignal*>(waveform.getSignal()) != nullptr)
        {
            (void)parent.addChild("cw"); // Empty element
        }
        else
        {
            const XmlElement pulsed_file = parent.addChild("pulsed_from_file");
            const auto& filename = waveform.getFilename();
            pulsed_file.setAttribute("filename", filename.value_or(""));
        }
    }

References XmlElement::addChild(), addChildWithNumber(), fers_signal::RadarSignal::getCarrier(), fers_signal::RadarSignal::getFilename(), fers_signal::RadarSignal::getName(), fers_signal::RadarSignal::getPower(), fers_signal::RadarSignal::getSignal(), and XmlElement::setAttribute().

Referenced by serial::world_to_xml_string().

Here is the call graph for this function:

Here is the caller graph for this function:

setAttributeFromBool()

void serial::xml_serializer_utils::setAttributeFromBool	(	const XmlElement &	element,
		const std::string &	name,
		bool	value
	)

Sets a boolean attribute on an XML element.

Parameters

element	The XML element to modify.
name	The name of the attribute to set.
value	The boolean value to set.

Definition at line 32 of file xml_serializer_utils.cpp.

    {
        element.setAttribute(name, value ? "true" : "false");
    }

References XmlElement::setAttribute().

Referenced by serializeMonostatic(), serializeReceiver(), and serializeTiming().

Here is the call graph for this function:

Here is the caller graph for this function: