7317183253

Committed 24 Dec 2023 10:25PM UTC coverage: 36.26% (-0.6%) from 36.89%

Build # 7317183253

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #2088 from tbago/add_more_camera_function

More camera server functionality

Run Details

28 of 718 new or added lines in 12 files covered. (3.9%)

20 existing lines in 6 files now uncovered.

10035 of 27675 relevant lines covered (36.26%)

127.93 hits per line

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

64.36

/src/mavsdk/plugins/param_server/param_server_impl.cpp

#include "param_server_impl.h"
#include "callback_list.tpp"

namespace mavsdk {

template class CallbackList<ParamServer::IntParam>;
template class CallbackList<ParamServer::FloatParam>;
template class CallbackList<ParamServer::CustomParam>;

ParamServerImpl::ParamServerImpl(std::shared_ptr<ServerComponent> server_component) :
    ServerPluginImplBase(server_component)
{
    // FIXME: this plugin should support various component IDs
    _server_component_impl->register_plugin(this);
}

ParamServerImpl::~ParamServerImpl()
{
    _server_component_impl->unregister_plugin(this);
}

void ParamServerImpl::init() {}

void ParamServerImpl::deinit()
{
    _server_component_impl->mavlink_parameter_server().unsubscribe_all_params_changed(this);
}

std::pair<ParamServer::Result, int32_t> ParamServerImpl::retrieve_param_int(std::string name) const
{
    auto result =
        _server_component_impl->mavlink_parameter_server().retrieve_server_param_int(name);

    if (result.first == MavlinkParameterServer::Result::Success) {
        return {ParamServer::Result::Success, result.second};
    } else {
        return {ParamServer::Result::NotFound, -1};
    }
}

ParamServer::Result ParamServerImpl::provide_param_int(std::string name, int32_t value)
{
    if (name.size() > 16) {
        return ParamServer::Result::ParamNameTooLong;
    }
    _server_component_impl->mavlink_parameter_server().provide_server_param_int(name, value);
    _server_component_impl->mavlink_parameter_server().subscribe_param_int_changed(
        name,
        [name, this](int32_t new_value) {
            _changed_param_int_callbacks({name, new_value});
        },
        this);
    return ParamServer::Result::Success;
}

std::pair<ParamServer::Result, float> ParamServerImpl::retrieve_param_float(std::string name) const
{
    const auto result =
        _server_component_impl->mavlink_parameter_server().retrieve_server_param_float(name);

    if (result.first == MavlinkParameterServer::Result::Success) {
        return {ParamServer::Result::Success, result.second};
    } else {
        return {ParamServer::Result::NotFound, NAN};
    }
}

ParamServer::Result ParamServerImpl::provide_param_float(std::string name, float value)
{
    if (name.size() > 16) {
        return ParamServer::Result::ParamNameTooLong;
    }
    _server_component_impl->mavlink_parameter_server().provide_server_param_float(name, value);
    _server_component_impl->mavlink_parameter_server().subscribe_param_float_changed(
        name,
        [name, this](float new_value) {
            _changed_param_float_callbacks({name, new_value});
        },
        this);
    return ParamServer::Result::Success;
}

std::pair<ParamServer::Result, std::string>
ParamServerImpl::retrieve_param_custom(std::string name) const
{
    const auto result =
        _server_component_impl->mavlink_parameter_server().retrieve_server_param_custom(name);

    if (result.first == MavlinkParameterServer::Result::Success) {
        return {ParamServer::Result::Success, result.second};
    } else {
        return {ParamServer::Result::NotFound, {}};
    }
}

ParamServer::Result
ParamServerImpl::provide_param_custom(std::string name, const std::string& value)
{
    if (name.size() > 16) {
        return ParamServer::Result::ParamNameTooLong;
    }
    _server_component_impl->mavlink_parameter_server().provide_server_param_custom(name, value);
    _server_component_impl->mavlink_parameter_server().subscribe_param_custom_changed(
        name,
        [name, this](std::string new_value) {
            _changed_param_custom_callbacks({name, new_value});
        },
        this);
    return ParamServer::Result::Success;
}

ParamServer::AllParams ParamServerImpl::retrieve_all_params() const
{
    auto tmp = _server_component_impl->mavlink_parameter_server().retrieve_all_server_params();

    ParamServer::AllParams res{};

    for (auto const& param_pair : tmp) {
        if (param_pair.second.is<float>()) {
            ParamServer::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>()) {
            ParamServer::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);
        }
    }

    return res;
}

ParamServer::ChangedParamIntHandle
ParamServerImpl::subscribe_changed_param_int(const ParamServer::ChangedParamIntCallback& callback)
{
    return _changed_param_int_callbacks.subscribe(callback);
}

void ParamServerImpl::unsubscribe_changed_param_int(ParamServer::ChangedParamIntHandle handle)
{
    _changed_param_int_callbacks.unsubscribe(handle);
}

