4899817366

Build Type

github

Committed by GitHub

Commit Message

Merge c0bb90862 into e4e9c71dd

Pull Request Pull Request #1772: Refactor MAVLinkParameters into client and server classes

Run Details

2192 of 2192 new or added lines in 34 files covered. (100.0%)

7708 of 24812 relevant lines covered (31.07%)

19.96 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.68

/src/mavsdk/plugins/param/param_impl.cpp

#include <functional>
#include "param_impl.h"
#include "system.h"
#include "unused.h"

namespace mavsdk {

ParamImpl::ParamImpl(System& system) : PluginImplBase(system)
{
    _system_impl->register_plugin(this);
}

ParamImpl::ParamImpl(std::shared_ptr<System> system) : PluginImplBase(std::move(system))
{
    _system_impl->register_plugin(this);
}

ParamImpl::~ParamImpl()
{
    _system_impl->unregister_plugin(this);
}

void ParamImpl::init() {}

void ParamImpl::deinit() {}

void ParamImpl::enable() {}

void ParamImpl::disable() {}

std::pair<Param::Result, int32_t> ParamImpl::get_param_int(const std::string& name)
{
    std::pair<MavlinkParameterSender::Result, int32_t> result = _system_impl->get_param_int(
        name, _component_id, _protocol_version == Param::ProtocolVersion::Ext);
    return std::make_pair<>(
        result_from_mavlink_parameter_sender_result(result.first), result.second);
}

Param::Result ParamImpl::set_param_int(const std::string& name, int32_t value)
{
    MavlinkParameterSender::Result result = _system_impl->set_param_int(
        name, value, _component_id, _protocol_version == Param::ProtocolVersion::Ext);
    return result_from_mavlink_parameter_sender_result(result);
}

std::pair<Param::Result, float> ParamImpl::get_param_float(const std::string& name)
{
    std::pair<MavlinkParameterSender::Result, float> result = _system_impl->get_param_float(
        name, _component_id, _protocol_version == Param::ProtocolVersion::Ext);
    return std::make_pair<>(
        result_from_mavlink_parameter_sender_result(result.first), result.second);
}

Param::Result ParamImpl::set_param_float(const std::string& name, float value)
{
    MavlinkParameterSender::Result result = _system_impl->set_param_float(
        name, value, _component_id, _protocol_version == Param::ProtocolVersion::Ext);
    return result_from_mavlink_parameter_sender_result(result);
}

std::pair<Param::Result, std::string> ParamImpl::get_param_custom(const std::string& name)
{
    auto result = _system_impl->get_param_custom(name, _component_id);
    return std::make_pair<>(
        result_from_mavlink_parameter_sender_result(result.first), result.second);
}

Param::Result ParamImpl::set_param_custom(const std::string& name, const std::string& value)
{
    auto result = _system_impl->set_param_custom(name, value, _component_id);
    return result_from_mavlink_parameter_sender_result(result);
}

Param::AllParams ParamImpl::get_all_params()
{
    auto tmp = _system_impl->get_all_params(
        _component_id, _protocol_version == Param::ProtocolVersion::Ext);

    if (tmp.first != MavlinkParameterSender::Result::Success) {
        return {};
    }

    Param::AllParams res{};
    for (auto const& param_pair : tmp.second) {
        if (param_pair.second.is<float>()) {
            Param::FloatParam tmp_param;
            tmp_param.name = param_pair.first;
            tmp_param.value = param_pair.second.get<float>();
            res.float_params.push_back(tmp_param);
        } else if (param_pair.second.is<int32_t>()) {
            Param::IntParam tmp_param;
            tmp_param.name = param_pair.first;
            tmp_param.value = param_pair.second.get<int32_t>();
            res.int_params.push_back(tmp_param);
        } else if (param_pair.second.is<int16_t>()) {
            Param::IntParam tmp_param;
            tmp_param.name = param_pair.first;
            tmp_param.value = param_pair.second.get<int16_t>();
            res.int_params.push_back(tmp_param);
        } else if (param_pair.second.is<int8_t>()) {
            Param::IntParam tmp_param;
            tmp_param.name = param_pair.first;
            tmp_param.value = param_pair.second.get<int8_t>();
            res.int_params.push_back(tmp_param);
        } else if (param_pair.second.is<std::string>()) {
            Param::CustomParam tmp_param;
            tmp_param.name = param_pair.first;
            tmp_param.value = param_pair.second.get<std::string>();
            res.custom_params.push_back(tmp_param);
        }
    }

    return res;
}

Param::Result
ParamImpl::select_component(int32_t component_id, Param::ProtocolVersion protocol_version)
{
    _component_id = component_id;
    _protocol_version = protocol_version;
    return Param::Result::Unknown;
}

Param::Result
ParamImpl::result_from_mavlink_parameter_sender_result(MavlinkParameterSender::Result result)
{
    switch (result) {
        case MavlinkParameterSender::Result::Success:
            return Param::Result::Success;
        case MavlinkParameterSender::Result::Timeout:
            return Param::Result::Timeout;
        case MavlinkParameterSender::Result::ConnectionError:
            return Param::Result::ConnectionError;
        case MavlinkParameterSender::Result::WrongType:
            return Param::Result::WrongType;
        case MavlinkParameterSender::Result::ParamNameTooLong:
            return Param::Result::ParamNameTooLong;
        case MavlinkParameterSender::Result::NotFound:
            LogWarn() << "NotFound";
            return Param::Result::Unknown; // TODO fix
        case MavlinkParameterSender::Result::ValueUnsupported:
            LogWarn() << "ValueUnsupported";
            return Param::Result::Unknown; // TODO fix
        case MavlinkParameterSender::Result::Failed:
            LogWarn() << "Failed";
            return Param::Result::Unknown; // TODO fix
        case MavlinkParameterSender::Result::ParamValueTooLong:
            return Param::Result::ParamValueTooLong;
        case MavlinkParameterSender::Result::StringTypeUnsupported:
            LogWarn() << "StringTypeUnsupported";
            return Param::Result::Unknown; // TODO fix
        case MavlinkParameterSender::Result::InconsistentData:
            LogWarn() << "InconsistentData";
            return Param::Result::Unknown; // TODO fix
        case MavlinkParameterSender::Result::UnknownError:
            LogErr() << "Unknown 2 param error";
            return Param::Result::Unknown;
        default:
            LogErr() << "Unknown param error" << (int)result;
            return Param::Result::Unknown;
    }
}

} // namespace mavsdk

