signals.h
Go to the documentation of this file.
1 /*********************************************************************
2  *
3  * Software License Agreement
4  *
5  * Copyright (c) 2020,
6  * TU Dortmund - Institute of Control Theory and Systems Engineering.
7  * All rights reserved.
8  *
9  * This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program. If not, see <https://www.gnu.org/licenses/>.
21  *
22  * Authors: Christoph Rösmann
23  *********************************************************************/
24 
25 #ifndef SRC_CORE_INCLUDE_CORBO_CORE_SIGNALS_H_
26 #define SRC_CORE_INCLUDE_CORBO_CORE_SIGNALS_H_
27 
28 #include <corbo-core/console.h>
29 #include <corbo-core/time.h>
30 #include <corbo-core/time_series.h>
31 #include <corbo-core/types.h>
32 
33 #ifdef MESSAGE_SUPPORT
34 #include <corbo-communication/messages/core/signals.pb.h>
35 #endif
36 
37 #include <map>
38 #include <memory>
39 #include <string>
40 #include <type_traits>
41 #include <unordered_map>
42 #include <vector>
43 
44 namespace corbo {
45 
46 constexpr const char SIGNAL_NAMESPACE_DELIMITER = '/';
47 
49 enum class SignalType {
50  TimeSeries,
52  Values,
58  Matrix,
59  MatrixSet
60 };
61 
76 {
77  std::string name = "unknown";
79  int value_dimension = 0;
80  bool zero_order_hold = false;
81 
82  std::string getShortName() const
83  {
84  std::size_t found = name.find_last_of("/");
85  return name.substr(found + 1);
86  }
87 
88 #ifdef MESSAGE_SUPPORT
89  void toMessage(corbo::messages::SignalHeader& message) const
91  {
92  message.set_time(time.toSec());
93  message.set_name(name);
94  message.set_value_dimension(value_dimension);
95  message.set_zero_order_hold(zero_order_hold);
96  }
98  void fromMessage(const corbo::messages::SignalHeader& message, std::stringstream* issues = nullptr)
99  {
100  time.fromSec(message.time());
101  name = message.name();
102  value_dimension = message.value_dimension();
103  zero_order_hold = message.zero_order_hold();
104  }
105 #endif
106 };
107 
134 {
135  public:
136  using Ptr = std::shared_ptr<SignalInterface>;
137  using ConstPtr = std::shared_ptr<const SignalInterface>;
138 
140  virtual ~SignalInterface() {}
141 
143  virtual SignalType getType() const = 0;
144 
146  virtual void getValueLabels(std::vector<std::string>& sublabels) const {}
147 
150 
151 #ifdef MESSAGE_SUPPORT
152  virtual void toMessage(corbo::messages::Signal& message) const {}
155  virtual void fromMessage(const corbo::messages::Signal& message, std::stringstream* issues = nullptr) {}
156 #endif
157 };
158 
172 {
173  public:
174  using Ptr = std::shared_ptr<Measurement>;
175  using ConstPtr = std::shared_ptr<const Measurement>;
176 
180  Measurement(double time, const std::vector<double>& values) : _time(time), _values(values) {}
182  Measurement(double time, const Eigen::Ref<const Eigen::VectorXd>& values) { set(time, values); }
183 
184  // Implements interface method
185  SignalType getType() const override { return SignalType::Measurement; }
186 
188  void set(double time, const std::vector<double>& values)
189  {
190  _time = time;
191  _values = values;
192  }
193 
195  void set(double time, const Eigen::Ref<const Eigen::VectorXd>& values)
196  {
197  _time = time;
198  _values.assign(values.data(), values.data() + values.size());
199  }
200 
202  const std::vector<double>& getValues() const { return _values; }
204  std::vector<double>& getValuesRef() { return _values; }
205 
207  double getTime() const { return _time; }
208 
210  const std::vector<std::string>& getValueLabels() const { return _value_labels; }
212  std::vector<std::string>& getValueLabelsRef() { return _value_labels; }
213 
214  // Implements interface method
215  void getValueLabels(std::vector<std::string>& sublabels) const override { sublabels = _value_labels; }
216 
217 #ifdef MESSAGE_SUPPORT
218  // Implements interface method
219  void toMessage(corbo::messages::Signal& message) const override;
220  // Implements interface method
221  void fromMessage(const corbo::messages::Signal& message, std::stringstream* issues = nullptr) override;
222 #endif
223 
224  private:
225  double _time;
226  std::vector<double> _values;
227  std::vector<std::string> _value_labels;
228 };
229 
245 {
246  public:
247  using Ptr = std::shared_ptr<TimeSeriesSignal>;
248  using ConstPtr = std::shared_ptr<const TimeSeriesSignal>;
249 
251  TimeSeriesSignal() : _time_series(new TimeSeries) {}
253  explicit TimeSeriesSignal(int value_dim) : _time_series(new TimeSeries(value_dim)) {}
255  explicit TimeSeriesSignal(TimeSeries::Ptr time_series) : _time_series(time_series) {}
257  explicit TimeSeriesSignal(const Measurement& measurment) { add(measurment); }
258 
260  bool isEmpty() const { return _time_series ? _time_series->isEmpty() : true; }
261 
262  // Implements interface method
263  SignalType getType() const override { return SignalType::TimeSeries; }
264 
265  // Implements interface method
266  void getValueLabels(std::vector<std::string>& sublabels) const override
267  {
268  if (_time_series) sublabels = _time_series->getValueLabels();
269  }
270 
272  void add(const Measurement& measurement);
274  void add(double time, const Eigen::Ref<const Eigen::VectorXd>& values);
276  void add(double time, const std::vector<double>& values);
277 
279  void set(TimeSeries::Ptr time_series) { _time_series = time_series; }
280 
292  void set(const Eigen::Ref<const Eigen::VectorXd>& time, const Eigen::Ref<const Eigen::MatrixXd>& values_matrix, double time_from_start = 0.0);
293 
295  void setTimeFromStart(double time_from_start);
296 
298  const TimeSeries* getTimeSeries() const { return _time_series.get(); }
300  TimeSeries* getTimeSeriesRaw() { return _time_series.get(); }
301 
303  TimeSeries::Ptr getTimeSeriesPtr() const { return _time_series; }
304 
305 #ifdef MESSAGE_SUPPORT
306  // Implements interface method
307  void toMessage(corbo::messages::Signal& message) const override;
308  // Implements interface method
309  void fromMessage(const corbo::messages::Signal& message, std::stringstream* issues = nullptr) override;
310 #endif
311 
312  private:
314 };
315 
334 {
335  public:
336  using Ptr = std::shared_ptr<TimeSeriesSequenceSignal>;
337  using ConstPtr = std::shared_ptr<const TimeSeriesSequenceSignal>;
338 
342  explicit TimeSeriesSequenceSignal(int value_dim) : _ts_sequence(new TimeSeriesSequence(value_dim)) {}
343 
345  bool isEmpty() const { return _ts_sequence ? _ts_sequence->isEmpty() : true; }
346  // Implements interface method
347  SignalType getType() const override { return SignalType::TimeSeriesSequence; }
348  // Implements interface method
349  void getValueLabels(std::vector<std::string>& sublabels) const override
350  {
351  // copy values from very first object in the sequence
352  if (_ts_sequence && !_ts_sequence->isEmpty() && _ts_sequence->getSequence().front())
353  sublabels = _ts_sequence->getSequence().front()->getValueLabels();
354  }
355 
357  void add(TimeSeries::Ptr ts);
358 
360  void set(TimeSeriesSequence::Ptr ts_sequence) { _ts_sequence = ts_sequence; }
361 
363  const TimeSeriesSequence* getSequence() const { return _ts_sequence.get(); }
365  TimeSeriesSequence* getSequenceRaw() { return _ts_sequence.get(); }
366 
368  TimeSeriesSequence::Ptr getSequencePtr() const { return _ts_sequence; }
369 
370 #ifdef MESSAGE_SUPPORT
371  // Implements interface method
372  void toMessage(corbo::messages::Signal& message) const override;
373  // Implements interface method
374  void fromMessage(const corbo::messages::Signal& message, std::stringstream* issues = nullptr) override;
375 #endif
376 
377  private:
379 };
380 
391 {
392  public:
393  using Ptr = std::shared_ptr<IndexedValuesSignal>;
394  using ConstPtr = std::shared_ptr<const IndexedValuesSignal>;
395 
397  IndexedValuesSignal() = default;
399  explicit IndexedValuesSignal(int index) : _index(index) {}
401  IndexedValuesSignal(int index, double value) : _index(index) { add(value); }
403  IndexedValuesSignal(int index, const std::vector<double>& values) : _index(index), _values(values) {}
405  IndexedValuesSignal(int index, const Eigen::Ref<const Eigen::VectorXd>& values) : _index(index) { add(values); }
406 
408  bool isEmpty() const { return _values.empty(); }
409 
410  // Implements interface method
411  SignalType getType() const override { return SignalType::IndexedValues; }
412 
413  // Get internal value dimension
414  int getValueDimension() const { return _values.size(); }
415 
417  void setIndex(int index) { _index = index; }
418 
420  void add(double value) { _values.push_back(value); }
422  void add(const Eigen::Ref<const Eigen::VectorXd>& values);
424  void add(const std::vector<double>& values);
425 
427  void set(int index, double value);
429  void set(int index, const Eigen::Ref<const Eigen::VectorXd>& values);
431  void set(int index, const std::vector<double>& values);
432 
434  int getIndex() const { return _index; }
436  const std::vector<double>& getValues() const { return _values; }
438  std::vector<double>& getValuesRef() { return _values; }
439 
440  // Clear value vector
441  void clear() { _values.clear(); }
442 
443 #ifdef MESSAGE_SUPPORT
444  void toMessage(corbo::messages::IndexedValues& message) const;
445  void fromMessage(const corbo::messages::IndexedValues& message, std::stringstream* issues = nullptr);
446  // Implements interface method
447  void toMessage(corbo::messages::Signal& message) const override
448  {
449  header.toMessage(*message.mutable_header());
450  toMessage(*message.mutable_indexed_values());
451  }
452  // Implements interface method
453  void fromMessage(const corbo::messages::Signal& message, std::stringstream* issues = nullptr) override
454  {
455  header.fromMessage(message.header());
456  fromMessage(message.indexed_values(), issues);
457  }
458 #endif
459 
460  private:
461  int _index = 0;
462  std::vector<double> _values;
463 };
464 
475 {
476  public:
477  using Ptr = std::shared_ptr<IndexedValuesSetSignal>;
478  using ConstPtr = std::shared_ptr<const IndexedValuesSetSignal>;
479  using Map = std::map<int, std::vector<double>>;
480 
482  IndexedValuesSetSignal() = default;
483 
485  bool isEmpty() const { return _values_map.empty(); }
486 
487  // Implements interface method
488  SignalType getType() const override { return SignalType::IndexedValuesSet; }
489 
491  void add(int index, double value);
493  void add(const IndexedValuesSignal& indexed_values);
495  void add(int index, const Eigen::Ref<const Eigen::VectorXd>& values);
497  void add(int index, const std::vector<double>& values);
498 
500  const Map& getData() const { return _values_map; }
502  Map& getDataRef() { return _values_map; }
503 
505  int getMaxValueDimension() const;
506 
507  void clear() { _values_map.clear(); }
508 
509 #ifdef MESSAGE_SUPPORT
510  void toMessage(corbo::messages::IndexedValuesSet& message) const;
511  void fromMessage(const corbo::messages::IndexedValuesSet& message, std::stringstream* issues = nullptr);
512  // Implements interface method
513  void toMessage(corbo::messages::Signal& message) const override
514  {
515  header.toMessage(*message.mutable_header());
516  toMessage(*message.mutable_indexed_values_set());
517  }
518  // Implements interface method
519  void fromMessage(const corbo::messages::Signal& message, std::stringstream* issues = nullptr) override
520  {
521  header.fromMessage(message.header());
522  fromMessage(message.indexed_values_set(), issues);
523  }
524 #endif
525 
526  private:
528 };
529 
540 {
541  public:
542  using Ptr = std::shared_ptr<MatrixSignal>;
543  using ConstPtr = std::shared_ptr<const MatrixSignal>;
544 
546  MatrixSignal() = default;
548  explicit MatrixSignal(const Eigen::Ref<const Eigen::MatrixXd>& matrix, const std::string& label = "") : _matrix(matrix), _label(label) {}
549 
551  bool isEmpty() const { return _matrix.rows() == 0 && _matrix.cols() == 0; }
552 
553  // Implements interface method
554  SignalType getType() const override { return SignalType::Matrix; }
555 
556  int getRowDimension() const { return _matrix.rows(); }
557  int getColDimension() const { return _matrix.cols(); }
558 
560  void set(const Eigen::Ref<const Eigen::MatrixXd>& matrix, const std::string& label = "")
561  {
562  _matrix = matrix;
563  _label = label;
564  }
565 
567  const Eigen::MatrixXd& getMatrix() const { return _matrix; }
569  Eigen::MatrixXd& getMatrixRef() { return _matrix; }
570 
572  const std::string& getLabel() const { return _label; }
574  std::string& getLabelRef() { return _label; }
575 
576 #ifdef MESSAGE_SUPPORT
577  void toMessage(corbo::messages::Matrix& message) const;
578  void fromMessage(const corbo::messages::Matrix& message, std::stringstream* issues = nullptr);
579  // Implements interface method
580  void toMessage(corbo::messages::Signal& message) const override
581  {
582  header.toMessage(*message.mutable_header());
583  toMessage(*message.mutable_matrix());
584  }
585  // Implements interface method
586  void fromMessage(const corbo::messages::Signal& message, std::stringstream* issues = nullptr) override
587  {
588  header.fromMessage(message.header());
589  fromMessage(message.matrix(), issues);
590  }
591 #endif
592 
593  private:
594  Eigen::MatrixXd _matrix;
595  std::string _label;
596 };
597 
608 {
609  public:
610  using Ptr = std::shared_ptr<MatrixSetSignal>;
611  using ConstPtr = std::shared_ptr<const MatrixSetSignal>;
612  using Map = std::map<int, std::vector<double>>;
613 
615  MatrixSetSignal() = default;
616 
618  bool isEmpty() const { return _matrix_set.empty(); }
619 
620  // Implements interface method
621  SignalType getType() const override { return SignalType::MatrixSet; }
622 
624  void add(MatrixSignal::Ptr& matrix_signal);
626  void add(const Eigen::Ref<const Eigen::MatrixXd>& matrix, const std::string& label = "");
627 
629  const std::vector<MatrixSignal::Ptr>& getData() const { return _matrix_set; }
631  std::vector<MatrixSignal::Ptr>& getDataRef() { return _matrix_set; }
632 
633  void clear() { _matrix_set.clear(); }
634 
635 #ifdef MESSAGE_SUPPORT
636  void toMessage(corbo::messages::MatrixSet& message) const;
637  void fromMessage(const corbo::messages::MatrixSet& message, std::stringstream* issues = nullptr);
638  // Implements interface method
639  void toMessage(corbo::messages::Signal& message) const override
640  {
641  header.toMessage(*message.mutable_header());
642  toMessage(*message.mutable_matrix_set());
643  }
644  // Implements interface method
645  void fromMessage(const corbo::messages::Signal& message, std::stringstream* issues = nullptr) override
646  {
647  header.fromMessage(message.header());
648  fromMessage(message.matrix_set(), issues);
649  }
650 #endif
651 
652  private:
653  std::vector<MatrixSignal::Ptr> _matrix_set;
654 };
655 
656 } // namespace corbo
657 
658 #endif // SRC_CORE_INCLUDE_CORBO_CORE_SIGNALS_H_
std::vector< double > & getValuesRef()
Write access to the underlying values data (use with care)
Definition: signals.h:438
Map< Matrix< T, Dynamic, Dynamic, ColMajor >, 0, OuterStride<> > matrix(T *data, int rows, int cols, int stride)
Definition: common.h:102
Eigen::MatrixXd _matrix
Definition: signals.h:594
Signal for a sequence of time series objects.
Definition: signals.h:333
std::string getShortName() const
Definition: signals.h:82
TimeSeriesSequence::Ptr getSequencePtr() const
Return shared pointer of the underlying time series sequence (can be empty if not initialized) ...
Definition: signals.h:368
Time Series (trajectory resp. sequence of values w.r.t. time)
Definition: time_series.h:54
Measurement(double time, const Eigen::Ref< const Eigen::VectorXd > &values)
Construct measurement with a given time and value vector (Eigen version)
Definition: signals.h:182
const TimeSeriesSequence * getSequence() const
Read access to the underlying time series sequence (returns null if not initialized) ...
Definition: signals.h:363
TimeSeriesSignal(TimeSeries::Ptr time_series)
Construct time series signal from a time_series object (avoids copying)
Definition: signals.h:255
SignalType
Available signal types (must match messages::SignalType enumeration)
Definition: signals.h:49
IndexedValuesSignal(int index, const Eigen::Ref< const Eigen::VectorXd > &values)
Construct with desired index and value vector (STL version)
Definition: signals.h:405
void getValueLabels(std::vector< std::string > &sublabels) const override
Return labels for the underlying components of the signal (e.g. axes labels)
Definition: signals.h:349
std::vector< std::string > _value_labels
labels for value vector components (optional)
Definition: signals.h:227
int getIndex() const
Return current index.
Definition: signals.h:434
TimeSeriesSequence * getSequenceRaw()
Raw access to the underlying time series sequence (returns null if not initialized) ...
Definition: signals.h:365
virtual void getValueLabels(std::vector< std::string > &sublabels) const
Return labels for the underlying components of the signal (e.g. axes labels)
Definition: signals.h:146
IndexedValuesSignal(int index, const std::vector< double > &values)
Construct with desired index and value vector.
Definition: signals.h:403
Eigen::MatrixXd & getMatrixRef()
Write access to the underlying matrix (use with care)
Definition: signals.h:569
Interface class for signals.
Definition: signals.h:133
SignalType getType() const override
Get the signal type according to enumeration SignalType.
Definition: signals.h:347
std::vector< double > _values
Definition: signals.h:462
bool isEmpty() const
Check if the underlying map is empty.
Definition: signals.h:618
int getRowDimension() const
Definition: signals.h:556
Map & getDataRef()
Write access to the underlying map (use with care)
Definition: signals.h:502
const std::string & getLabel() const
Read access to the label.
Definition: signals.h:572
std::vector< MatrixSignal::Ptr > & getDataRef()
Write access to the underlying map (use with care)
Definition: signals.h:631
std::vector< double > _values
corresponding value vector
Definition: signals.h:226
const TimeSeries * getTimeSeries() const
Read access to the underlying time series object (returns null if not initialized) ...
Definition: signals.h:298
SignalType getType() const override
Get the signal type according to enumeration SignalType.
Definition: signals.h:488
Sequence of time series objects.
Definition: time_series.h:260
Representation of time stamps.
Definition: time.h:251
bool isEmpty() const
Determine if no time series is available.
Definition: signals.h:345
TimeSeriesSequenceSignal(int value_dim)
Construct empty signal with a desired value vector dimension.
Definition: signals.h:342
double getTime() const
Retrieve recorded time of the measurement.
Definition: signals.h:207
MatrixSignal(const Eigen::Ref< const Eigen::MatrixXd > &matrix, const std::string &label="")
Construct with matrix.
Definition: signals.h:548
Signal containing a set of matrices.
Definition: signals.h:607
SignalHeader header
The header of the signal.
Definition: signals.h:149
bool isEmpty() const
Check if the time series is empty.
Definition: signals.h:260
Signal containing values indexed by a single integer.
Definition: signals.h:390
std::shared_ptr< SignalInterface > Ptr
Definition: signals.h:136
TimeSeriesSignal(int value_dim)
Construct empty time series signal with a dresired value vector dimension.
Definition: signals.h:253
void getValueLabels(std::vector< std::string > &sublabels) const override
Return labels for the underlying components of the signal (e.g. axes labels)
Definition: signals.h:215
Measurement()
Default constructor.
Definition: signals.h:178
TimeSeriesSignal()
Default constructor.
Definition: signals.h:251
bool isEmpty() const
Check if the underlying map is empty.
Definition: signals.h:485
IndexedValuesSignal(int index)
Construct with desired index.
Definition: signals.h:399
virtual ~SignalInterface()
Virtual destructor.
Definition: signals.h:140
bool isEmpty() const
Check if the underlying map is empty.
Definition: signals.h:408
std::shared_ptr< const SignalInterface > ConstPtr
Definition: signals.h:137
SignalType getType() const override
Get the signal type according to enumeration SignalType.
Definition: signals.h:554
void add(double value)
Add value.
Definition: signals.h:420
int getValueDimension() const
Definition: signals.h:414
Measurement(double time, const std::vector< double > &values)
Construct measurement with a given time and value vector (Std version)
Definition: signals.h:180
Measurement signal (value vector recorded at a specific time)
Definition: signals.h:171
SignalType getType() const override
Get the signal type according to enumeration SignalType.
Definition: signals.h:621
TimeSeriesSignal(const Measurement &measurment)
Constructs and initializes time series signal and adds a single measurement.
Definition: signals.h:257
SignalType getType() const override
Get the signal type according to enumeration SignalType.
Definition: signals.h:263
TimeSeriesSequenceSignal()
Default constructor.
Definition: signals.h:340
std::shared_ptr< MatrixSignal > Ptr
Definition: signals.h:542
TimeSeriesSequence::Ptr _ts_sequence
Definition: signals.h:378
A matrix or vector expression mapping an existing expression.
Definition: Ref.h:192
void getValueLabels(std::vector< std::string > &sublabels) const override
Return labels for the underlying components of the signal (e.g. axes labels)
Definition: signals.h:266
const std::vector< std::string > & getValueLabels() const
Access labels of signal components (might be empty if not provided) [read-only].
Definition: signals.h:210
Time Series signal (trajectory resp. sequence of values w.r.t. time)
Definition: signals.h:244
const std::vector< double > & getValues() const
Read access to the underlying values object.
Definition: signals.h:436
double toSec() const
Cast time stamp to seconds.
Definition: time.h:281
std::string _label
Definition: signals.h:595
Signal containing a simple matrix.
Definition: signals.h:539
double _time
measurement time
Definition: signals.h:225
TimeSeries::Ptr getTimeSeriesPtr() const
Return shared pointer of the underlying time series (can be empty if not initialized) ...
Definition: signals.h:303
void setIndex(int index)
Set desired index.
Definition: signals.h:417
TimeSeries::Ptr _time_series
Definition: signals.h:313
SignalType getType() const override
Get the signal type according to enumeration SignalType.
Definition: signals.h:185
Time time
Time-stamp.
Definition: signals.h:78
constexpr const char SIGNAL_NAMESPACE_DELIMITER
Definition: signals.h:46
const std::vector< MatrixSignal::Ptr > & getData() const
Read access to the underlying map object.
Definition: signals.h:629
std::shared_ptr< TimeSeriesSequence > Ptr
Definition: time_series.h:263
void fromSec(double t)
Set time stamp from seconds.
Definition: time.h:283
IndexedValuesSignal(int index, double value)
Construct with desired index and single value.
Definition: signals.h:401
int getColDimension() const
Definition: signals.h:557
std::shared_ptr< TimeSeries > Ptr
Definition: time_series.h:64
const Map & getData() const
Read access to the underlying map object.
Definition: signals.h:500
Signal header.
Definition: signals.h:75
std::map< int, std::vector< double > > Map
Definition: signals.h:479
std::map< int, std::vector< double > > Map
Definition: signals.h:612
SignalType getType() const override
Get the signal type according to enumeration SignalType.
Definition: signals.h:411
std::vector< double > & getValuesRef()
Access value vector.
Definition: signals.h:204
std::vector< MatrixSignal::Ptr > _matrix_set
Definition: signals.h:653
TimeSeries * getTimeSeriesRaw()
Raw access to the underlying time series object (returns null if not initialized) ...
Definition: signals.h:300
const std::vector< double > & getValues() const
Access value vector (read-only)
Definition: signals.h:202
std::vector< std::string > & getValueLabelsRef()
Access labels of signal components (might be empty if not provided, allowed to modify directly) ...
Definition: signals.h:212
bool isEmpty() const
Check if the underlying map is empty.
Definition: signals.h:551
Signal containing values indexed by an integer (int to double[] map)
Definition: signals.h:474
const Eigen::MatrixXd & getMatrix() const
Read access to the underlying matrix object.
Definition: signals.h:567
std::string & getLabelRef()
Write access to the label.
Definition: signals.h:574


control_box_rst
Author(s): Christoph Rösmann
autogenerated on Mon Feb 28 2022 22:07:18