array_memory.hh

#ifndef CLICK_ARRAY_MEMORY_HH
#define CLICK_ARRAY_MEMORY_HH 1
#include <click/glue.hh>
#include <click/type_traits.hh>
#if HAVE_VALGRIND && HAVE_VALGRIND_MEMCHECK_H
# include <valgrind/memcheck.h>
#endif
CLICK_DECLS
 
template <size_t s> class sized_array_memory { public:
    typedef char_array<s> type;
    template <typename T> static type *cast(T *x) {
        static_assert(sizeof(type) == s, "char_array<> size off");
        return reinterpret_cast<type *>(x);
    }
    template <typename T> static const type *cast(const T *x) {
        return reinterpret_cast<const type *>(x);
    }
    static void fill(void *a, size_t n, const void *x) {
        for (; n != 0; --n, a = (char *) a + s)
            memcpy(a, x, s);
    }
    static void move_construct(void* a, void* x) {
        memcpy(a, x, s);
    }
    static void copy(void *dst, const void *src, size_t n) {
        if (n)
            memcpy(dst, src, n * s);
    }
    static void move(void *dst, const void *src, size_t n) {
        if (n)
            memmove(dst, src, n * s);
    }
    static void move_onto(void *dst, const void *src, size_t n) {
        if (n)
            memmove(dst, src, n * s);
    }
    static void destroy(void *a, size_t n) {
        (void) a, (void) n;
    }
    static void mark_noaccess(void *a, size_t n) {
#ifdef VALGRIND_MAKE_MEM_NOACCESS
        VALGRIND_MAKE_MEM_NOACCESS(a, n * s);
#else
        (void) a, (void) n;
#endif
    }
    static void mark_undefined(void *a, size_t n) {
#ifdef VALGRIND_MAKE_MEM_UNDEFINED
        VALGRIND_MAKE_MEM_UNDEFINED(a, n * s);
#else
        (void) a, (void) n;
#endif
    }
};
 
template <typename T> class typed_array_memory { public:
    typedef T type;
    static T *cast(T *x) {
        return x;
    }
    static const T *cast(const T *x) {
        return x;
    }
    static void fill(T *a, size_t n, const T *x) {
        for (size_t i = 0; i != n; ++i)
            new((void *) &a[i]) T(*x);
    }
    static void move_construct(T* a, T* x) {
#if HAVE_CXX_RVALUE_REFERENCES
        new((void *) a) T(click_move(*x));
#else
        new((void *) a) T(*x);
#endif
    }
    static void copy(T *dst, const T *src, size_t n) {
        for (size_t i = 0; i != n; ++i)
            new((void *) &dst[i]) T(src[i]);
    }
    static void move(T *dst, const T *src, size_t n) {
        if (dst > src && src + n > dst) {
            for (dst += n - 1, src += n - 1; n != 0; --n, --dst, --src) {
                new((void *) dst) T(*src);
                src->~T();
            }
        } else {
            for (size_t i = 0; i != n; ++i) {
                new((void *) &dst[i]) T(src[i]);
                src[i].~T();
            }
        }
    }
    static void move_onto(T *dst, const T *src, size_t n) {
        if (dst > src && src + n > dst) {
            for (dst += n - 1, src += n - 1; n != 0; --n, --dst, --src) {
                dst->~T();
                new((void *) dst) T(*src);
            }
        } else {
            for (size_t i = 0; i != n; ++i) {
                dst[i].~T();
                new((void *) &dst[i]) T(src[i]);
            }
        }
    }
    static void destroy(T *a, size_t n) {
        for (size_t i = 0; i != n; ++i)
            a[i].~T();
    }
    static void mark_noaccess(T *a, size_t n) {
        sized_array_memory<sizeof(T)>::mark_noaccess(a, n);
    }
    static void mark_undefined(T *a, size_t n) {
        sized_array_memory<sizeof(T)>::mark_undefined(a, n);
    }
};
 
template <typename T> class array_memory : public conditional<has_trivial_copy<T>::value, sized_array_memory<sizeof(T)>, typed_array_memory<T> > {};
 
CLICK_ENDDECLS
#endif