message_parser.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_COMMUNICATION_INCLUDE_CORBO_COMMUNICATION_MESSAGE_PARSER_H_
#define SRC_COMMUNICATION_INCLUDE_CORBO_COMMUNICATION_MESSAGE_PARSER_H_

#ifdef MESSAGE_SUPPORT

#include <corbo-communication/messages/descriptor_extensions.pb.h>
#include <google/protobuf/message.h>
#include <functional>
#include <list>
#include <string>
#include <utility>
#include <vector>

namespace corbo {

class MessageParser
{
 public:
    struct FieldInformation
    {
        std::string msg_type;                 
        std::string field_name;               
        std::vector<std::string> enum_list;   
        std::list<std::string> nested_names;  

        // support manipulation of the field from outside
        // (using reflection interface):
        const google::protobuf::FieldDescriptor* field_raw            = nullptr;  
        google::protobuf::Message* message_raw                        = nullptr;  
        const google::protobuf::OneofDescriptor* oneof_descriptor     = nullptr;  
        const google::protobuf::FieldDescriptor* oneof_selected_field = nullptr;  

        bool new_message = true;  

        // The following list contains extra options that are defined in 'messages/descriptor_extensions.proto'
        // better would be std::optional (C++17)
        std::pair<bool, std::string> label;            
        std::pair<bool, std::string> description;      
        std::pair<bool, std::string> msg_description;  
        std::pair<bool, std::string> default_value;    
        std::pair<bool, double> min_value;             
        std::pair<bool, double> max_value;             
        bool dynamic_size = false;        
        std::pair<bool, int> min_size;    
        std::pair<bool, int> max_size;    
        std::pair<bool, bool> info_text;  

        std::pair<bool, messages::GuiType> gui_type;  
        bool collapsed         = false;               
        bool update_signals    = false;               
        bool print_description = false;               
    };

    enum class MessageEvent { MessageStart, MessageEnd, OneOf };

    template <typename T>
    using CbValue = std::function<void(const T&, const FieldInformation&)>;

    using CbMessageEvent = std::function<void(const MessageEvent&, const FieldInformation&)>;

    void setCallbackValueInt32(CbValue<std::int32_t> fun_value_int32) { _fun_value_int32 = fun_value_int32; }
    void setCallbackValueInt32Array(CbValue<std::vector<std::int32_t>> fun_value_int32_array) { _fun_value_int32_array = fun_value_int32_array; }

    void setCallbackValueUInt32(CbValue<std::uint32_t> fun_value_uint32) { _fun_value_uint32 = fun_value_uint32; }
    void setCallbackValueUInt32Array(CbValue<std::vector<std::uint32_t>> fun_value_uint32_array) { _fun_value_uint32_array = fun_value_uint32_array; }

    void setCallbackValueInt64(CbValue<std::int64_t> fun_value_int64) { _fun_value_int64 = fun_value_int64; }
    void setCallbackValueInt64Array(CbValue<std::vector<std::int64_t>> fun_value_int64_array) { _fun_value_int64_array = fun_value_int64_array; }

    void setCallbackValueUInt64(CbValue<std::uint64_t> fun_value_uint64) { _fun_value_uint64 = fun_value_uint64; }
    void setCallbackValueUInt64Array(CbValue<std::vector<std::uint64_t>> fun_value_uint64_array) { _fun_value_uint64_array = fun_value_uint64_array; }

    void setCallbackValueFloat(CbValue<float> fun_value_float) { _fun_value_float = fun_value_float; }
    void setCallbackValueFloatArray(CbValue<std::vector<float>> fun_value_float_array) { _fun_value_float_array = fun_value_float_array; }

    void setCallbackValueDouble(CbValue<double> fun_value_double) { _fun_value_double = fun_value_double; }
    void setCallbackValueDoubleArray(CbValue<std::vector<double>> fun_value_double_array) { _fun_value_double_array = fun_value_double_array; }

    void setCallbackValueString(CbValue<std::string> fun_value_string) { _fun_value_string = fun_value_string; }
    void setCallbackValueStringArray(CbValue<std::vector<std::string>> fun_value_string_array) { _fun_value_string_array = fun_value_string_array; }

    void setCallbackValueStringInfo(CbValue<std::string> fun_value_string_info) { _fun_value_string_info = fun_value_string_info; }

    void setCallbackValueBool(CbValue<bool> fun_value_bool) { _fun_value_bool = fun_value_bool; }
    void setCallbackValueBoolArray(CbValue<std::vector<bool>> fun_value_bool_array) { _fun_value_bool_array = fun_value_bool_array; }

    void setCallbackValueEnum(CbValue<std::string> fun_value_enum) { _fun_value_enum = fun_value_enum; }
    void setCallbackValueEnumArray(CbValue<std::vector<std::string>> fun_value_enum_array) { _fun_value_enum_array = fun_value_enum_array; }

    void setCallbackMessageEvent(CbMessageEvent fun_msg_event) { _fun_msg_event = fun_msg_event; }

    void parse(google::protobuf::Message* message, bool expand_oneof = true, bool skip_inactive_oneof = true,
               std::list<std::string>* nested_names = nullptr);

    void parseField(google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field, bool expand_oneof = true,
                    bool expand_first_oneof = true, bool skip_inactive_oneof = true, std::list<std::string>* nested_names = nullptr);

    void setVerbose(bool active) { _verbose = active; }

    static std::string nestedNamesToString(const std::list<std::string>& namespaces);

 protected:
    void consumeFieldMessage(google::protobuf::Message* message, const google::protobuf::Reflection* reflection,
                             const google::protobuf::FieldDescriptor* field, bool expand_oneof = true, bool skip_inactive_oneof = true,
                             std::list<std::string>* nested_names = nullptr);
    void consumeFieldValue(google::protobuf::Message* message, const google::protobuf::Reflection* reflection,
                           const google::protobuf::FieldDescriptor* field, std::list<std::string>* nested_names = nullptr);

    void getFieldInformation(google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field, FieldInformation& info,
                             std::list<std::string>* nested_names = nullptr, bool is_message = false);

    CbValue<std::int32_t> _fun_value_int32;
    CbValue<std::vector<std::int32_t>> _fun_value_int32_array;
    CbValue<std::uint32_t> _fun_value_uint32;
    CbValue<std::vector<std::uint32_t>> _fun_value_uint32_array;
    CbValue<std::int64_t> _fun_value_int64;
    CbValue<std::vector<std::int64_t>> _fun_value_int64_array;
    CbValue<std::uint64_t> _fun_value_uint64;
    CbValue<std::vector<std::uint64_t>> _fun_value_uint64_array;
    CbValue<float> _fun_value_float;
    CbValue<std::vector<float>> _fun_value_float_array;
    CbValue<double> _fun_value_double;
    CbValue<std::vector<double>> _fun_value_double_array;
    CbValue<std::string> _fun_value_string;
    CbValue<std::vector<std::string>> _fun_value_string_array;
    CbValue<std::string> _fun_value_string_info;
    CbValue<bool> _fun_value_bool;
    CbValue<std::vector<bool>> _fun_value_bool_array;
    CbValue<std::string> _fun_value_enum;
    CbValue<std::vector<std::string>> _fun_value_enum_array;

    CbMessageEvent _fun_msg_event;

    bool _verbose = true;
};

}  // namespace corbo

#endif  // MESSAGE_SUPPORT

#endif  // SRC_COMMUNICATION_INCLUDE_CORBO_COMMUNICATION_MESSAGE_PARSER_H_