xsarray.h

Go to the documentation of this file.

 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
#ifndef XSARRAY_H
#define XSARRAY_H
 
#include "xstypesconfig.h"
 
#define XSARRAY_DECL(T)\
        T* const m_data;                        \
        const XsSize m_size;            \
        const XsSize m_reserved;        \
        const XsSize m_flags;           \
        XsArrayDescriptor const* const m_descriptor;            
#define XSARRAY_STRUCT(S,T)             struct S { XSARRAY_DECL(T) }
#define XSARRAY_INITIALIZER(D)  { 0, 0, 0, XSDF_Managed, D }
 
typedef void (*XsArrayItemSwapFunc)(void*, void*);
typedef void (*XsArrayItemStructFunc)(void*);
typedef void (*XsArrayItemCopyFunc)(void*, void const*);
typedef int (*XsArrayItemCompareFunc)(void const*, void const*);        
typedef void (*XsArrayRawCopy)(void*, void const*, XsSize, XsSize);
 
#define XSEXPCASTITEMSWAP       (XsArrayItemSwapFunc)
#define XSEXPCASTITEMMAKE       (XsArrayItemStructFunc)
#define XSEXPCASTITEMCOPY       (XsArrayItemCopyFunc)
#define XSEXPCASTITEMCOMP       (XsArrayItemCompareFunc)
#define XSEXPCASTRAWCOPY        (XsArrayRawCopy)
 
struct XsArrayDescriptor
{
#ifndef __cplusplus
        const
#else
protected:
        template <typename T, XsArrayDescriptor const& D, typename I> friend struct XsArrayImpl;
#endif
        XsSize itemSize;                                                                        
        void (*itemSwap)(void* a, void* b);                                     
        void (*itemConstruct)(void* e);                                         
        void (*itemCopyConstruct)(void* e, void const* s);      
        void (*itemDestruct)(void* e);                                          
        void (*itemCopy)(void* to, void const* from);           
        int (*itemCompare)(void const* a, void const* b);       
        void (*rawCopy)(void* to, void const* from, XsSize count, XsSize iSize);        
};
typedef struct XsArrayDescriptor XsArrayDescriptor;
 
#ifdef __cplusplus
#include <iterator>
#include <stdexcept>
 
#if __cplusplus >= 201103L && !defined(XSENS_HAVE_TYPE_TRAITS)
#include <type_traits>
#define XSENS_HAVE_TYPE_TRAITS
#endif
 
