nx_metadata_sdk  1.0
Metadata SDK
utils.h
Go to the documentation of this file.
1 // Copyright 2018-present Network Optix, Inc. Licensed under MPL 2.0: www.mozilla.org/MPL/2.0/
2 
3 #pragma once
4 
12 #include <cstddef>
13 #include <cstring>
14 #include <cstdlib>
15 #include <memory>
16 #include <string>
17 #include <sstream>
18 #include <vector>
19 
20 #if defined(QT_CORE_LIB)
21  // To be supported in toString().
22  #include <QtCore/QByteArray>
23  #include <QtCore/QString>
24  #include <QtCore/QUrl>
25 #endif
26 
27 #if !defined(NX_KIT_API)
28  #define NX_KIT_API /*empty*/
29 #endif
30 
31 namespace nx {
32 namespace kit {
33 namespace utils {
34 
35 //-------------------------------------------------------------------------------------------------
36 // Strings.
37 
38 inline bool isAsciiPrintable(int c)
39 {
40  return c >= 32 && c <= 126;
41 }
42 
47 NX_KIT_API std::string baseName(std::string path);
48 
52 NX_KIT_API std::string getProcessName();
53 
59 template<typename T>
60 std::string toString(T value);
61 
62 template<typename... Args>
63 std::string format(const std::string& formatStr, Args... args)
64 {
65  const size_t size = snprintf(nullptr, 0, formatStr.c_str(), args...) + /* space for '\0' */ 1;
66  if (size < 0)
67  return formatStr; //< No better way to handle out-of-memory-like errors.
68  std::string result(size, '\0');
69  snprintf(&result[0], size, formatStr.c_str(), args...);
70  result.resize(size - /* trailing '\0' */ 1);
71  return result;
72 }
73 
74 NX_KIT_API bool fromString(const std::string& s, int* value);
75 NX_KIT_API bool fromString(const std::string& s, double* value);
76 NX_KIT_API bool fromString(const std::string& s, float* value);
77 
78 void NX_KIT_API stringReplaceAllChars(std::string* s, char sample, char replacement);
79 void NX_KIT_API stringInsertAfterEach(std::string* s, char sample, const char* insertion);
80 
81 //-------------------------------------------------------------------------------------------------
82 // OS support.
83 
88 NX_KIT_API const std::vector<std::string>& getProcessCmdLineArgs();
89 
90 //-------------------------------------------------------------------------------------------------
91 // Aligned allocation.
92 
97 inline size_t alignUp(size_t value, size_t alignment)
98 {
99  if (alignment == 0)
100  return value;
101  const size_t remainder = value % alignment;
102  if (remainder == 0)
103  return value;
104  return value + alignment - remainder;
105 }
106 
108 inline uint8_t* misalignedPtr(void* data)
109 {
110  return (uint8_t*) (17 + alignUp((uintptr_t) data, 32));
111 }
112 
121 template<class MallocFunc>
122 void* mallocAligned(size_t size, size_t alignment, MallocFunc mallocFunc)
123 {
124  if (alignment == 0)
125  return 0;
126  void* ptr = mallocFunc(size + alignment + sizeof(alignment));
127  if (!ptr) //< allocation error
128  return ptr;
129 
130  void* aligned_ptr = (char*) ptr + sizeof(alignment); //< Leaving place to save misalignment.
131  const size_t misalignment = alignment - (((uintptr_t) aligned_ptr) % alignment);
132  memcpy((char*) ptr + misalignment, &misalignment, sizeof(misalignment)); //< Save misalignment.
133  return (char*) aligned_ptr + misalignment;
134 }
135 
137 inline void* mallocAligned(size_t size, size_t alignment)
138 {
139  // NOTE: Lambda is used to suppress a warning that some ::malloc() implementations are using
140  // deprecated exception specification.
141  return mallocAligned<>(size, alignment, [](size_t size) { return ::malloc(size); });
142 }
143 
151 template<class FreeFunc>
152 void freeAligned(void* ptr, FreeFunc freeFunc)
153 {
154  if (!ptr)
155  return freeFunc(ptr);
156 
157  ptr = (char*) ptr - sizeof(size_t);
158  size_t misalignment = 0;
159  memcpy(&misalignment, ptr, sizeof(misalignment)); //< Retrieve saved misalignment.
160  ptr = (char*) ptr - misalignment;
161 
162  freeFunc(ptr);
163 }
164 
166 inline void freeAligned(void* ptr)
167 {
168  // NOTE: Lambda is used to suppress a warning that some ::free() implementations are using
169  // deprecated exception specification.
170  return freeAligned<>(ptr, [](void* ptr) { return ::free(ptr); });
171 }
172 
173 //-------------------------------------------------------------------------------------------------
174 // Implementation.
175 
176 // The order of overloads below is important - it defines which will be chosen by inline functions.
177 NX_KIT_API std::string toString(bool b);
178 NX_KIT_API std::string toString(const void* ptr);
179 inline std::string toString(void* ptr) { return toString(const_cast<const void*>(ptr)); }
180 inline std::string toString(std::nullptr_t ptr) { return toString((const void*) ptr); }
181 inline std::string toString(uint8_t i) { return toString((int) i); } //< Avoid matching as char.
182 inline std::string toString(int8_t i) { return toString((int) i); } //< Avoid matching as char.
183 NX_KIT_API std::string toString(char c);
184 NX_KIT_API std::string toString(const char* s);
185 inline std::string toString(char* s) { return toString(const_cast<const char*>(s)); }
186 inline std::string toString(const std::string& s) { return toString(s.c_str()); }
187 NX_KIT_API std::string toString(wchar_t c);
188 NX_KIT_API std::string toString(const wchar_t* w);
189 inline std::string toString(wchar_t* w) { return toString(const_cast<const wchar_t*>(w)); }
190 inline std::string toString(const std::wstring& w) { return toString(w.c_str()); }
191 
192 // For unknown types, use their operator<<().
193 template<typename T>
194 std::string toString(T value)
195 {
196  std::ostringstream outputString;
197  outputString << value;
198  return outputString.str();
199 }
200 
201 #if defined(QT_CORE_LIB)
202 
203 static inline std::string toString(QByteArray b) //< By value to avoid calling the template impl.
204 {
205  return toString(b.toStdString());
206 }
207 
208 static inline std::string toString(QString s) //< By value to avoid calling the template impl.
209 {
210  return toString(s.toUtf8().constData());
211 }
212 
213 static inline std::string toString(QUrl u) //< By value to avoid calling the template impl.
214 {
215  return toString(u.toEncoded().toStdString());
216 }
217 
218 #endif // defined(QT_CORE_LIB)
219 
220 template<typename P>
221 std::string toString(P* ptr)
222 {
223  return toString((const void*) ptr);
224 }
225 
226 } // namespace utils
227 } // namespace kit
228 } // namespace nx
size_t alignUp(size_t value, size_t alignment)
Definition: utils.h:97
void * mallocAligned(size_t size, size_t alignment, MallocFunc mallocFunc)
Definition: utils.h:122
Definition: apple_utils.h:6
void freeAligned(void *ptr, FreeFunc freeFunc)
Definition: utils.h:152
uint8_t * misalignedPtr(void *data)
Definition: utils.h:108