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 <cstdio>
15 #include <cstdlib>
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 
52 NX_KIT_API std::string decodeEscapedString(
53  const std::string& s, std::string* outErrorMessage = nullptr);
54 
61 template<typename T>
62 std::string toString(T value);
63 
67 template<typename... Args>
68 std::string format(const std::string& formatStr, Args... args)
69 {
70  const int size = snprintf(nullptr, 0, formatStr.c_str(), args...) + /*space for \0*/ 1;
71  if (size <= 0)
72  return formatStr; //< No better way to handle out-of-memory-like errors.
73  std::string result(size, '\0');
74  snprintf(&result[0], size, formatStr.c_str(), args...);
75  result.resize(size - /*terminating \0*/ 1);
76  return result;
77 }
78 
79 NX_KIT_API bool fromString(const std::string& s, int* value);
80 NX_KIT_API bool fromString(const std::string& s, double* value);
81 NX_KIT_API bool fromString(const std::string& s, float* value);
82 NX_KIT_API bool fromString(const std::string& s, bool* value);
83 
84 NX_KIT_API void stringReplaceAllChars(std::string* s, char sample, char replacement);
85 NX_KIT_API void stringInsertAfterEach(std::string* s, char sample, const char* insertion);
86 NX_KIT_API void stringReplaceAll(
87  std::string* s, const std::string& sample, const std::string& replacement);
88 
89 //-------------------------------------------------------------------------------------------------
90 // OS support.
91 
96 NX_KIT_API std::string baseName(std::string path);
97 
103 NX_KIT_API std::string absolutePath(
104  const std::string& originDir, const std::string& path);
105 
109 NX_KIT_API std::string getProcessName();
110 
115 NX_KIT_API const std::vector<std::string>& getProcessCmdLineArgs();
116 
117 NX_KIT_API bool fileExists(const char* filename);
118 
119 //-------------------------------------------------------------------------------------------------
120 // Aligned allocation.
121 
126 inline size_t alignUp(size_t value, size_t alignment)
127 {
128  if (alignment == 0)
129  return value;
130  const size_t remainder = value % alignment;
131  if (remainder == 0)
132  return value;
133  return value + alignment - remainder;
134 }
135 
137 inline uint8_t* misalignedPtr(void* data)
138 {
139  return (uint8_t*) (17 + alignUp((uintptr_t) data, 32));
140 }
141 
150 template<class MallocFunc>
151 void* mallocAligned(size_t size, size_t alignment, MallocFunc mallocFunc)
152 {
153  if (alignment == 0)
154  return nullptr;
155  const auto ptr = (char*) mallocFunc(size + alignment + sizeof(alignment));
156  if (!ptr) //< allocation error
157  return ptr;
158 
159  char* const alignedPtr = ptr + sizeof(alignment); //< Leaving place to save misalignment.
160  const size_t misalignment = alignment - (uintptr_t) alignedPtr % alignment;
161  memcpy(ptr + misalignment, &misalignment, sizeof(misalignment)); //< Save misalignment.
162  return alignedPtr + misalignment;
163 }
164 
166 inline void* mallocAligned(size_t size, size_t alignment)
167 {
168  // NOTE: Lambda is used to suppress a warning that some ::malloc() implementations are using
169  // deprecated exception specification.
170  return mallocAligned<>(size, alignment, [](size_t size) { return ::malloc(size); });
171 }
172 
180 template<class FreeFunc>
181 void freeAligned(void* ptr, FreeFunc freeFunc)
182 {
183  if (!ptr)
184  return freeFunc(ptr);
185 
186  ptr = (char*) ptr - sizeof(size_t);
187  size_t misalignment = 0;
188  memcpy(&misalignment, ptr, sizeof(misalignment)); //< Retrieve saved misalignment.
189  ptr = (char*) ptr - misalignment;
190 
191  freeFunc(ptr);
192 }
193 
195 inline void freeAligned(void* ptr)
196 {
197  // NOTE: Lambda is used to suppress a warning that some ::free() implementations are using
198  // deprecated exception specification.
199  return freeAligned<>(ptr, [](void* ptr) { return ::free(ptr); });
200 }
201 
202 //-------------------------------------------------------------------------------------------------
203 // Implementation.
204 
205 // The order of overloads below is important - it defines which will be chosen by inline functions.
206 NX_KIT_API std::string toString(bool b);
207 NX_KIT_API std::string toString(const void* ptr);
208 inline std::string toString(void* ptr) { return toString(const_cast<const void*>(ptr)); }
209 inline std::string toString(std::nullptr_t ptr) { return toString((const void*) ptr); }
210 inline std::string toString(uint8_t i) { return toString((int) i); } //< Avoid matching as char.
211 inline std::string toString(int8_t i) { return toString((int) i); } //< Avoid matching as char.
212 NX_KIT_API std::string toString(char c);
213 NX_KIT_API std::string toString(const char* s);
214 inline std::string toString(char* s) { return toString(const_cast<const char*>(s)); }
215 NX_KIT_API std::string toString(wchar_t c);
216 NX_KIT_API std::string toString(const wchar_t* w);
217 inline std::string toString(wchar_t* w) { return toString(const_cast<const wchar_t*>(w)); }
218 
219 // std::string can contain '\0' inside, hence a dedicated implementation.
220 NX_KIT_API std::string toString(const std::string& s);
221 NX_KIT_API std::string toString(const std::wstring& w);
222 
223 
225 template<typename T>
226 std::string toString(T value)
227 {
228  std::ostringstream outputString;
229  outputString << value;
230  return outputString.str();
231 }
232 
233 #if defined(QT_CORE_LIB)
234 
235 static inline std::string toString(QByteArray b) //< By value to avoid calling the template impl.
236 {
237  return toString(b.toStdString());
238 }
239 
240 static inline std::string toString(QString s) //< By value to avoid calling the template impl.
241 {
242  return toString(s.toUtf8().constData());
243 }
244 
245 static inline std::string toString(QUrl u) //< By value to avoid calling the template impl.
246 {
247  return toString(u.toEncoded().toStdString());
248 }
249 
250 #endif // defined(QT_CORE_LIB)
251 
252 template<typename P>
253 std::string toString(P* ptr)
254 {
255  return toString((const void*) ptr);
256 }
257 
258 } // namespace utils
259 } // namespace kit
260 } // namespace nx
std::string format(const std::string &formatStr, Args... args)
Definition: utils.h:68
size_t alignUp(size_t value, size_t alignment)
Definition: utils.h:126
void * mallocAligned(size_t size, size_t alignment, MallocFunc mallocFunc)
Definition: utils.h:151
Definition: apple_utils.h:6
void freeAligned(void *ptr, FreeFunc freeFunc)
Definition: utils.h:181
uint8_t * misalignedPtr(void *data)
Definition: utils.h:137