extern "C" {
#endif
 
XSTYPES_DLL_API void XsArray_construct(void* thisPtr, XsArrayDescriptor const* const descriptor, XsSize count, void const* src);
XSTYPES_DLL_API void XsArray_copyConstruct(void* thisPtr, void const* src);
XSTYPES_DLL_API void XsArray_destruct(void* thisPtr);
XSTYPES_DLL_API void XsArray_assign(void* thisPtr, XsSize count, void const* src);
XSTYPES_DLL_API void XsArray_resize(void* thisPtr, XsSize count);
XSTYPES_DLL_API void XsArray_reserve(void* thisPtr, XsSize count);
XSTYPES_DLL_API void XsArray_copy(void* thisPtr, void const* src);
XSTYPES_DLL_API void XsArray_append(void* thisPtr, void const* other);
XSTYPES_DLL_API void XsArray_insert(void* thisPtr, XsSize index, XsSize count, void const* src);
XSTYPES_DLL_API void XsArray_erase(void* thisPtr, XsSize index, XsSize count);
XSTYPES_DLL_API void XsArray_swap(void* a, void* b);
XSTYPES_DLL_API int XsArray_compare(void const* a, void const* b);
XSTYPES_DLL_API int XsArray_compareSet(void const* a, void const* b);
XSTYPES_DLL_API int XsArray_comparePredicate(void const* a, void const* b, XsArrayItemCompareFunc predicate);
XSTYPES_DLL_API ptrdiff_t XsArray_find(void const* thisPtr, void const* needle);
XSTYPES_DLL_API ptrdiff_t XsArray_findPredicate(void const* thisPtr, void const* needle, XsArrayItemCompareFunc predicate);
XSTYPES_DLL_API int XsArray_empty(void const* thisPtr);
XSTYPES_DLL_API void const* XsArray_at(void const* thisPtr, XsSize index);
XSTYPES_DLL_API void* XsArray_atIndex(void* thisPtr, XsSize index);
XSTYPES_DLL_API void XsArray_removeDuplicates(void* thisPtr);
XSTYPES_DLL_API void XsArray_removeDuplicatesPredicate(void* thisPtr, XsArrayItemCompareFunc predicate);
XSTYPES_DLL_API void XsArray_rawCopy(void* to, void const* from, XsSize count, XsSize iSize);
XSTYPES_DLL_API void XsArray_sort(void* thisPtr);
XSTYPES_DLL_API void XsArray_reverse(void* thisPtr);
 
struct XsArray
{
        XSARRAY_DECL(void)
#ifdef __cplusplus
        inline XsArray(XsArrayDescriptor const* descriptor, XsSize count = 0, void const* src = 0)
                : m_data(0)
                , m_size(0)
                , m_reserved(0)
                , m_flags(0)
                , m_descriptor(0)
        {
                XsArray_construct(this, descriptor, count, src);
        }
 
        inline XsArray(const XsArray& src)
                : m_data(0)
                , m_size(0)
                , m_reserved(0)
                , m_flags(0)
                , m_descriptor(0)
        {
                XsArray_copyConstruct(this, &src);
        }
 
        inline explicit XsArray(XsArrayDescriptor const* descriptor, void* ref, XsSize count, XsDataFlags flags)
                : m_data(ref)
                , m_size(count)
                , m_reserved(count)
                , m_flags((XsSize)flags)
                , m_descriptor(descriptor)
        {
        }
 
#ifndef SWIG
        inline XsArray(XsArray&& src)
                : m_data(0)
                , m_size(0)
                , m_reserved(0)
                , m_flags(0)
                , m_descriptor(src.m_descriptor)
        {
                if (!(src.m_flags & XSDF_Managed))
                        XsArray_copy(this, &src);
                else
                        XsArray_swap(this, &src);
        }
#endif
 
        ~XsArray()
        {
                XsArray_destruct(this);
        }
 
        inline XsArray const& operator=(const XsArray& src)
        {
                if (this != &src)
                        XsArray_copy(this, &src);
                return *this;
        }
#endif
};
 
typedef struct XsArray XsArray;
 
#ifdef __cplusplus
} // extern "C"
 
template <typename T, XsArrayDescriptor const& D, typename I>
struct XsArrayImpl : private XsArray
{
        typedef T value_type;
 
        typedef XsSize size_type;
 
        typedef XsArrayImpl<T, D, I> ArrayImpl;
 
        inline explicit XsArrayImpl<T, D, I>(XsSize count = 0, T const* src = 0)
                : XsArray(&D, count, src)
        {
        }
 
        inline XsArrayImpl<T, D, I>(ArrayImpl const& other)
                : XsArray(other)
        {
        }
 
#ifndef XSENS_NOITERATOR
        template <typename Iterator>
        inline explicit XsArrayImpl<T, D, I>(Iterator const& beginIt, Iterator const& endIt)
                : XsArray(&D, 0, 0)
        {
                ptrdiff_t diff = endIt - beginIt;
                if (diff > 0)
                {
                        reserve((XsSize) diff);
                        for (Iterator it = beginIt; it != endIt; ++it)
                                push_back(*it);
                }
        }
#endif
        inline explicit XsArrayImpl<T, D, I>(T* ref, XsSize sz, XsDataFlags flags /* = XSDF_None */)
                : XsArray(&D, ref, sz, flags)
        {
        }
 
