mirror of
https://git.rwth-aachen.de/acs/public/villas/node/
synced 2025-03-09 00:00:00 +01:00
151 lines
4.1 KiB
C++
151 lines
4.1 KiB
C++
/* Read / write sample data in different formats.
|
|
*
|
|
* Author: Steffen Vogel <post@steffenvogel.de>
|
|
* SPDX-FileCopyrightText: 2014-2023 Institute for Automation of Complex Power Systems, RWTH Aachen University
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <memory>
|
|
|
|
#include <villas/list.hpp>
|
|
#include <villas/plugin.hpp>
|
|
#include <villas/sample.hpp>
|
|
#include <villas/signal_list.hpp>
|
|
|
|
namespace villas {
|
|
namespace node {
|
|
|
|
// Forward declarations
|
|
class FormatFactory;
|
|
|
|
class Format {
|
|
|
|
friend FormatFactory;
|
|
|
|
public:
|
|
using Ptr = std::unique_ptr<Format>;
|
|
|
|
protected:
|
|
int flags; // A set of flags which is automatically used.
|
|
int real_precision; // Number of digits used for floatint point numbers
|
|
|
|
Logger logger;
|
|
|
|
struct {
|
|
char *buffer;
|
|
size_t buflen;
|
|
} in, out;
|
|
|
|
SignalList::Ptr
|
|
signals; // Signal meta data for parsed samples by Format::scan()
|
|
|
|
public:
|
|
Format(int fl);
|
|
|
|
virtual ~Format();
|
|
|
|
const SignalList::Ptr getSignals() const { return signals; }
|
|
|
|
int getFlags() const { return flags; }
|
|
|
|
void start(const SignalList::Ptr sigs, int fl = (int)SampleFlags::ALL);
|
|
void start(const std::string &dtypes, int fl = (int)SampleFlags::ALL);
|
|
|
|
virtual void start() {}
|
|
|
|
virtual void parse(json_t *json);
|
|
|
|
virtual int print(FILE *f, const struct Sample *const smps[], unsigned cnt);
|
|
|
|
virtual int scan(FILE *f, struct Sample *const smps[], unsigned cnt);
|
|
|
|
/* Print \p cnt samples from \p smps into buffer \p buf of length \p len.
|
|
*
|
|
* @param buf[out] The buffer which should be filled with serialized data.
|
|
* @param len[in] The length of the buffer \p buf.
|
|
* @param rbytes[out] The number of bytes which have been written to \p buf. Ignored if nullptr.
|
|
* @param smps[in] The array of pointers to samples.
|
|
* @param cnt[in] The number of pointers in the array \p smps.
|
|
*
|
|
* @retval >=0 The number of samples from \p smps which have been written into \p buf.
|
|
* @retval <0 Something went wrong.
|
|
*/
|
|
virtual int sprint(char *buf, size_t len, size_t *wbytes,
|
|
const struct Sample *const smps[], unsigned cnt) = 0;
|
|
|
|
/* Parse samples from the buffer \p buf with a length of \p len bytes.
|
|
*
|
|
* @param buf[in] The buffer of data which should be parsed / de-serialized.
|
|
* @param len[in] The length of the buffer \p buf.
|
|
* @param rbytes[out] The number of bytes which have been read from \p buf.
|
|
* @param smps[out] The array of pointers to samples.
|
|
* @param cnt[in] The number of pointers in the array \p smps.
|
|
*
|
|
* @retval >=0 The number of samples which have been parsed from \p buf and written into \p smps.
|
|
* @retval <0 Something went wrong.
|
|
*/
|
|
virtual int sscan(const char *buf, size_t len, size_t *rbytes,
|
|
struct Sample *const smps[], unsigned cnt) = 0;
|
|
|
|
// Wrappers for sending a (un)parsing single samples
|
|
|
|
int print(FILE *f, const struct Sample *smp) { return print(f, &smp, 1); }
|
|
|
|
int scan(FILE *f, struct Sample *smp) { return scan(f, &smp, 1); }
|
|
|
|
int sprint(char *buf, size_t len, size_t *wbytes, const struct Sample *smp) {
|
|
return sprint(buf, len, wbytes, &smp, 1);
|
|
}
|
|
|
|
int sscan(const char *buf, size_t len, size_t *rbytes, struct Sample *smp) {
|
|
return sscan(buf, len, rbytes, &smp, 1);
|
|
}
|
|
};
|
|
|
|
class BinaryFormat : public Format {
|
|
|
|
public:
|
|
using Format::Format;
|
|
};
|
|
|
|
class FormatFactory : public plugin::Plugin {
|
|
|
|
public:
|
|
using plugin::Plugin::Plugin;
|
|
|
|
virtual Format *make() = 0;
|
|
|
|
static Format *make(json_t *json);
|
|
|
|
static Format *make(const std::string &format);
|
|
|
|
virtual void init(Format *f) { f->logger = getLogger(); }
|
|
|
|
virtual std::string getType() const { return "format"; }
|
|
|
|
virtual bool isHidden() const { return false; }
|
|
};
|
|
|
|
template <typename T, const char *name, const char *desc, int flags = 0>
|
|
class FormatPlugin : public FormatFactory {
|
|
|
|
public:
|
|
using FormatFactory::FormatFactory;
|
|
|
|
virtual Format *make() {
|
|
auto *f = new T(flags);
|
|
|
|
init(f);
|
|
|
|
return f;
|
|
}
|
|
|
|
virtual std::string getName() const { return name; }
|
|
|
|
virtual std::string getDescription() const { return desc; }
|
|
};
|
|
|
|
} // namespace node
|
|
} // namespace villas
|