ParamServer::ChangedParamFloatHandle ParamServerImpl::subscribe_changed_param_float(
    const ParamServer::ChangedParamFloatCallback& callback)
{
    return _changed_param_float_callbacks.subscribe(callback);
}

void ParamServerImpl::unsubscribe_changed_param_float(ParamServer::ChangedParamFloatHandle handle)
{
    _changed_param_float_callbacks.unsubscribe(handle);
}

ParamServer::ChangedParamCustomHandle ParamServerImpl::subscribe_changed_param_custom(
    const ParamServer::ChangedParamCustomCallback& callback)
{
    return _changed_param_custom_callbacks.subscribe(callback);
}

void ParamServerImpl::unsubscribe_changed_param_custom(ParamServer::ChangedParamCustomHandle handle)
{
    _changed_param_custom_callbacks.unsubscribe(handle);
}

ParamServer::Result
ParamServerImpl::result_from_mavlink_parameter_server_result(MavlinkParameterServer::Result result)
{
    switch (result) {
        case MavlinkParameterServer::Result::Success:
            return ParamServer::Result::Success;
        case MavlinkParameterServer::Result::NotFound:
            return ParamServer::Result::NotFound;
        case MavlinkParameterServer::Result::ParamNameTooLong:
            return ParamServer::Result::ParamNameTooLong;
        case MavlinkParameterServer::Result::WrongType:
            return ParamServer::Result::WrongType;
        case MavlinkParameterServer::Result::ParamValueTooLong:
            return ParamServer::Result::ParamValueTooLong;
        default:
            LogErr() << "Unknown param error";
            return ParamServer::Result::Unknown;
    }
}

} // namespace mavsdk