        inline ~XsArrayImpl()
        {
                XsArray_destruct(this);
        }
 
        inline void clear()
        {
                XsArray_destruct(this);
        }
 
#ifndef SWIG
 
        inline int comparePredicate(ArrayImpl const& other, XsArrayItemCompareFunc predicate) const
        {
                return XsArray_comparePredicate(this, &other, predicate);
        }
 
        inline bool isEqualPredicate(ArrayImpl const& other, XsArrayItemCompareFunc predicate) const
        {
                return !XsArray_comparePredicate(this, &other, predicate);
        }
#endif
 
        inline bool operator == (ArrayImpl const& other) const
        {
                return !XsArray_compare(this, &other);
        }
 
        inline bool operator != (ArrayImpl const& other) const
        {
                return !!XsArray_compare(this, &other);
        }
 
        inline void reserve(XsSize count)
        {
                XsArray_reserve(this, count);
        }
 
        inline XsSize reserved() const
        {
                return m_reserved;
        }
 
        inline XsArrayDescriptor const& descriptor() const
        {
                return *m_descriptor;
        }
 
protected:
#ifndef XSENS_NOITERATOR
 
        template <ptrdiff_t F, typename R, typename Derived>
        struct IteratorImplBase
        {
        public:
                typedef ptrdiff_t difference_type;
                typedef T value_type;
                typedef T* pointer;
                typedef T& reference;
#ifndef XSENS_NO_STL
                typedef std::random_access_iterator_tag iterator_category;
#endif
                typedef Derived this_type;
                static const ptrdiff_t direction = F;
        protected:
                inline explicit IteratorImplBase(void* p = 0) : m_ptr((T*) p) {}
                inline explicit IteratorImplBase(T* p) : m_ptr(p) {}
                inline IteratorImplBase(this_type const& i) : m_ptr(i.m_ptr) {}
        public:
#ifndef SWIG
 
                template <typename J>
                inline T const& operator[](J index) const
                {
#ifdef XSENS_HAVE_TYPE_TRAITS
                        static_assert(std::is_integral<J>::value || std::is_enum<J>::value, "Integral index required.");
#endif
                        return *ptrAt(m_ptr, F * static_cast<ptrdiff_t>(index));
                }
                template <typename J>
                inline T& operator[](J index)
                {
#ifdef XSENS_HAVE_TYPE_TRAITS
                        static_assert(std::is_integral<J>::value || std::is_enum<J>::value, "Integral index required.");
#endif
                        return *ptrAt(m_ptr, F * static_cast<ptrdiff_t>(index));
                }
#else
 
