simplersble 0.11.0-dev32

The all-in-one Bluetooth library that makes it easy to add wireless connectivity to your projects.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

#include <simpledbus/base/HolderUtils.h>

namespace SimpleDBus {

namespace HolderUtils {

Holder from_byte_array(const kvn::bytearray& value) {
    Holder value_array = Holder::create_array();
    for (size_t i = 0; i < value.size(); i++) {
        value_array.array_append(Holder::create_byte(value[i]));
    }
    return value_array;
}

kvn::bytearray to_byte_array(const Holder& holder) {
    auto value_array = holder.get_array();
    kvn::bytearray _value;
    for (std::size_t i = 0; i < value_array.size(); i++) {
        _value.push_back(value_array[i].get_byte());
    }
    return _value;
}

Holder from_string_array(const std::vector<std::string>& value) {
    Holder holder = Holder::create_array();
    for (auto const& val : value) {
        holder.array_append(Holder::create_string(val));
    }
    return holder;
}

std::vector<std::string> to_string_array(const Holder& holder) {
    std::vector<std::string> result;
    auto array = holder.get_array();
    for (auto& h : array) {
        result.push_back(h.get_string());
    }
    return result;
}

Holder from_dict_uint8_byte_array(const std::map<uint8_t, kvn::bytearray>& value) {
    Holder dict = Holder::create_dict();
    for (auto const& [key, val] : value) {
        dict.dict_append(Holder::BYTE, key, from_byte_array(val));
    }
    return dict;
}

std::map<uint8_t, kvn::bytearray> to_dict_uint8_byte_array(const Holder& holder) {
    std::map<uint8_t, kvn::bytearray> result;
    auto dict = holder.get_dict_uint8();
    for (auto& [key, val_holder] : dict) {
        result[key] = to_byte_array(val_holder);
    }
    return result;
}

Holder from_dict_uint16_byte_array(const std::map<uint16_t, kvn::bytearray>& value) {
    Holder dict = Holder::create_dict();
    for (auto const& [key, val] : value) {
        dict.dict_append(Holder::UINT16, key, from_byte_array(val));
    }
    return dict;
}

std::map<uint16_t, kvn::bytearray> to_dict_uint16_byte_array(const Holder& holder) {
    std::map<uint16_t, kvn::bytearray> result;
    auto dict = holder.get_dict_uint16();
    for (auto& [key, val_holder] : dict) {
        result[key] = to_byte_array(val_holder);
    }
    return result;
}

Holder from_dict_string_byte_array(const std::map<std::string, kvn::bytearray>& value) {
    Holder dict = Holder::create_dict();
    for (auto const& [key, val] : value) {
        dict.dict_append(Holder::STRING, key, from_byte_array(val));
    }
    return dict;
}

std::map<std::string, kvn::bytearray> to_dict_string_byte_array(const Holder& holder) {
    std::map<std::string, kvn::bytearray> result;
    auto dict = holder.get_dict_string();
    for (auto& [key, val_holder] : dict) {
        result[key] = to_byte_array(val_holder);
    }
    return result;
}

}  // namespace HolderUtils

}  // namespace SimpleDBus