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