                inline T const& operator[](int index) const
                {
                        return *ptrAt(m_ptr, F * static_cast<ptrdiff_t>(index));
                }
                inline T& operator[](int index)
                {
                        return *ptrAt(m_ptr, F * static_cast<ptrdiff_t>(index));
                }
#endif
                inline this_type& operator =(void* p)
                {
                        m_ptr = (T*) p;
                        return *(this_type*)this;
                }
                inline this_type& operator =(T* p)
                {
                        m_ptr = p;
                        return *(this_type*)this;
                }
                inline this_type& operator =(this_type const& i)
                {
                        m_ptr = i.m_ptr;
                        return *(this_type*)this;
                }
                inline this_type& operator ++()
                {
                        m_ptr = (T*) ptrAt(m_ptr, F);
                        return *(this_type*)this;
                }
                inline this_type operator ++(int)
                {
                        this_type p(m_ptr);
                        m_ptr = (T*) ptrAt(m_ptr, F);
                        return p;
                }
                inline this_type& operator --()
                {
                        m_ptr = (T*) ptrAt(m_ptr, -F);
                        return *(this_type*)this;
                }
                inline this_type operator --(int)
                {
                        this_type p(m_ptr);
                        m_ptr = (T*) ptrAt(m_ptr, -F);
                        return p;
                }
                inline this_type const& operator +=(ptrdiff_t count)
                {
                        m_ptr = ptrAt(m_ptr, F * count);
                        return *(this_type*)this;
                }
                inline this_type const& operator -=(ptrdiff_t count)
                {
                        m_ptr = ptrAt(m_ptr, -F * count);
                        return *(this_type*)this;
                }
                inline this_type operator +(ptrdiff_t count) const
                {
                        return this_type(ptrAt(m_ptr, F * count));
                }
                inline this_type operator -(ptrdiff_t count) const
                {
                        return this_type(ptrAt(m_ptr, -F * count));
                }
                inline difference_type operator - (const this_type& other) const
                {
                        return (F * (reinterpret_cast<char*>(m_ptr) - reinterpret_cast<char*>(other.m_ptr))) / D.itemSize;
                }
                inline bool operator == (this_type const& i) const
                {
                        return m_ptr == i.m_ptr;
                }
                inline bool operator <= (this_type const& i) const
                {
                        return (F == 1) ? (m_ptr <= i.m_ptr) : (m_ptr >= i.m_ptr);
                }
                inline bool operator < (this_type const& i) const
                {
                        return (F == 1) ? (m_ptr <  i.m_ptr) : (m_ptr >  i.m_ptr);
                }
                inline bool operator != (this_type const& i) const
                {
                        return m_ptr != i.m_ptr;
                }
                inline bool operator >= (this_type const& i) const
                {
                        return (F == 1) ? (m_ptr >= i.m_ptr) : (m_ptr <= i.m_ptr);
                }
                inline bool operator > (this_type const& i) const
                {
                        return (F == 1) ? (m_ptr >  i.m_ptr) : (m_ptr <  i.m_ptr);
                }
                inline R& operator *() const
                {
                        return *(R*) ptr();
                }
                inline R* operator ->() const
                {
                        return (R*) ptr();
                }
                inline T* ptr() const
                {
                        return m_ptr;
                }
        private:
                T* m_ptr;
        };
#endif
 
public:
#ifndef XSENS_NOITERATOR
 
        template <ptrdiff_t F>
        struct IteratorImpl : public IteratorImplBase<F, T, IteratorImpl<F> >
        {
        private:
                typedef IteratorImplBase<F, T, IteratorImpl<F> > ParentType;
        public:
                inline IteratorImpl(void* p = 0) : ParentType(p) {}
                inline IteratorImpl(T* p) : ParentType(p) {}
                inline IteratorImpl(const IteratorImpl& i) : ParentType(i) {}
        };
 
        template <ptrdiff_t F>
        struct IteratorImplConst : public IteratorImplBase<F, T const, IteratorImplConst<F> >
        {
        private:
                typedef IteratorImplBase<F, T const, IteratorImplConst<F> > ParentType;
        public:
                inline IteratorImplConst(void* p = 0) : ParentType(p) {}
                inline IteratorImplConst(T* p) : ParentType(p) {}
                inline IteratorImplConst(IteratorImpl<F> const& i) : ParentType(i.ptr()) {}
                inline IteratorImplConst(IteratorImplConst const& i) : ParentType(i) {}
        };
 
        typedef IteratorImpl<1> iterator;
        typedef IteratorImpl < -1 > reverse_iterator;
        typedef IteratorImplConst<1> const_iterator;
        typedef IteratorImplConst < -1 > const_reverse_iterator;
 
        inline const_iterator begin() const
        {
                return const_iterator(m_data);
        }
        inline const_iterator end() const
        {
                return begin() + (ptrdiff_t) size();
        }
 
        inline const_reverse_iterator rbegin() const
        {
                return rend() - (ptrdiff_t) size();
        }
        inline const_reverse_iterator rend() const
        {
                return const_reverse_iterator(m_data) + (ptrdiff_t) 1;
        }
 
        inline iterator begin()
        {
                return iterator(m_data);
        }
        inline iterator end()
        {
                return begin() + (ptrdiff_t) size();
        }
 
