* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ *
+ * @brief A very efficient storage for bytes and C strings.
+ */
+/** @file rplcore/rplbytestorage.hpp
+ *
+ * @brief Definitions for a a very efficient storage for bytes and C strings.
+ */
#include "rplcore/rplcore.hpp"
}
/**
- * @brief Allocates a byte block.
+ * @brief Copy a byte block to a new allocated byte block.
*
- * @param size the size of the block to allocate
- *
- * @return a byte block (without a trailing '\0')
+ * @param source the source to copy
+ * @param size the size of the block to allocate
+ * @return a byte block (without a trailing '\0')
*/
uint8_t* RplByteStorage::allocateBytes(void* source, int size)
{
*/
#include "rplcore/rplcore.hpp"
+/** @file
+ * @brief Implements a portable data container.
+ */
+
/** @class RplContainer rplcontainer.hpp "rplcore/rplcontainer.hpp"
*
* @brief Implements a portable data container.
*/
/** @mainpage
*
- * The rplcore directory contains the basic classes of the rplqt source.
- *
- * If you want to use any of the rplqt sources these rplcore classes
- * are necessary to include.
+ * @note A real public library for QT.
+ *
+ * This library contains the module groups
+ * <ul>
+ * <li>rplcore: basic definitions, used in all other module groups</li>
+ * <li>rplmath: mathematic definitions and tools</li>
+ * <li>rplexpr: definition for parsing and interpretation of languages</li>
+ * <li>rplnet: definitions and tools for tcp/udp communication</li>
+ * </ul>
+ *
+ * Each module group has a central include file, which organizes the necessary
+ * include files. You had to include only the central include file.
+ *
+ * Example:
+ * <pre><code>
+ * #include "rplcore/rplcore.hpp"
+ * #include "rplexpr/rplexpr.hpp"
+ * </code></pre>
+ * In this case all definitions of rplcore and rplexpr are available.
+ */
+/** @file
+ * @brief Generally usable exceptions.
*/
-
#include "rplcore/rplcore.hpp"
/** @class RplException rplexception.hpp "rplcore/rplexception.hpp"
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+
+/** @file
+ * A configurable logger for different output media.
+ */
#include "rplcore/rplcore.hpp"
#include <QDir>
#include <iostream>
* @brief Builds the standard appender configured by a configuration file.
*
* @param config configuration file
+ * @param prefix the prefix of the key in the config file
+ * (in front of "name")
+ * @param defaultLogfilePrefix
+ * the prefix of the log file if no entry in the
+ * configuration file
*/
void RplLogger::buildStandardAppender(RplConfig* config,
const char* prefix,
* The original sources can be found on https://github.com/republib.
*/
-
+/** @file
+ * @brief Missed operation for <code>QString</code>s.
+ */
#include "rplcore/rplcore.hpp"
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief Missed operation for <code>QByteArray</code>s.
+ */
#include "rplcore.hpp"
/** @class RplString rplstring.hpp "rplcore/rplstring.hpp"
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief Implements a thread stopper.
+ */
#include "rplcore.hpp"
enum {
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief A testing tool like JUnit.
+ */
#include "rplcore/rplcore.hpp"
#include "rpltest.hpp"
*
* @param expected the file with the expected content
* @param current the file with the current content
+ * @param file the source file (point of the comparison)
+ * @param lineNo the source position (point of the comparison)
* @return true: the files are equal<br>
* false: otherwise
*/
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief A writer to an output media.
+ *
+ * Implementation of the abstract base class <code>RplWriter</code> and
+ * the concrete derivation <code>RplFileWriter</code>.
+ */
#include "rplcore/rplcore.hpp"
{
}
/**
- * @brief Puts a given count of '\t' to the output medium.
+ * @brief Puts a given count of "\t" to the output medium.
*
- * @param indent indention level, number of '\t'
+ * @param indent indention level, number of "\t"
*/
void RplWriter::indent(int indent)
{
* @brief Writes a line with indention to the output medium.
*
* @param indent indention level. Indention is limited to 20
- * @param format format string with placeholders like <code>sprintf()</code>
- * @param ... variable arguments, values for the placeholders
+ * @param line the line to write
*/
void RplWriter::writeIndented(int indent, const char* line)
{
* @brief Writes a line with indention to the output medium.
*
* @param indent indention level. Indention is limited to 20
- * @param line line to write (without '\n')
+ * @param format format string with placeholders like <code>sprintf</code>
+ * @param ... the values for the placeholders (variable arguments)
*/
void RplWriter::formatIndented(int indent, const char* format, ...)
{
*
* @param filename the file's name
* @param mode write mode, "w" for write or "a" for append
+ * @param eoln line end: "\n" or "\r\n"
*/
RplFileWriter::RplFileWriter(const char* filename, const char* mode,
const char* eoln) :
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief Predefined classes of the virtual machine, e.g RplASInteger.
+ */
#include "rplcore/rplcore.hpp"
#include "rplexpr/rplexpr.hpp"
* @brief Returns a string representation of an instance.
*
* @param object the object to convert
+ * @param maxLength not used
* @return a string describing the <code>object</code>
*/
QString RplASBoolean::toString(void* object, int) const
* @brief Returns a string representation of an instance.
*
* @param object the object to convert
+ * @param maxLength not used
* @return a string describing the <code>object</code>
*/
QString RplASFloat::toString(void* object, int) const
* @brief Returns a string representation of an instance.
*
* @param object the object to convert
+ * @param maxLength the maximum length of the result
* @return a string describing the <code>object</code>
*/
QString RplASInteger::toString(void* object, int maxLength) const
* @brief Returns a string representation of an instance.
*
* @param object the object to convert
+ * @param maxLength the maximum length of the result
* @return a string describing the <code>object</code>
*/
QString RplASString::toString(void* object, int maxLength) const
* @brief Returns a string representation of an instance.
*
* @param object the object to convert
+ * @param maxLength unused
* @return a string describing the <code>object</code>
*/
QString RplASList::toString(void* object, int maxLength) const
* @brief Returns a string representation of an instance.
*
* @param object the object to convert
+ * @param maxLength maximal length of the result
* @return a string describing the <code>object</code>
*/
QString RplASMap::toString(void* object, int maxLength) const
*
* @param writer writes to output
* @param indent nesting level: so many tabs will be used as prefix
- * @param header NULL or the headline
*/
void RplVariable::dump(RplWriter& writer, int indent)
{
* @brief Implements a data type representing a calculated value.
*/
+/**
+ * @brief Constructor.
+ *
+ * @param tree the abstract syntax tree
+ */
RplASFormula::RplASFormula(RplASTree& tree) :
RplASClass("Formula", tree)
{
*
* In this case we do nothing.
*
- * @param formula ignored
+ * @param expr the result
* @return
*/
void* RplASFormula::newValueInstance(void* expr) const
* @brief Constructor.
*
* @param name name of the user defined class
+ * @param position the position of the class definition
+ * @param tree the abstract syntax tree
*/
RplASUserClass::RplASUserClass(const QString& name,
const RplSourcePosition* position,
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ *
+ * @brief Implementation of an Abstract Syntax Tree.
+ *
+ */
#include "rplcore/rplcore.hpp"
#include "rplexpr/rplexpr.hpp"
* @brief Implements a specific exception for the Abstract Syntax Tree.
*/
-/**
- * @brief RplASException::RplASException
- * @param message
- */
-
-
/**
* @brief Builds the message.
*
}
/**
- * @brief Builds the message.
- *
- * @param position describes the position of the error/warning
- * @param format the reason of the exception
- * @param varList the values for the placeholders in the format.
+ * @brief Constructor.
*/
RplASException::RplASException() :
RplException("")
/**
* @brief Make the instance to a boolean value.
*
- * @param value the string value.
+ * @param string the string value.
*/
void RplASVariant::setString(const QString& string)
{
/**
* @brief Builds a string.
*
+ * @param maxLength the maximum length of the result
* @return the value as string
*/
QString RplASVariant::toString(int maxLength) const
* @brief Make the instance to an object.
*
* @param object the class specific value object.
+ * @param clazz the data type of the object
*/
void RplASVariant::setObject(void* object, const RplASClass* clazz)
{
* @brief Calculates the value.
*
* @param value In/OUT: the value of the instance
+ * @param frame not used
* @return NULL
*/
RplASNode1* RplASNamedValue::calc(RplASVariant& , RplStackFrame* )
*
* @brief Implements variable definition for the Abstract Syntax Tree.
*
- * <code>m_child</code>: next statement</br>
+ * <code>m_child</code>: next statement<br>
* <code>m_child2</code>: named value (name + default value expression)
* <code>m_child3</code>: initial value or NULL
*/
*
* @brief Implements an statement consisting of an expression.
*
- * <code>m_child</code>: next statement</br>
+ * <code>m_child</code>: next statement<br>
* <code>m_child2</code>: expression
*/
/**
* @brief Writes the internals of a statement list into a file.
*
- * @param writer writes to output media
- * @param indent the indent level of the statement list
- * @param chain the chain of statements to dump
+ * @param writer writes to output media
+ * @param indent the indent level of the statement list
+ * @param statements the chain of statements to dump
*/
void RplASNode1::dumpStatements(RplWriter& writer, int indent,
RplASItem* statements)
}
/**
- * @brief Sets the child5.
+ * @brief Sets the child6.
*
- * @param child5 the new child3
+ * @param child6 the new child6
*/
void RplASNode6::setChild6(RplASItem* child6)
{
/**
* @brief Constructor.
+ *
+ * @param op the operator id
+ * @param type the node type
*/
RplASUnaryOp::RplASUnaryOp(int op, RplASItemType type) :
RplASNode1(type),
*/
/**
- * @brief RplASStatement::RplASStatement
- * @param op
+ * @brief Constructor.
*/
RplASStatement::RplASStatement()
{
* If the condition is evaluated to true, the then-part will be executed.
* Otherwise the else-part if it exists.
*
- * <code>m_child</code>: next statement</br>
+ * <code>m_child</code>: next statement<br>
* <code>m_child2</code>: condition<br>
* <code>m_child3</code>: then part<br>
* <code>m_child4</code>: else part or NULL<br>
* Then the condition will be tested. If true the body will be executed
* and then the forwarding statement.
*
- * <code>m_child</code>: next statement</br>
+ * <code>m_child</code>: next statement<br>
* <code>m_child2</code>: body<br>
* <code>m_child3</code>: iterator variable<br>
* <code>m_child4</code>: container variable<br>
* The start and end value will be calculated.
* The body will be executed so many times given by the start and end value.
*
- * <code>m_child</code>: next statement</br>
+ * <code>m_child</code>: next statement<br>
* <code>m_child2</code>: body<br>
* <code>m_child3</code>: variable or NULL<br>
* <code>m_child4</code>: start value or NULL<br>
* <code>m_child5</code>: end value<br>
- * <code>m_child6</code>: step value or NULL<br>
+ * <code>m_child6</code>: step value or NULL
*
*/
* The while statement has an a condition and a body.
* The body will be executed while the condition returns true.
*
- * <code>m_child</code>: next statement</br>
+ * <code>m_child</code>: next statement<br>
* <code>m_child2</code>: condition<br>
* <code>m_child3</code>: body<br>
*/
* The while statement has an a condition and a body.
* The body will be executed while the condition returns true.
*
- * <code>m_child</code>: next statement</br>
+ * <code>m_child</code>: next statement<br>
* <code>m_child2</code>: condition<br>
* <code>m_child3</code>: body<br>
*/
/**
* @brief Handles the start of a new class definition.
* @param name name of the class/method
+ * @param type the symbol space type
* @return the new symbol space
*/
RplSymbolSpace* RplASTree::startClassOrMethod(const QString& name,
*
* @brief Implements a method or function call for the Abstract Syntax Tree.
*
- * <code>m_child</code>: next statement</br>
+ * <code>m_child</code>: next statement<br>
* <code>m_child2</code>: argument list<br>
* <code>m_child3</code>: parent (variable, field ...)
*/
*
* @brief Implements a call of a method or function.
*
- * <code>m_child</code>: ???</br>
+ * <code>m_child</code>: body
* <code>m_child2</code>: argument list (or NULL)
*/
*
* The special case "function" (a method without class) is included.
*
- * <code>m_child</code>: body</br>
+ * <code>m_child</code>: body<br>
* <code>m_child2</code>: parameter list (or NULL)
*/
/**
* @brief Constructor.
*
* @param name the method name
- * @param type the method result type
+ * @param tree the abstract syntax tree
*/
RplASMethod::RplASMethod(const QString& name, RplASTree& tree) :
RplASNode2(AST_METHOD),
class RplASException : public RplException {
public:
RplASException();
- RplASException(const RplSourcePosition* position, const char* message, ...);
+ RplASException(const RplSourcePosition* position, const char* format, ...);
protected:
void build(const RplSourcePosition* position, const char* format,
va_list varList);
*
* @param writer writes to output media
* @param indent nesting level: so many tabs will be used as prefix
- * @param header NULL or the headline
*/
virtual void dump(RplWriter& writer,int indent) = 0;
public:
* @brief Returns a string representation of an instance.
*
* @param object the object to convert
+ * @param maxLength the maximum length of the result (string)
* @return a string describing the <code>object</code>
*/
virtual QString toString(void *object, int maxLength = 80) const = 0;
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief Configurable scanner, wich separates syntactic symbols from an input media.
+ */
#include "rplcore/rplcore.hpp"
#include "rplexpr/rplexpr.hpp"
*
*/
-/**
- * @brief RplLexException::RplLexException
- * @param message
- */
/**
* @brief Constructor.
*
* @brief Constructor.
*
* @param source the input source handler
- * @param keywords a string with all keywords delimited by ' '.
+ * @param keywords a string with all keywords delimited by " ".
* Example: "if then else fi while do done"
- * @param operators a string with the operators separated by blank or '\n'.
- * '\n' separates the operators with the same priority.
+ * @param operators a string with the operators separated by blank or "\n".
+ * "\n" separates the operators with the same priority.
* Lower position means lower priority
+ * @param rightAssociatives
+ * the operators which are right associative
* @param comments a string with pairs of comment begin and end delimited
- * by ' '. The comment end can be '\n' for line end.
+ * by " ". The comment end can be "\n" for line end.
* Example: "/ * * / // \n" (ignore the blank in "* /")
* @param firstCharsId string with the characters which are allowed as first
* characters of an id
SF_TICK = 1 << 1,
/// " can be a string delimiter
SF_QUOTE = 1 << 2,
- /// character escaping like in C: \<char> is <char>
+ /// character escaping like in C: "\x" is "x"
SF_C_ESCAPING = 1 << 3,
- /// special characters like in C: \r \f \n \t \a
+ /// special characters like in C: "\r" "\f" "\n" "\t" "\a"
SF_C_SPECIAL = 1 << 4,
- /// characters can be written in hexadecimal notation: \x20 is ' '
+ /// characters can be written in hexadecimal notation: "\x20" is " "
SF_C_HEX_CHARS = 1 << 5,
/// A delimiter inside a string must be doubled (like in Pascal)
SF_DOUBLE_DELIM = 1 << 6,
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief A parser for the language <b>ML</b>.
+ */
#include "rplcore/rplcore.hpp"
#include "rplexpr/rplexpr.hpp"
* @brief Parses a for statement.
*
* Syntax:
- * for [ <var> ] [ from <start_expr> ] to <end_expr> [ step <step_expr> ] do
- * <body> od
+ * for [ VAR ] [ from START_EXPR ] to END_EXPR [ step STEP_EXPR ] do
+ * BODY od
*
- * for <var> in <iterable_expr> do <body> od
+ * for VAR in ITERABLE_EXPR do BODY od
*
* @post the token behind the do is read
* @return the abstract syntax tree of the for statement
* @brief Parses a variable definition.
*
* Syntax:
- * Variable: { "const" | "lazy" }* <type> id [ = <expr> ] [ ";" ]
- * Parameter: { "const" | "lazy" }* <type> id [ = <expr> ] { "," | ")" }
+ * Variable: { "const" | "lazy" }* TYPE id [ = EXPR ] [ ";" ]
+ * Parameter: { "const" | "lazy" }* TYPE id [ = EXPR ] { "," | ")" }
*
* @pre first token of the definition is read
* @post token behind the definition is read: ';', ',', ')'
* @brief Parses a list.
*
* Syntax:<br>
- * '[' [<expr_1> [ ',' <expr_2> ...]] ']'
+ * '[' [ EXPR_1 [ ',' EXPR_2 ...]] ']'
*
* @pre '[' is the current token
* @post the token behind the ']' is read
* @brief Parses a map.
*
* Syntax:<br>
- * '{' [ <string_expr1> ':' <expr_1> [ ',' <string_expr1> ': <expr_2> ...]] '}'
+ * '{' [ STRING_EXPR_1 ':' EXPR_1 [ ',' STRING_EXPR_2 ': EXPR_2 ...]] '}'
*
* @pre '{' is the current token
* @post the token behind the '}' is read
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief Generally usable parts of an parser, e.g. error handling.
+ */
+
#include "rplcore/rplcore.hpp"
#include "rplexpr/rplexpr.hpp"
* @param prefix first char in the message: 'E' (error) or 'W' (warning)
* @param location unique id of the error/warning message
* @param position position of the error/warning
- * @param format message with placeholdes like sprintf()
- * @param varList the variable argument list
+ * @param message message with placeholdes like sprintf()
*/
void RplParser::addSimpleMessage(LevelTag prefix, int location,
const RplSourcePosition* position,
* The exception will be catched at a position where error recovery can take place.
*
* @param location unique id of the error/warning message
- * @param format message with placeholdes like sprintf()
+ * @param message error message
*/
void RplParser::syntaxError(int location, const char* message)
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+
+/** @file
+ * @brief Reading from several input media.
+ *
+ * The abstract base class <code>RplReader</code> and its concrete derivations
+ * <code>RplStringReader</code>, <code>RplFileReader</code> are used to read
+ * from one medium.
+ * The <code>RplSource</code> combines several readers and build a uniquely
+ * usable input stream.
+ */
+
#include "rplcore/rplcore.hpp"
#include "rplexpr/rplexpr.hpp"
* @param unit name of the input source (normally a file)
* @param lineNo line number inside the input source
* @param colNo distance to the line start
- * @param source parent: the source
*/
RplSourcePosition::RplSourcePosition(RplSourceUnit* unit, int lineNo,
int colNo) :
/**
* @brief Constructor.
*
- * @param name name of the unit, the filename
+ * @param file name of the directory
* @param reader the parent
*/
-RplFileSourceUnit::RplFileSourceUnit(const QDir& dir,
+RplFileSourceUnit::RplFileSourceUnit(const QDir& file,
RplFileReader* reader) :
- RplSourceUnit(dir.absolutePath(), reader),
+ RplSourceUnit(file.absolutePath(), reader),
m_currentPosition(0),
- m_file(dir.absolutePath()),
+ m_file(file.absolutePath()),
m_textStream(&m_file),
- m_line() {
+ m_line()
+{
}
/**
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ *
+ * @brief Implements an interpreter of an abstract syntax tree.
+ */
#include "rplcore/rplcore.hpp"
#include "rplexpr/rplexpr.hpp"
/*
+ *
* Licence:
* You can use and modify this file without any restriction.
* There is no warranty.
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief Implements encryption and decryption engines.
+ */
+
#include "rplmath.hpp"
/** @class RplEnigma::secret_t rplenigma.hpp "rplmath/rplenigma.hpp"
* Author: hm
*/
+/** @file
+ * @brief Implements 2 dimensional matrices.
+ */
+
#include "rplmath/rplmath.hpp"
RplMatrixException::RplMatrixException(const RplMatrix& RplMatrix,
*
* @param rows number of rows
* @param cols number of columns
+ * @param name the name of the matrix
*/
RplMatrix::RplMatrix(int rows, int cols, const char* name):
m_rows(rows),
*
* @param rows the row number
* @param cols the column number
- * @trows RplMatrixException
+ * @throws RplMatrixException
*/
void RplMatrix::checkDefinition(int rows, int cols) const
{
/**
* Compares the instance with a given scalar.
*
- * @param operand the scalar to compare
+ * @param scalar the scalar to compare
* @return true: all elements are equal to the scalar<br>
* false: otherwise
*/
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+
+/** @file
+ * @brief Implements pseudo random generators.
+ */
#include "rplmath.hpp"
/** @class RplRandom rplrandom.hpp "rplmath/rplrandom.hpp"
* @brief Constructor.
*
* @param configurator delivers some connection parameters
- * @param port 0 or the port of the server
- * @param sleepMilliSec duration of a busy wait
* @param logger the logger. If NULL a default logger will be used
*/
RplClientThread::RplClientThread(RplConfigurator& configurator,
*
* @param configurator some parameters will be get from this configurator
* @param taskHandler this handler reads from the tcp and interprets the content
- * @param threadFacctory creates a thread for a new connection
+ * @param threadFactory creates a thread for a new connection
* @param logger NULL or logger
* @param parent NULL or the parent which deletes the childen
*/
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+
+/** @file
+ * @brief Unit test of the abstract syntax tree.
+ */
+
+
#include "rplcore/rplcore.hpp"
#include "rplexpr/rplexpr.hpp"
#include "rplcore/rpltest.hpp"
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief Unit test of the byte and C string storage.
+ */
+
#include "rplcore/rplcore.hpp"
#include "rplcore/rpltest.hpp"
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief Unit test of the syntax symbol extractor.
+ */
+
#include "rplcore/rplcore.hpp"
#include "rplexpr/rplexpr.hpp"
#include "rplcore/rpltest.hpp"
* Created on: 29.05.2014
* Author: hm
*/
+
+/** @file
+ * @brief Unit test of the matrices.
+ */
+
#include "rplcore/rplcore.hpp"
#include "rplmath/rplmath.hpp"
#include "rplcore/rpltest.hpp"
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief Unit test of the parser for the language "MF".
+ */
#include "rplcore/rplcore.hpp"
#include "rplexpr/rplexpr.hpp"
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief Unit test of the QString tools.
+ */
+
#include "rplcore/rplcore.hpp"
#include "rplcore/rpltest.hpp"
* The original sources can be found on https://github.com/republib.
*/
+/** @file
+ * @brief Unit test of the input media reader.
+ */
+
#include "rplcore/rplcore.hpp"
#include "rplexpr/rplexpr.hpp"
#include "rplcore/rpltest.hpp"
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
-// ------------------
+
+/** @file
+ * @brief Unit test of the QByteArray tools.
+ */
#include "rplcore/rplcore.hpp"
#include "rplcore/rpltest.hpp"
/**
/*
+ *
* Licence:
* You can use and modify this file without any restriction.
* There is no warranty.
* You also can use the licence from http://www.wtfpl.net/.
* The original sources can be found on https://github.com/republib.
*/
+
+/** @file
+ * @brief Unit test of the output media writers.
+ */
+
#include "rplcore/rplcore.hpp"
#include "rplcore/rpltest.hpp"
/**
projects / reqt / commitdiff