common_signal_target.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_COMMON_SIGNAL_TARGET_H_
#define SRC_CORE_INCLUDE_CORBO_CORE_COMMON_SIGNAL_TARGET_H_
 
#include <corbo-core/signal_target_interface.h>
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace corbo {
 
class CommonSignalTarget : public SignalTargetInterface
{
 public:
    struct SignalGroup
    {
        std::string group_name;                           
        std::vector<SignalInterface::Ptr> group_signals;  
        std::vector<SignalGroup> children;                
        SignalGroup* parent = nullptr;
    };
 
    using Ptr = std::shared_ptr<CommonSignalTarget>;
 
    virtual ~CommonSignalTarget() {}
 
    // implements interface method
    void registerMeasurement(const std::string& /*unique_name*/, int /*value_dimension*/, const std::vector<std::string>& /*value_labels*/ = {},
                             bool zero_order_hold = false) override
    {
    }
 
    // implements interface method
    void registerTimeSeries(const std::string& /*unique_name*/, int /*value_dimension*/, bool zero_order_hold = false) override {}
 
    // implements interface method
    void sendMeasurement(Measurement::ConstPtr measurement) override;
 
    // implements interface method
    void sendTimeSeries(TimeSeriesSignal::Ptr time_series) override;
 
    // implements interface method
    void sendIndexedValues(IndexedValuesSignal::Ptr indexed_values) override;
 
    // implements interface method
    void sendIndexedValuesSet(IndexedValuesSetSignal::Ptr indexed_values_set) override;
 
    // implements interface method
    void sendMatrix(MatrixSignal::Ptr matrix) override;
 
    void setTopLevelGroupName(const std::string& name) { _signals.group_name = name; }
 
    // const SignalGroup* getSignalGroup(const std::string full_signal_name) const { return resolveGroupLevel(full_signal_name); }
 
    void removeSignal(const std::string& name);
 
    SignalGroup* getGroup(const std::string& full_group_name);
    SignalInterface::Ptr getSignal(const std::string& full_signal_name);
 
    bool isEmpty() { return _signals.children.empty(); }
 
    const SignalGroup& getSignals() const { return _signals; }
 
    SignalGroup& getSignalsRef() { return _signals; }
 
    void clear();
 
 protected:
    SignalGroup* expandGroups(const std::string full_signal_name, std::string* signal_name_out = nullptr, SignalInterface::Ptr* signal = nullptr);
 
 private:
    SignalGroup _signals;  
};
 
}  // namespace corbo
 
#endif  // SRC_CORE_INCLUDE_CORBO_CORE_COMMON_SIGNAL_TARGET_H_