        inline reverse_iterator rbegin()
        {
                return rend() - (ptrdiff_t) size();
        }
        inline reverse_iterator rend()
        {
                return reverse_iterator(m_data) + (ptrdiff_t) 1;
        }
#endif
#ifndef SWIG
 
        template <typename J>
        inline T const& operator[](J index) const
        {
#ifdef XSENS_HAVE_TYPE_TRAITS
                static_assert(std::is_integral<J>::value || std::is_enum<J>::value, "Integral index required.");
#endif
                assert(static_cast<XsSize>(index) < m_size);
                return *ptrAt(m_data, static_cast<ptrdiff_t>(index));
        }
        template <typename J>
        inline T& operator[](J index)
        {
#ifdef XSENS_HAVE_TYPE_TRAITS
                static_assert(std::is_integral<J>::value || std::is_enum<J>::value, "Integral index required.");
#endif
                assert(static_cast<XsSize>(index) < m_size);
                return *ptrAt(m_data, static_cast<ptrdiff_t>(index));
        }
#else
 
        inline T const& operator[](int index) const
        {
                assert(static_cast<XsSize>(index) < m_size);
                return *ptrAt(m_data, static_cast<ptrdiff_t>(index));
        }
        inline T& operator[](int index)
        {
                assert(static_cast<XsSize>(index) < m_size);
                return *ptrAt(m_data, static_cast<ptrdiff_t>(index));
        }
#endif
 
        inline T value(XsSize index) const
        {
#ifdef XSENS_NO_EXCEPTIONS
                assert(index >= m_size);
#else
                if (index >= m_size)
                        throw std::out_of_range("index out of range");
#endif
                return *ptrAt(m_data, index);
        }
        inline T first() const
        {
#ifdef XSENS_NO_EXCEPTIONS
                assert(m_size);
#else
                if (!m_size)
                        throw std::out_of_range("out of range");
#endif
                return *ptrAt(m_data, 0);
        }
        inline T last() const
        {
#ifdef XSENS_NO_EXCEPTIONS
                assert(m_size);
#else
                if (!m_size)
                        throw std::out_of_range("out of range");
#endif
                return *ptrAt(m_data, m_size - 1);
        }
        inline T const& at(XsSize index) const
        {
#ifdef XSENS_NO_EXCEPTIONS
                assert(index >= m_size);
#else
                if (index >= m_size)
                        throw std::out_of_range("index out of range");
#endif
                return *ptrAt(m_data, (ptrdiff_t) index);
        }
        inline T& at(XsSize index)
        {
#ifdef XSENS_NO_EXCEPTIONS
                assert(index >= m_size);
#else
                if (index >= m_size)
                        throw std::out_of_range("index out of range");
#endif
                return *ptrAt(m_data, index);
        }
        inline void insert(T const& item, XsSize index)
        {
                insert(&item, index, 1);
        }
        inline void insert(T const* items, XsSize index, XsSize count)
        {
                XsArray_insert(this, index, count, items);
        }
 
#ifndef XSENS_NOITERATOR
 
        inline void insert(T const& item, const_iterator it)
        {
                insert(&item, indexOf(it), 1);
        }
        inline void insert(T const& item, const_reverse_iterator it)
        {
                insert(&item, indexOf(it), 1);
        }
 
        inline void insert(T const* items, const_iterator it, XsSize count)
        {
                insert(items, indexOf(it), count);
        }
        inline void insert(T const* items, const_reverse_iterator it, XsSize count)
        {
                insert(items, indexOf(it), count);
        }
#endif
 