1	#include "param_server_impl.h"
2	#include "callback_list.tpp"
3
4	namespace mavsdk {
5
6	template class CallbackList<ParamServer::IntParam>;
7	template class CallbackList<ParamServer::FloatParam>;
8	template class CallbackList<ParamServer::CustomParam>;
9
10	ParamServerImpl::ParamServerImpl(std::shared_ptr<ServerComponent> server_component) :	6✔
11	ServerPluginImplBase(server_component)	6✔
12	{
13	// FIXME: this plugin should support various component IDs
14	_server_component_impl->register_plugin(this);	6✔
15	}	6✔
16
17	ParamServerImpl::~ParamServerImpl()	6✔
18	{
19	_server_component_impl->unregister_plugin(this);	6✔
20	}	6✔
21
22	void ParamServerImpl::init() {}	6✔
23
24	void ParamServerImpl::deinit()	6✔
25	{
26	_server_component_impl->mavlink_parameter_server().unsubscribe_all_params_changed(this);	6✔
27	}	6✔
28
29	std::pair<ParamServer::Result, int32_t> ParamServerImpl::retrieve_param_int(std::string name) const	2✔
30	{
31	auto result =	2✔
32	_server_component_impl->mavlink_parameter_server().retrieve_server_param_int(name);	2✔
33
34	if (result.first == MavlinkParameterServer::Result::Success) {	2✔
35	return {ParamServer::Result::Success, result.second};	2✔
36	} else {
37	return {ParamServer::Result::NotFound, -1};	×
38	}
39	}
40
41	ParamServer::Result ParamServerImpl::provide_param_int(std::string name, int32_t value)	8✔
42	{
43	if (name.size() > 16) {	8✔
44	return ParamServer::Result::ParamNameTooLong;	×
45	}
46	_server_component_impl->mavlink_parameter_server().provide_server_param_int(name, value);	8✔
47	_server_component_impl->mavlink_parameter_server().subscribe_param_int_changed(	8✔
48	name,
49	[name, this](int32_t new_value) {	2✔
50	_changed_param_int_callbacks({name, new_value});	2✔
51	},	2✔
52	this);
53	return ParamServer::Result::Success;	8✔
54	}
55
56	std::pair<ParamServer::Result, float> ParamServerImpl::retrieve_param_float(std::string name) const	2✔
57	{
58	const auto result =	2✔
59	_server_component_impl->mavlink_parameter_server().retrieve_server_param_float(name);	2✔
60
61	if (result.first == MavlinkParameterServer::Result::Success) {	2✔
62	return {ParamServer::Result::Success, result.second};	2✔
63	} else {
64	return {ParamServer::Result::NotFound, NAN};	×
65	}
66	}
67
68	ParamServer::Result ParamServerImpl::provide_param_float(std::string name, float value)	8✔
69	{
70	if (name.size() > 16) {	8✔
71	return ParamServer::Result::ParamNameTooLong;	×
72	}
73	_server_component_impl->mavlink_parameter_server().provide_server_param_float(name, value);	8✔
74	_server_component_impl->mavlink_parameter_server().subscribe_param_float_changed(	8✔
75	name,
76	[name, this](float new_value) {	2✔
77	_changed_param_float_callbacks({name, new_value});	2✔
78	},	2✔
79	this);
80	return ParamServer::Result::Success;	8✔
81	}
82
83	std::pair<ParamServer::Result, std::string>
84	ParamServerImpl::retrieve_param_custom(std::string name) const	2✔
85	{
86	const auto result =	2✔
87	_server_component_impl->mavlink_parameter_server().retrieve_server_param_custom(name);	4✔
88
89	if (result.first == MavlinkParameterServer::Result::Success) {	2✔
90	return {ParamServer::Result::Success, result.second};	2✔
91	} else {
92	return {ParamServer::Result::NotFound, {}};	×
93	}
94	}
95
96	ParamServer::Result
97	ParamServerImpl::provide_param_custom(std::string name, const std::string& value)	8✔
98	{
99	if (name.size() > 16) {	8✔
100	return ParamServer::Result::ParamNameTooLong;	×
101	}
102	_server_component_impl->mavlink_parameter_server().provide_server_param_custom(name, value);	8✔
103	_server_component_impl->mavlink_parameter_server().subscribe_param_custom_changed(	8✔
104	name,
105	[name, this](std::string new_value) {	2✔
106	_changed_param_custom_callbacks({name, new_value});	2✔
107	},	2✔
108	this);
109	return ParamServer::Result::Success;	8✔
110	}
111
112	ParamServer::AllParams ParamServerImpl::retrieve_all_params() const	2✔
113	{
114	auto tmp = _server_component_impl->mavlink_parameter_server().retrieve_all_server_params();	4✔
115
116	ParamServer::AllParams res{};	2✔
117
118	for (auto const& param_pair : tmp) {	6✔
119	if (param_pair.second.is<float>()) {	4✔
120	ParamServer::FloatParam tmp_param;	4✔
121	tmp_param.name = param_pair.first;	2✔
122	tmp_param.value = param_pair.second.get<float>();	2✔
123	res.float_params.push_back(tmp_param);	2✔
124	} else if (param_pair.second.is<int32_t>()) {	2✔
125	ParamServer::IntParam tmp_param;	4✔
126	tmp_param.name = param_pair.first;	2✔
127	tmp_param.value = param_pair.second.get<int32_t>();	2✔
128	res.int_params.push_back(tmp_param);	2✔
129	}
130	}
131
132	return res;	2✔
133	}
134
135	ParamServer::ChangedParamIntHandle
NEW 136	ParamServerImpl::subscribe_changed_param_int(const ParamServer::ChangedParamIntCallback& callback)	×
137	{
NEW 138	return _changed_param_int_callbacks.subscribe(callback);	×
139	}
140
NEW 141	void ParamServerImpl::unsubscribe_changed_param_int(ParamServer::ChangedParamIntHandle handle)	×
142	{
NEW 143	_changed_param_int_callbacks.unsubscribe(handle);	×
NEW 144	}	×
145
NEW 146	ParamServer::ChangedParamFloatHandle ParamServerImpl::subscribe_changed_param_float(	×
147	const ParamServer::ChangedParamFloatCallback& callback)
148	{
NEW 149	return _changed_param_float_callbacks.subscribe(callback);	×
150	}
151
NEW 152	void ParamServerImpl::unsubscribe_changed_param_float(ParamServer::ChangedParamFloatHandle handle)	×
153	{
NEW 154	_changed_param_float_callbacks.unsubscribe(handle);	×
NEW 155	}	×
156
NEW 157	ParamServer::ChangedParamCustomHandle ParamServerImpl::subscribe_changed_param_custom(	×
158	const ParamServer::ChangedParamCustomCallback& callback)
159	{
NEW 160	return _changed_param_custom_callbacks.subscribe(callback);	×
161	}
162
NEW 163	void ParamServerImpl::unsubscribe_changed_param_custom(ParamServer::ChangedParamCustomHandle handle)	×
164	{
NEW 165	_changed_param_custom_callbacks.unsubscribe(handle);	×
NEW 166	}	×
167
168	ParamServer::Result
169	ParamServerImpl::result_from_mavlink_parameter_server_result(MavlinkParameterServer::Result result)	×
170	{
171	switch (result) {	×
172	case MavlinkParameterServer::Result::Success:	×
173	return ParamServer::Result::Success;	×
174	case MavlinkParameterServer::Result::NotFound:	×
175	return ParamServer::Result::NotFound;	×
176	case MavlinkParameterServer::Result::ParamNameTooLong:	×
177	return ParamServer::Result::ParamNameTooLong;	×
178	case MavlinkParameterServer::Result::WrongType:	×
179	return ParamServer::Result::WrongType;	×
180	case MavlinkParameterServer::Result::ParamValueTooLong:	×
181	return ParamServer::Result::ParamValueTooLong;	×
182	default:	×
183	LogErr() << "Unknown param error";	×
184	return ParamServer::Result::Unknown;	×
185	}
186	}
187
188	} // namespace mavsdk

mavlink / MAVSDK / 7317183253

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