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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
#ifndef _GLIBMM_UTILITY_H
#define _GLIBMM_UTILITY_H
/* Copyright 2002 The gtkmm Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include <glibmmconfig.h>
#include <glibmm/ustring.h>
#include <glib.h>
#include <memory> //For std::unique_ptr.
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
// These are used by gmmproc-generated type conversions:
/** Helper to deal with memory allocated
* by GLib functions in an exception-safe manner.
*
* This just creates a std::unique_ptr that uses g_free() as its deleter.
*/
template <typename T>
std::unique_ptr<T[], decltype(&g_free)>
make_unique_ptr_gfree(T* p)
{
return std::unique_ptr<T[], decltype(&g_free)>(p, &g_free);
}
// Convert const gchar* to ustring, while treating NULL as empty string.
inline Glib::ustring
convert_const_gchar_ptr_to_ustring(const char* str)
{
return (str) ? Glib::ustring(str) : Glib::ustring();
}
// Convert const gchar* to std::string, while treating NULL as empty string.
inline std::string
convert_const_gchar_ptr_to_stdstring(const char* str)
{
return (str) ? std::string(str) : std::string();
}
// Convert a non-const gchar* return value to ustring, freeing it too.
inline Glib::ustring
convert_return_gchar_ptr_to_ustring(char* str)
{
return (str) ? Glib::ustring(Glib::make_unique_ptr_gfree(str).get()) : Glib::ustring();
}
// Convert a non-const gchar* return value to std::string, freeing it too.
inline std::string
convert_return_gchar_ptr_to_stdstring(char* str)
{
return (str) ? std::string(Glib::make_unique_ptr_gfree(str).get()) : std::string();
}
/** Get a pointer to the C style string in a std::string or Glib::ustring.
* If the string is empty, a nullptr is returned.
*/
template <typename T>
inline const char*
c_str_or_nullptr(const T& str)
{
return str.empty() ? nullptr : str.c_str();
}
// Append type_name to dest, while replacing special characters with '+'.
GLIBMM_API
void append_canonical_typename(std::string& dest, const char* type_name);
// Delete data referred to by a void*.
// Instantiations can be used as destroy callbacks in glib functions
// that take a GDestroyNotify parameter, such as g_object_set_qdata_full()
// and g_option_group_set_translate_func().
template <typename T>
void
destroy_notify_delete(void* data)
{
delete static_cast<T*>(data);
}
// Conversion between different types of function pointers with
// reinterpret_cast can make gcc8 print a warning.
// https://github.com/libsigcplusplus/libsigcplusplus/issues/1
// https://github.com/libsigcplusplus/libsigcplusplus/issues/8
/** Returns the supplied function pointer, cast to a pointer to another function type.
*
* When a single reinterpret_cast between function pointer types causes a
* compiler warning or error, this function may work.
*
* Qualify calls with namespace names: sigc::internal::function_pointer_cast<>().
* If you don't, indirect calls from another library that also contains a
* function_pointer_cast<>() (perhaps glibmm), can be ambiguous due to ADL
* (argument-dependent lookup).
*/
template <typename T_out, typename T_in>
inline T_out function_pointer_cast(T_in in)
{
// The double reinterpret_cast suppresses a warning from gcc8 with the
// -Wcast-function-type option.
return reinterpret_cast<T_out>(reinterpret_cast<void (*)()>(in));
}
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
#endif /* _GLIBMM_UTILITY_H */
|