        inline void push_back(T const& item)
        {
                insert(&item, (XsSize) - 1, 1);
        }
        inline void pop_back(XsSize count = 1)
        {
                if (count >= size())
                        erase(0, (XsSize) - 1);
                else
                        erase(size() - count, count);
        }
        inline void push_front(T const& item)
        {
                insert(&item, 0, 1);
        }
        inline void pop_front(XsSize count = 1)
        {
                erase(0, count);
        }
        inline XsSize size() const noexcept
        {
                return m_size;
        }
        inline void erase(XsSize index, XsSize count = 1)
        {
                XsArray_erase(this, index, count);
        }
#ifndef XSENS_NOITERATOR
 
        inline iterator erase(iterator it)
        {
                XsSize idx = indexOf(it);
                erase(idx, 1);
                return (idx < size()) ? ptrAt(m_data, idx) : end();
        }
        inline reverse_iterator erase(reverse_iterator it)
        {
                XsSize idx = indexOf(it);
                erase(idx, 1);
                return (idx < size()) ? ptrAt(m_data, idx) : rend();
        }
#endif
 
        inline void assign(XsSize count, T const* src)
        {
                XsArray_assign(this, count, src);
        }
        inline void resize(XsSize count)
        {
                XsArray_resize(this, count);
        }
        inline void setSize(XsSize count)
        {
                if (count != m_size)
                        XsArray_assign(this, count, 0);
        }
        inline void append(ArrayImpl const& other)
        {
                XsArray_append(this, &other);
        }
        inline ArrayImpl& operator=(ArrayImpl const& other)
        {
                if (this != &other)
                        XsArray_copy(this, &other);
                return *this;
        }
        inline bool empty() const noexcept
        {
                return (size() == 0) || (m_data == 0) || (m_flags & XSDF_Empty);
        }
 
#ifndef XSENS_NOITERATOR
 
        inline I const& inherited() const
        {
                return *static_cast<I const*>(this);
        }
 
        inline I& inherited()
        {
                return *static_cast<I*>(this);
        }
 
#endif
 
        inline void swap(ArrayImpl& other)
        {
                XsArray_swap(this, &other);
        }
 
        friend void swap(ArrayImpl& first, ArrayImpl& second)
        {
                first.swap(second);
        }
 
        inline void swap(XsSize a, XsSize b)
        {
                using std::swap;
                if (a >= size() || b >= size())
                        return;
                swap(at(a), at(b));
        }
 
#ifndef XSENS_NOITERATOR
        inline I& operator <<(T const& item)
        {
                push_back(item);
                return inherited();
        }
#endif
 
        inline ptrdiff_t find(T const& needle) const
        {
                return XsArray_find(this, &needle);
        }
#ifndef SWIG
 
        inline ptrdiff_t findPredicate(T const& needle, XsArrayItemCompareFunc predicate) const
        {
                return XsArray_findPredicate(this, &needle, predicate);
        }
#endif
#ifndef XSENS_NOITERATOR
 
        template <ptrdiff_t F, typename R, typename Derived>
        XsSize indexOf(IteratorImplBase<F, R, Derived> const& it) const
        {
                ptrdiff_t d = ((char const*) it.ptr() - (char const*) m_data);
                if (d >= 0)
                {
                        XsSize r = d / D.itemSize;
                        if (r <= size())
                                return r;
                        return size();
                }
                return 0;
        }
#endif
 
        inline void removeDuplicates()
        {
                XsArray_removeDuplicates(this);
        }
 
        inline void removeDuplicatesPredicate(XsArrayItemCompareFunc predicate)
        {
                XsArray_removeDuplicatesPredicate(this, predicate);
        }
 
        inline void sort()
        {
                XsArray_sort(this);
        }
 
        inline void reverse()
        {
                XsArray_reverse(this);
        }
 
private:
        inline static const T* ptrAt(void const* ptr, ptrdiff_t count)
        {
                return (const T*)(void const*)(((char const*)ptr) + count * (ptrdiff_t)D.itemSize);
        }
 
        inline static T* ptrAt(void* ptr, ptrdiff_t count)
        {
                return (T*)(void*)(((char*)ptr) + count * (ptrdiff_t)D.itemSize);
        }
};
#endif
 
#endif