extl/memory/help_functions.h

   1 /* ///////////////////////////////////////////////////////////////////////
   2  * File:                help_functions.h
   3  *
   4  * Created:             08.03.10
   5  * Updated:             08.04.14
   6  *
   7  * Brief: Memory helpful functions
   8  *
   9  * [<Home>]
  10  * Copyright (c) 2008-2020, Waruqi All rights reserved.
  11  * //////////////////////////////////////////////////////////////////// */
  12
  13 #ifndef EXTL_MEMORY_HELP_FUNCTIONS_H
  14 #define EXTL_MEMORY_HELP_FUNCTIONS_H
  15
  16 /*!\file help_functions.h
  17  * \brief Memory helpful functions
  18  */
  19 #ifndef __cplusplus
  20 #       error help_functions.h need be supported by c++.
  21 #endif
  22
  23 /* ///////////////////////////////////////////////////////////////////////
  24  * Includes
  25  */
  26 #       include "../prefix.h"
  27 #       include "../type/traits/is_void.h"
  28
  29 #ifdef EXTL_TYPE_TRAITS_IS_POD_SUPPORT
  30 #       include "../type/traits/is_pod.h"
  31 #endif
  32
  33 /* ///////////////////////////////////////////////////////////////////////
  34  * ::extl namespace
  35  */
  36 EXTL_BEGIN_NAMESPACE
  37
  38 /* ///////////////////////////////////////////////////////////////////////
  39  * Memory block operations
  40  */
  41
  42 /// mem_copy
  43 EXTL_INLINE void const* mem_copy(void* dest, void const* src, e_size_t size)
  44 {
  45         EXTL_ASSERT(NULL != dest);
  46         EXTL_ASSERT(NULL != src);
  47         return ::memcpy(dest, src, size);
  48 }
  49
  50 /// mem_cmp
  51 EXTL_INLINE e_int_t mem_cmp(void const* lhs, void const* rhs, e_size_t size)
  52 {
  53         EXTL_ASSERT(NULL != lhs);
  54         EXTL_ASSERT(NULL != rhs);
  55
  56         return ::memcmp(lhs, rhs, size);
  57 }
  58
  59 /// mem_move
  60 EXTL_INLINE void const* mem_move(void* dest, void const* src, e_size_t size)
  61 {
  62         EXTL_ASSERT(NULL != dest);
  63         EXTL_ASSERT(NULL != src);
  64
  65         return ::memmove(dest, src, size);
  66 }
  67
  68 /// mem_fill
  69 EXTL_INLINE void const* mem_fill(void* dest, e_int_t const& value, e_size_t size)
  70 {
  71         EXTL_ASSERT(NULL != dest);
  72         return ::memset(dest, value, size);
  73 }
  74
  75 /// mem_fill_0
  76 EXTL_INLINE void const* mem_fill_0(void* dest, e_size_t size)
  77 {
  78         EXTL_ASSERT(NULL != dest);
  79         return ::memset(dest, 0, size);
  80 }
  81 /* ///////////////////////////////////////////////////////////////////////
  82  * POD memory block operations
  83  */
  84 /// pod_copy_n
  85 template < typename_param_k D, typename_param_k S >
  86 EXTL_INLINE D const* pod_copy_n(D* dest, S const* src, e_size_t n)
  87 {
  88 #ifdef EXTL_TYPE_TRAITS_IS_POD_SUPPORT
  89         EXTL_MUST_BE_POD(D);
  90         EXTL_MUST_BE_POD(S);
  91 #endif
  92         EXTL_MUST_NOT_BE_VOID(D);
  93         EXTL_MUST_NOT_BE_VOID(S);
  94
  95         return static_cast<D const*>(mem_copy(dest, src, n * sizeof(D)));
  96 }
  97
  98 /// non_pod_copy_n
  99 template < typename_param_k D, typename_param_k S >
 100 EXTL_INLINE D const* non_pod_copy_n(D* dest, S const* src, e_size_t n)
 101 {
 102         D* ret = dest;
 103         for(; 0 != n; ++dest, ++src, --n)
 104     {
 105         *dest = *src;
 106     }
 107         return ret;
 108 }
 109 /// pod_cmp_n
 110 template < typename_param_k D, typename_param_k S >
 111 EXTL_INLINE e_int_t pod_cmp_n(D const* lhs, S const* rhs, e_size_t n)
 112 {
 113 #ifdef EXTL_TYPE_TRAITS_IS_POD_SUPPORT
 114         EXTL_MUST_BE_POD(D);
 115         EXTL_MUST_BE_POD(S);
 116 #endif
 117         EXTL_MUST_NOT_BE_VOID(D);
 118         EXTL_MUST_NOT_BE_VOID(S);
 119
 120         EXTL_ASSERT(0 != n);
 121         for(e_size_t i = 0; i < n; ++i, ++lhs, ++rhs)
 122         {
 123                 if(*lhs != *rhs)
 124                 {
 125                         return (*lhs < *rhs)? -1 : + 1;
 126                 }
 127         }
 128         return 0;
 129 }
 130 /// pod_cmp_n
 131 EXTL_INLINE e_int_t pod_cmp_n(e_char_t const* lhs, e_char_t const* rhs, e_size_t n)
 132 {
 133         return mem_cmp(lhs, rhs, n * sizeof(e_char_t));
 134 }
 135
 136 /// non_pod_cmp_n
 137 template < typename_param_k D, typename_param_k S >
 138 EXTL_INLINE e_int_t non_pod_cmp_n(D const* lhs, S const* rhs, e_size_t n)
 139 {
 140         EXTL_ASSERT(NULL != lhs);
 141         EXTL_ASSERT(NULL != rhs);
 142         EXTL_ASSERT(0 != n);
 143         for(e_size_t i = 0; i < n; ++i, ++lhs, ++rhs)
 144         {
 145                 if(*lhs != *rhs)
 146                 {
 147                         return (*lhs < *rhs)? -1 : + 1;
 148                 }
 149         }
 150         return 0;
 151 }
 152 /// pod_move_n
 153 template < typename_param_k D, typename_param_k S >
 154 EXTL_INLINE D const* pod_move_n(D* dest, S const* src, e_size_t n)
 155 {
 156 #ifdef EXTL_TYPE_TRAITS_IS_POD_SUPPORT
 157         EXTL_MUST_BE_POD(D);
 158         EXTL_MUST_BE_POD(S);
 159 #endif
 160
 161         EXTL_MUST_NOT_BE_VOID(D);
 162         EXTL_MUST_NOT_BE_VOID(S);
 163
 164         return static_cast<D const*>(mem_move(dest, src, n * sizeof(D)));
 165 }
 166 /// non_pod_move_n
 167 template < typename_param_k D, typename_param_k S >
 168 EXTL_INLINE D const* non_pod_move_n(D* dest, S const* src, e_size_t n)
 169 {
 170         EXTL_ASSERT(NULL != dest);
 171         EXTL_ASSERT(NULL != src);
 172
 173         return non_pod_copy_n(dest, src, n);
 174 }
 175
 176 /// pod_fill_n
 177 template < typename_param_k D, typename_param_k V >
 178 EXTL_INLINE D const* pod_fill_n(D* dest, V const& value, e_size_t n)
 179 {
 180 #ifdef EXTL_TYPE_TRAITS_IS_POD_SUPPORT
 181         EXTL_MUST_BE_POD(D);
 182         EXTL_MUST_BE_POD(V);
 183 #endif
 184         EXTL_MUST_NOT_BE_VOID(D);
 185
 186         EXTL_ASSERT(0 != n);
 187
 188         D* ret = dest;
 189         for(; 0 != n; ++dest, --n)
 190     {
 191         *dest = value;
 192     }
 193         return ret;
 194 }
 195 /// pod_fill_n: Optimizatiion
 196 EXTL_INLINE e_char_t const* pod_fill_n(e_char_t* dest, e_char_t const& value, e_size_t n)
 197 {
 198         return static_cast<e_char_t const*>(mem_fill(dest, value, n * sizeof(e_char_t)));
 199 }
 200 /// non_pod_fill_n
 201 template < typename_param_k D, typename_param_k V >
 202 EXTL_INLINE D const* non_pod_fill_n(D* dest, V const& value, e_size_t n)
 203 {
 204         EXTL_ASSERT(NULL != dest);
 205         EXTL_ASSERT(0 != n);
 206
 207         D* ret = dest;
 208         for(; 0 != n; ++dest, --n)
 209     {
 210         *dest = value;
 211     }
 212         return ret;
 213 }
 214
 215 /// pod_fill_n
 216 template < typename_param_k D >
 217 EXTL_INLINE D const* pod_fill_0_n(D* dest, e_size_t n)
 218 {
 219 #ifdef EXTL_TYPE_TRAITS_IS_POD_SUPPORT
 220         EXTL_MUST_BE_POD(D);
 221 #endif
 222         EXTL_MUST_NOT_BE_VOID(D);
 223
 224         return static_cast<D const*>(mem_fill_0(dest, n * sizeof(D)));
 225 }
 226
 227 /// non_pod_fill_0
 228 template < typename_param_k D >
 229 EXTL_INLINE D const* non_pod_fill_0_n(D* dest, e_size_t n)
 230 {
 231         EXTL_ASSERT(NULL != dest);
 232         EXTL_ASSERT(0 != n);
 233
 234         D* ret = dest;
 235         for(; 0 != n; ++dest, --n)
 236     {
 237         *dest = D();
 238     }
 239         return ret;
 240 }
 241 /* ///////////////////////////////////////////////////////////////////////
 242  * Unit-testing
 243  */
 244 #ifdef EXTL_MEMORY_HELP_FUNCTIONS_TEST_ENABLE
 245 #       include "unit_test/help_functions_test.h"
 246 #endif
 247
 248 /* ///////////////////////////////////////////////////////////////////////
 249  * ::extl namespace
 250  */
 251 EXTL_END_NAMESPACE
 252
 253 /* //////////////////////////////////////////////////////////////////// */
 254 #endif /* EXTL_MEMORY_HELP_FUNCTIONS_H */
 255 /* //////////////////////////////////////////////////////////////////// */