ADTF  3.15.2
rawmemory_base.h
Go to the documentation of this file.
1 
7 #pragma once
8 #include <adtf_utils.h>
9 #include "adtf_base_type_traits.h"
10 
11 namespace adtf
12 {
13 namespace base
14 {
15 namespace ant
16 {
23 {
24 public:
33  virtual tResult Set(const void* pValue, size_t szSize) = 0;
38  virtual size_t GetSize() const = 0;
43  virtual const void* Get() const = 0;
44 };
45 
87 template<typename T>
89 {
101  inline static tResult Assign(T* pAssignValue,
102  const size_t szStaticSize,
103  const void* pValueToSet,
104  const size_t szSizeToSet)
105  {
106  static_assert(penguin::detail::always_false<T>,
107  "Unsupported type T! See documentation which types are supported."
108  "adtf_memory<T> only supports trivial types unless you specialize the adtf_memory_forward<T> for the type T!");
109  return ERR_NOT_IMPL;
110  }
119  inline static const void* GetPtr(const T* pAssignValue)
120  {
121  static_assert(penguin::detail::always_false<T>,
122  "Unsupported type T! See documentation which types are supported."
123  "adtf_memory<T> only supports trivial types unless you specialize the adtf_memory_forward<T> for the type T!");
124  return nullptr;
125  }
134  inline static size_t GetSize(const T* pAssignValue, const size_t szStaticSize)
135  {
136  static_assert(penguin::detail::always_false<T>,
137  "Unsupported type T! See documentation which types are supported."
138  "adtf_memory<T> only supports trivial types unless you specialize the adtf_memory_forward<T> for the type T!");
139  return size_t(0);
140  }
141 };
142 
149 template<typename T, size_t TSIZE = 0>
150 class adtf_memory : public IRawMemory, protected adtf_memory_forward<T>
151 {
153  typedef T _myStorageType;
155 
156 private:
159  adtf_memory() {};
160  adtf_memory(const adtf_memory&) = delete;
161  adtf_memory& operator=(const adtf_memory&) = delete;
162  adtf_memory(adtf_memory&&) = delete;
163  adtf_memory& operator=(adtf_memory&&) = delete;
164 
165 public:
167  explicit adtf_memory(T* pAssignValue)
168  {
169  m_pAssignValue = pAssignValue;
170  }
172  virtual ~adtf_memory()
173  {
174  m_pAssignValue = nullptr;
175  }
176 
177  tResult Set(const void* pValue, size_t szSize)
178  {
179  if (pValue != nullptr)
180  {
181  return _myBase::Assign(m_pAssignValue, TSIZE, pValue, szSize);
182  }
183  else
184  {
185  RETURN_ERROR(ERR_POINTER);
186  }
187  }
188  const void* Get() const
189  {
190  if (m_pAssignValue != nullptr)
191  {
193  }
194  return nullptr;
195  }
196  size_t GetSize() const
197  {
198  if (m_pAssignValue != nullptr)
199  {
200  return _myBase::GetSize(m_pAssignValue, TSIZE);
201  }
202  return size_t(0);
203  }
204 };
205 
206 template<typename T, typename Enable = void>
208  public IRawMemory
209 {
210 private:
211  T* m_pPtr;
212  size_t m_szSize;
213 
214 public:
215  adtf_memory_buffer(T* pPtr, size_t szSize):
216  m_pPtr(pPtr),
217  m_szSize(szSize)
218  {
219  }
220 
221  tResult Set(const void* pValue, size_t szSize) override
222  {
223  if (szSize > GetSize())
224  {
225  RETURN_ERROR(ERR_OUT_OF_RANGE);
226  }
227 
228  adtf_util::cMemoryBlock::MemCopy(m_pPtr, pValue, szSize);
229 
231  }
232 
233  size_t GetSize() const override
234  {
235  return m_szSize;
236  }
237 
238  const void* Get() const override
239  {
240  return m_pPtr;
241  }
242 };
243 
244 template<typename T>
245 class adtf_memory_buffer<T, typename std::enable_if<std::is_const<T>::value>::type> :
246  public IRawMemory
247 {
248 private:
249  const T* m_pPtr;
250  size_t m_szSize;
251 
252 public:
253  adtf_memory_buffer(const T* pPtr, size_t szSize):
254  m_pPtr(pPtr),
255  m_szSize(szSize)
256  {
257  }
258 
259  tResult Set(const void* /* pValue */, size_t /* szSize */) override
260  {
261  RETURN_ERROR(ERR_NOACCESS);
262  }
263 
264  size_t GetSize() const override
265  {
266  return m_szSize;
267  }
268 
269  const void* Get() const override
270  {
271  return m_pPtr;
272  }
273 };
274 } //namespace ant
275 
276 namespace penguin
277 {
291 template<typename T, typename Enable = void>
293 {
294 public:
295  explicit adtf_memory_trivial_type(T* pValuePointer):
296  m_pAssignedValue(pValuePointer)
297  {
298  }
307  tResult Set(const void* pValue, size_t szSize) override
308  {
309  RETURN_IF_POINTER_NULL(pValue);
310  RETURN_IF_POINTER_NULL(m_pAssignedValue);
311  if (szSize == sizeof(T))
312  {
313  adtf_util::cMemoryBlock::MemCopy(m_pAssignedValue, pValue, szSize);
315  }
316  else
317  {
318  RETURN_ERROR(ERR_MEMORY);
319  }
320  }
325  size_t GetSize() const override
326  {
327  if(m_pAssignedValue)
328  {
329  return sizeof(T);
330  }
331  return size_t(0);
332  }
337  const void* Get() const override
338  {
339  return m_pAssignedValue;
340  }
341 
342 private:
343  T* m_pAssignedValue = nullptr;
344 };
345 
346 template<typename T>
347 class adtf_memory_trivial_type<T, typename std::enable_if<std::is_const<T>::value>::type>
349 {
350 public:
351  explicit adtf_memory_trivial_type(T* pValuePointer):
352  m_pAssignedValue(pValuePointer)
353  {
354  }
363  tResult Set(const void* /*pValue*/, size_t /*szSize*/) override
364  {
365  RETURN_ERROR(ERR_POINTER);
366  }
371  size_t GetSize() const override
372  {
373  if (m_pAssignedValue)
374  {
375  return sizeof(T);
376  }
377  return size_t(0);
378  }
383  const void* Get() const override
384  {
385  return m_pAssignedValue;
386  }
387 private:
388  T* m_pAssignedValue = nullptr;
389 };
390 
391 
406 template<typename T, size_t TSIZE = 0, typename Enable=void>
408 {
410  typedef T _myStorageType;
412 
413 private:
416  adtf_memory() {};
417  adtf_memory(const adtf_memory&) = delete;
418  adtf_memory& operator=(const adtf_memory&) = delete;
419  adtf_memory(adtf_memory&&) = delete;
420  adtf_memory& operator=(adtf_memory&&) = delete;
421 
422 public:
427  explicit adtf_memory(T* pAssignValue):
428  m_pAssignValue(pAssignValue)
429  {
430  }
434  virtual ~adtf_memory()
435  {
436  m_pAssignValue = nullptr;
437  }
438 
445  tResult Set(const void* pValue, size_t szSize) override
446  {
447  constexpr auto szSizeToUse = std::conditional<std::is_void<T>::value,
450  if (pValue != nullptr)
451  {
452  return _myBase::Assign(m_pAssignValue, szSizeToUse, pValue, szSize);
453  }
454  else
455  {
457  }
458  }
463  const void* Get() const override
464  {
465  if (m_pAssignValue != nullptr)
466  {
468  }
469  return nullptr;
470  }
476  size_t GetSize() const override
477  {
478  constexpr auto szSizeToUse = std::conditional<std::is_void<T>::value,
481  if (m_pAssignValue != nullptr)
482  {
483  return _myBase::GetSize(m_pAssignValue, szSizeToUse);
484  }
485  return size_t(0);
486  }
487 };
488 
494 template<typename T>
495 class adtf_memory<T, 0, typename std::enable_if<std::is_trivially_copyable<T>::value>::type>
496  : public adtf_memory_trivial_type<T>
497 {
498 public:
500  typedef T _myStorageType;
502 
503 public:
504  explicit adtf_memory(T* pAssignValue):
505  _myBase(pAssignValue)
506  {
507  }
508 };
509 
510 }
511 
519 using ant::IRawMemory;
522 
523 } //namespace base
524 
525 } // namespace adtf
526 
Copyright © Audi Electronics Venture GmbH.
A common result class usable as return value throughout.
The IRawMemory interface provides methods for getting and setting memory values through abstract inte...
virtual tResult Set(const void *pValue, size_t szSize)=0
Sets the Raw pointer memory.
virtual size_t GetSize() const =0
Returns the size in bytes of the memory.
virtual const void * Get() const =0
Returns the raw memory pointer.
tResult Set(const void *pValue, size_t szSize) override
Sets the Raw pointer memory.
size_t GetSize() const override
Returns the size in bytes of the memory.
const void * Get() const override
Returns the raw memory pointer.
Legacy template class for adtf_memory usage.
size_t GetSize() const
Returns the size in bytes of the memory.
adtf_memory(T *pAssignValue)
explicit CTOR to create a IRawMemory interface rvalue
T * m_pAssignValue
Reference pointer to the T constructed with explict adtf_memory.
tResult Set(const void *pValue, size_t szSize)
Sets the Raw pointer memory.
const void * Get() const
Returns the raw memory pointer.
Template class implementation for the IRawMemory interface for trivial types.
tResult Set(const void *pValue, size_t szSize) override
Sets the Raw pointer memory.
size_t GetSize() const override
Returns the size in bytes of the memory.
const void * Get() const override
Returns the raw memory pointer.
Template class implementation for the ant::IRawMemory interface (see Supported types for adtf_memory<...
adtf_memory(T *pAssignValue)
explicit CTOR to create a IRawMemory interface rvalue
tResult Set(const void *pValue, size_t szSize) override
Sets the content of the assigned value of type T to the given memory.
size_t GetSize() const override
Retrieves the size of the content of the assigned value of type T.
T * m_pAssignValue
Reference pointer to the T constructed with explict adtf_memory.
const void * Get() const override
Retrieves the content of the assigned value of type T as memory pointer.
Namespace for entire ADTF SDK.
#define RETURN_NOERROR
Return status ERR_NOERROR, which requires the calling function's return type to be tResult.
#define RETURN_ERROR(code)
Return specific error code, which requires the calling function's return type to be tResult.
#define RETURN_IF_POINTER_NULL(_ptr)
Return ERR_POINTER if _ptr is nullptr, which requires the calling function's return type to be tResul...
Concept template class for non trivial penguin::adtf_memory types of type T to specialize the usage o...
static tResult Assign(T *pAssignValue, const size_t szStaticSize, const void *pValueToSet, const size_t szSizeToSet)
Sets (copy) the memory value pValueToSet of size in bytes szSizeToSet to the of container class T in ...
static size_t GetSize(const T *pAssignValue, const size_t szStaticSize)
Gets size in bytes of the memory pointer of container class T in parameter pAssignValue.
static const void * GetPtr(const T *pAssignValue)
Gets the memory pointer to the of container class T in parameter pAssignValue.
helper template to retrieve the given size as expression.
helper template to retrieve the given size as expression.