1	#include <functional>
2	#include "param_impl.h"
3	#include "system.h"
4	#include "unused.h"
5
6	namespace mavsdk {
7
8	ParamImpl::ParamImpl(System& system) : PluginImplBase(system)	×
9	{
10	_system_impl->register_plugin(this);	×
11	}	×
12
13	ParamImpl::ParamImpl(std::shared_ptr<System> system) : PluginImplBase(std::move(system))	8✔
14	{
15	_system_impl->register_plugin(this);	8✔
16	}	8✔
17
18	ParamImpl::~ParamImpl()	8✔
19	{
20	_system_impl->unregister_plugin(this);	8✔
21	}	8✔
22
23	void ParamImpl::init() {}	8✔
24
25	void ParamImpl::deinit() {}	8✔
26
27	void ParamImpl::enable() {}	8✔
28
29	void ParamImpl::disable() {}	8✔
30
31	std::pair<Param::Result, int32_t> ParamImpl::get_param_int(const std::string& name)	5✔
32	{
33	std::pair<MavlinkParameterSender::Result, int32_t> result = _system_impl->get_param_int(	5✔
34	name, _component_id, _protocol_version == Param::ProtocolVersion::Ext);	5✔
35	return std::make_pair<>(
36	result_from_mavlink_parameter_sender_result(result.first), result.second);	5✔
37	}
38
39	Param::Result ParamImpl::set_param_int(const std::string& name, int32_t value)	2✔
40	{
41	MavlinkParameterSender::Result result = _system_impl->set_param_int(	4✔
42	name, value, _component_id, _protocol_version == Param::ProtocolVersion::Ext);	2✔
43	return result_from_mavlink_parameter_sender_result(result);	2✔
44	}
45
46	std::pair<Param::Result, float> ParamImpl::get_param_float(const std::string& name)	5✔
47	{
48	std::pair<MavlinkParameterSender::Result, float> result = _system_impl->get_param_float(	5✔
49	name, _component_id, _protocol_version == Param::ProtocolVersion::Ext);	5✔
50	return std::make_pair<>(
51	result_from_mavlink_parameter_sender_result(result.first), result.second);	5✔
52	}
53
54	Param::Result ParamImpl::set_param_float(const std::string& name, float value)	2✔
55	{
56	MavlinkParameterSender::Result result = _system_impl->set_param_float(	4✔
57	name, value, _component_id, _protocol_version == Param::ProtocolVersion::Ext);	2✔
58	return result_from_mavlink_parameter_sender_result(result);	2✔
59	}
60
61	std::pair<Param::Result, std::string> ParamImpl::get_param_custom(const std::string& name)	4✔
62	{
63	auto result = _system_impl->get_param_custom(name, _component_id);	8✔
64	return std::make_pair<>(
65	result_from_mavlink_parameter_sender_result(result.first), result.second);	4✔
66	}
67
68	Param::Result ParamImpl::set_param_custom(const std::string& name, const std::string& value)	2✔
69	{
70	auto result = _system_impl->set_param_custom(name, value, _component_id);	2✔
71	return result_from_mavlink_parameter_sender_result(result);	2✔
72	}
73
74	Param::AllParams ParamImpl::get_all_params()	4✔
75	{
76	auto tmp = _system_impl->get_all_params(	4✔
77	_component_id, _protocol_version == Param::ProtocolVersion::Ext);	8✔
78
79	if (tmp.first != MavlinkParameterSender::Result::Success) {	4✔
80	return {};	×
81	}
82
83	Param::AllParams res{};	8✔
84	for (auto const& param_pair : tmp.second) {	34✔
85	if (param_pair.second.is<float>()) {	30✔
86	Param::FloatParam tmp_param;	24✔
87	tmp_param.name = param_pair.first;	12✔
88	tmp_param.value = param_pair.second.get<float>();	12✔
89	res.float_params.push_back(tmp_param);	12✔
90	} else if (param_pair.second.is<int32_t>()) {	18✔
91	Param::IntParam tmp_param;	24✔
92	tmp_param.name = param_pair.first;	12✔
93	tmp_param.value = param_pair.second.get<int32_t>();	12✔
94	res.int_params.push_back(tmp_param);	12✔
95	} else if (param_pair.second.is<int16_t>()) {	6✔
96	Param::IntParam tmp_param;	×
97	tmp_param.name = param_pair.first;	×
98	tmp_param.value = param_pair.second.get<int16_t>();	×
99	res.int_params.push_back(tmp_param);	×
100	} else if (param_pair.second.is<int8_t>()) {	6✔
101	Param::IntParam tmp_param;	×
102	tmp_param.name = param_pair.first;	×
103	tmp_param.value = param_pair.second.get<int8_t>();	×
104	res.int_params.push_back(tmp_param);	×
105	} else if (param_pair.second.is<std::string>()) {	6✔
106	Param::CustomParam tmp_param;	12✔
107	tmp_param.name = param_pair.first;	6✔
108	tmp_param.value = param_pair.second.get<std::string>();	6✔
109	res.custom_params.push_back(tmp_param);	6✔
110	}
111	}
112
113	return res;	4✔
114	}
115
116	Param::Result
117	ParamImpl::select_component(int32_t component_id, Param::ProtocolVersion protocol_version)	6✔
118	{
119	_component_id = component_id;	6✔
120	_protocol_version = protocol_version;	6✔
121	return Param::Result::Unknown;	6✔
122	}
123
124	Param::Result
125	ParamImpl::result_from_mavlink_parameter_sender_result(MavlinkParameterSender::Result result)	20✔
126	{
127	switch (result) {	20✔
128	case MavlinkParameterSender::Result::Success:	18✔
129	return Param::Result::Success;	18✔
130	case MavlinkParameterSender::Result::Timeout:	2✔
131	return Param::Result::Timeout;	2✔
132	case MavlinkParameterSender::Result::ConnectionError:	×
133	return Param::Result::ConnectionError;	×
134	case MavlinkParameterSender::Result::WrongType:	×
135	return Param::Result::WrongType;	×
136	case MavlinkParameterSender::Result::ParamNameTooLong:	×
137	return Param::Result::ParamNameTooLong;	×
138	case MavlinkParameterSender::Result::NotFound:	×
139	LogWarn() << "NotFound";	×
140	return Param::Result::Unknown; // TODO fix	×
141	case MavlinkParameterSender::Result::ValueUnsupported:	×
142	LogWarn() << "ValueUnsupported";	×
143	return Param::Result::Unknown; // TODO fix	×
144	case MavlinkParameterSender::Result::Failed:	×
145	LogWarn() << "Failed";	×
146	return Param::Result::Unknown; // TODO fix	×
147	case MavlinkParameterSender::Result::ParamValueTooLong:	×
148	return Param::Result::ParamValueTooLong;	×
149	case MavlinkParameterSender::Result::StringTypeUnsupported:	×
150	LogWarn() << "StringTypeUnsupported";	×
151	return Param::Result::Unknown; // TODO fix	×
152	case MavlinkParameterSender::Result::InconsistentData:	×
153	LogWarn() << "InconsistentData";	×
154	return Param::Result::Unknown; // TODO fix	×
155	case MavlinkParameterSender::Result::UnknownError:	×
156	LogErr() << "Unknown 2 param error";	×
157	return Param::Result::Unknown;	×
158	default:	×
159	LogErr() << "Unknown param error" << (int)result;	×
160	return Param::Result::Unknown;	×
161	}
162	}
163
164	} // namespace mavsdk

mavlink / MAVSDK / 4899817366

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous