lqnx_io.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2026, QORE Lab, Imperial College London
 * All rights reserved.
 */
#ifndef LINE_IO_LQNX_IO_H
#define LINE_IO_LQNX_IO_H
 
/**
 * @file
 * @ingroup line_io
 * The `.lqnx` (LQNS XML) interchange as a symmetric MODEL-LEVEL pair in `io::`.
 *
 * The implementations live in `lang/lqn/`: `lqn::read_lqnx_model` returns the
 * `LqnModel` a builder produces, `lqn::write_lqnx` takes one, and
 * `lqn::read_lqnx` returns the FINALIZED `LqnStruct` SolverLN consumes. The
 * struct reader is the odd one out of that trio: its output cannot be handed
 * back to the writer. So the io pair is `read_lqnx_model` / `write_lqnx`,
 * both on `LqnModel`, keeping the `lqn::` names verbatim so a caller moving
 * between the namespaces meets no second spelling. MATLAB spells the same pair
 * `LayeredNetwork.parseXML` / `writeXML`, which name methods of a class this
 * port does not have.
 *
 * The SRVN text grammar (`.in`) goes through this XML both ways: `read_srvn_model`
 * / `srvn2lqnx` read it, `write_srvn` / `lqnx2srvn` write it, keeping the `lqn::` names.
 */
 
#include <string>
 
#include "line/lang/lqn/lqn_reader.h"
#include "line/lang/lqn/lqn_writer.h"
#include "line/lang/lqn/srvn_reader.h"
#include "line/lang/lqn/srvn_writer.h"
 
namespace line {
namespace io {
 
/** Read a `.lqnx` file into the model-level `LqnModel`, which `write_lqnx` accepts back. */
template <class T>
lqn::LqnModel<T> read_lqnx_model(const std::string& path) {
    return lqn::read_lqnx_model<T>(path);
}
 
/**
 * Write an `LqnModel` as `.lqnx`; forwards to `lqn::write_lqnx`.
 *
 * @return what the schema could not carry (see `lqn::LqnWriteReport`)
 */
template <class T>
lqn::LqnWriteReport write_lqnx(const lqn::LqnModel<T>& m, const std::string& path,
                               const std::string& model_name = std::string("LQN"),
                               bool use_abstract_names = false, std::string* out_text = NULL) {
    return lqn::write_lqnx(m, path, model_name, use_abstract_names, out_text);
}
 
/**
 * Read an SRVN file (the LQNS `.in` text grammar, or a `.lqn` that is not XML) into the
 * model-level `LqnModel`; forwards to `lqn::read_srvn_model`.
 */
template <class T>
lqn::LqnModel<T> read_srvn_model(const std::string& path) {
    return lqn::read_srvn_model<T>(path);
}
 
/** Translate SRVN text into a `.lqnx` document; forwards to `lqn::srvn2lqnx`. */
inline std::string srvn2lqnx(const std::string& src, const std::string& name = std::string("model")) {
    return lqn::srvn2lqnx(src, name);
}
 
/** Translate a `.lqnx` document into SRVN text; forwards to `lqn::lqnx2srvn`. */
inline std::string lqnx2srvn(const std::string& xml_text, const std::string& name = std::string()) {
    return lqn::lqnx2srvn(xml_text, name);
}
 
/** Write an `LqnModel` as SRVN text (`write_lqnx`, then `lqnx2srvn`); forwards to `lqn::write_srvn`. */
template <class T>
void write_srvn(const lqn::LqnModel<T>& m, const std::string& path, bool use_abstract_names = false) {
    lqn::write_srvn(m, path, use_abstract_names);
}
 
}  // namespace io
}  // namespace line
 
#endif  // LINE_IO_LQNX_IO_H