stub_analytics_plugin  1.6
Network Optix Video Analytics SDK
utils.h
Go to the documentation of this file.
1 // Copyright 2018-present Network Optix, Inc.
2 #pragma once
3 
11 #include <cstddef>
12 #include <cstring>
13 #include <cstdlib>
14 #include <memory>
15 #include <string>
16 #include <sstream>
17 
18 #if defined(QT_CORE_LIB)
19  // To be supported in toString().
20  #include <QtCore/QByteArray>
21  #include <QtCore/QString>
22  #include <QtCore/QUrl>
23 #endif
24 
25 #if !defined(NX_KIT_API)
26  #define NX_KIT_API /*empty*/
27 #endif
28 
29 namespace nx {
30 namespace kit {
31 namespace utils {
32 
33 //-------------------------------------------------------------------------------------------------
34 // Strings.
35 
36 inline bool isAsciiPrintable(int c)
37 {
38  return c >= 32 && c <= 126;
39 }
40 
44 template<typename T>
45 std::string toString(T value);
46 
47 template<typename... Args>
48 std::string format(const std::string& formatStr, Args... args)
49 {
50  const size_t size = snprintf(nullptr, 0, formatStr.c_str(), args...) + /* space for '\0' */ 1;
51  if (size < 0)
52  return formatStr; //< No better way to handle out-of-memory-like errors.
53  std::string result(size, '\0');
54  snprintf(&result[0], size, formatStr.c_str(), args...);
55  result.resize(size - /* trailing '\0' */ 1);
56  return result;
57 }
58 
59 //-------------------------------------------------------------------------------------------------
60 // Aligned allocation.
61 
66 inline size_t alignUp(size_t value, size_t alignment)
67 {
68  if (alignment == 0)
69  return value;
70  const size_t remainder = value % alignment;
71  if (remainder == 0)
72  return value;
73  return value + alignment - remainder;
74 }
75 
77 inline uint8_t* misalignedPtr(void* data)
78 {
79  return (uint8_t*) (17 + alignUp((uintptr_t) data, 32));
80 }
81 
90 template<class MallocFunc>
91 void* mallocAligned(size_t size, size_t alignment, MallocFunc mallocFunc)
92 {
93  if (alignment == 0)
94  return 0;
95  void* ptr = mallocFunc(size + alignment + sizeof(alignment));
96  if (!ptr) //< allocation error
97  return ptr;
98 
99  void* aligned_ptr = (char*) ptr + sizeof(alignment); //< Leaving place to save misalignment.
100  const size_t misalignment = alignment - (((uintptr_t) aligned_ptr) % alignment);
101  memcpy((char*) ptr + misalignment, &misalignment, sizeof(misalignment)); //< Save misalignment.
102  return (char*) aligned_ptr + misalignment;
103 }
104 
106 inline void* mallocAligned(size_t size, size_t alignment)
107 {
108  return mallocAligned<>(size, alignment, ::malloc);
109 }
110 
118 template<class FreeFunc>
119 void freeAligned(void* ptr, FreeFunc freeFunc)
120 {
121  if (!ptr)
122  return freeFunc(ptr);
123 
124  ptr = (char*) ptr - sizeof(size_t);
125  size_t misalignment = 0;
126  memcpy(&misalignment, ptr, sizeof(misalignment)); //< Retrieve saved misalignment.
127  ptr = (char*) ptr - misalignment;
128 
129  freeFunc(ptr);
130 }
131 
133 inline void freeAligned(void* ptr)
134 {
135  return freeAligned<>(ptr, ::free);
136 }
137 
138 //-------------------------------------------------------------------------------------------------
139 // Implementation.
140 
141 template<typename T>
142 std::string toString(T value)
143 {
144  std::ostringstream outputString;
145  outputString << value;
146  return outputString.str();
147 }
148 
149 NX_KIT_API std::string toString(std::string s); //< By value to avoid calling the template impl.
150 NX_KIT_API std::string toString(uint8_t i); //< Otherwise, uint8_t would be printed as char.
151 NX_KIT_API std::string toString(char c);
152 NX_KIT_API std::string toString(const char* s);
153 NX_KIT_API std::string toString(char* s);
154 NX_KIT_API std::string toString(const void* ptr);
155 NX_KIT_API std::string toString(void* ptr);
156 NX_KIT_API std::string toString(std::nullptr_t ptr);
157 NX_KIT_API std::string toString(bool b);
158 
159 #if defined(QT_CORE_LIB)
160 
161 static inline std::string toString(QByteArray b) //< By value to avoid calling the template impl.
162 {
163  return toString(b.toStdString());
164 }
165 
166 static inline std::string toString(QString s) //< By value to avoid calling the template impl.
167 {
168  return toString(s.toUtf8().constData());
169 }
170 
171 static inline std::string toString(QUrl u) //< By value to avoid calling the template impl.
172 {
173  return toString(u.toEncoded().toStdString());
174 }
175 
176 #endif // defined(QT_CORE_LIB)
177 
178 template<typename P>
179 std::string toString(P* ptr)
180 {
181  return toString((const void*) ptr);
182 }
183 
184 } // namespace utils
185 } // namespace kit
186 } // namespace nx
size_t alignUp(size_t value, size_t alignment)
Definition: utils.h:66
uint8_t * misalignedPtr(void *data)
Definition: utils.h:77
void * mallocAligned(size_t size, size_t alignment, MallocFunc mallocFunc)
Definition: utils.h:91
Definition: debug.cpp:13
void freeAligned(void *ptr, FreeFunc freeFunc)
Definition: utils.h:119