signal_target_interface.h

Go to the documentation of this file.

/*********************************************************************
 *
 *  Software License Agreement
 *
 *  Copyright (c) 2020,
 *  TU Dortmund - Institute of Control Theory and Systems Engineering.
 *  All rights reserved.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 *  Authors: Christoph Rösmann
 *********************************************************************/

#ifndef SRC_CORE_INCLUDE_CORBO_CORE_SIGNAL_TARGET_INTERFACE_H_
#define SRC_CORE_INCLUDE_CORBO_CORE_SIGNAL_TARGET_INTERFACE_H_

#include <corbo-core/signals.h>

#include <memory>
#include <string>
#include <vector>

namespace corbo {

class SignalTargetInterface
{
 public:
    using Ptr = std::shared_ptr<SignalTargetInterface>;

    virtual ~SignalTargetInterface() {}

    virtual void registerMeasurement(const std::string& unique_name, int value_dimension, const std::vector<std::string>& value_labels = {},
                                     bool zero_order_hold = false) = 0;

    virtual void registerTimeSeries(const std::string& unique_name, int value_dimension, bool zero_order_hold = false) = 0;

    virtual void sendMeasurement(Measurement::ConstPtr measurement) = 0;

    virtual void sendMeasurement(const std::string& unique_name, double time, const std::vector<double>& values,
                                 const std::vector<std::string>& value_labels = {})
    {
        Measurement::Ptr measurement        = std::make_shared<Measurement>(time, values);
        measurement->header.time            = Time::now();
        measurement->header.name            = unique_name;
        measurement->header.value_dimension = values.size();
        measurement->getValueLabelsRef()    = value_labels;
        sendMeasurement(measurement);
    }

    virtual void sendMeasurement(const std::string& unique_name, double time, const Eigen::Ref<const Eigen::VectorXd>& values,
                                 const std::vector<std::string>& value_labels = {})
    {
        Measurement::Ptr measurement        = std::make_shared<Measurement>(time, values);
        measurement->header.time            = Time::now();
        measurement->header.name            = unique_name;
        measurement->header.value_dimension = values.rows();
        measurement->getValueLabelsRef()    = value_labels;
        sendMeasurement(measurement);
    }

    virtual void sendTimeSeries(TimeSeriesSignal::Ptr time_series) = 0;

    virtual void sendTimeSeries(const std::string& unique_name, TimeSeries::Ptr time_series)
    {
        TimeSeriesSignal::Ptr ts_signal   = std::make_shared<TimeSeriesSignal>();
        ts_signal->header.time            = Time::now();
        ts_signal->header.name            = unique_name;
        ts_signal->header.value_dimension = time_series->getValueDimension();
        ts_signal->set(time_series);
        sendTimeSeries(ts_signal);
    }

    virtual void sendIndexedValues(IndexedValuesSignal::Ptr indexed_values) = 0;

    virtual void sendIndexedValues(const std::string& unique_name, int index, const std::vector<double>& values)
    {
        IndexedValuesSignal::Ptr indexed_values = std::make_shared<IndexedValuesSignal>(index, values);
        indexed_values->header.time             = Time::now();
        indexed_values->header.name             = unique_name;
        indexed_values->header.value_dimension  = 1;  // for indexed values just one, since we won't have a fixed dimension, just statistical data
        sendIndexedValues(indexed_values);
    }

    virtual void sendIndexedValues(const std::string& unique_name, int index, const Eigen::Ref<const Eigen::VectorXd>& values)
    {
        IndexedValuesSignal::Ptr indexed_values = std::make_shared<IndexedValuesSignal>(index, values);
        indexed_values->header.time             = Time::now();
        indexed_values->header.name             = unique_name;
        indexed_values->header.value_dimension  = 1;  // for indexed values just one, since we won't have a fixed dimension, just statistical data
        sendIndexedValues(indexed_values);
    }

    virtual void sendIndexedValuesSet(IndexedValuesSetSignal::Ptr indexed_values_set) = 0;

    virtual void sendMatrix(MatrixSignal::Ptr matrix) = 0;

    virtual void sendMatrix(const std::string& unique_name, const Eigen::Ref<const Eigen::MatrixXd>& matrix, const std::string& label = "")
    {
        MatrixSignal::Ptr matrix_sig       = std::make_shared<MatrixSignal>(matrix, label);
        matrix_sig->header.time            = Time::now();
        matrix_sig->header.name            = unique_name;
        matrix_sig->header.value_dimension = 1;  // not relevant for this type yet (TODO(roesmann): unify)
        sendMatrix(matrix_sig);
    }
};

}  // namespace corbo

#endif  // SRC_CORE_INCLUDE_CORBO_CORE_SIGNAL_TARGET_INTERFACE_H_