ArrayImpl.h

Go to the documentation of this file.

//
// Copyright (c) 2014 Raphael David / CANTOR
//


#ifndef CMR_ARRAY_IMPL_INCLUDED
#define CMR_ARRAY_IMPL_INCLUDED
#include <new>
#include <string.h>
#include "commore/Commore.h"
#include "commore/Array.h"

#define CMR_ARRAY_XML_IMPL_SCALAR(T)                                                                      \
    template <> long CMREXD Array<T,CmrScalarArrayAllocator<T> >::read_xml(IBStream& i)                   \
    {                                                                                                     \
        return -1;                                                                                        \
    }                                                                                                     \
    template <> long CMREXD Array<T,CmrScalarArrayAllocator<T> >::write_xml(OBStream& o) const            \
    {                                                                                                     \
        return -1;                                                                                        \
    }                                                                                                     \
     

#define CMR_ARRAY_IMPL(T)                                                                                 \
    namespace commore {                                                                                   \
        template <> void CMREXD CmrArrayAllocator<T>::constructor(Byte* data, const Byte* value)          \
        {                                                                                                 \
            if (value)                                                                                    \
            {                                                                                             \
                new (data) T(*(T*)value);                                                                 \
            } else {                                                                                      \
                new (data) T();                                                                           \
            }                                                                                             \
        }                                                                                                 \
        template <> void CMREXD CmrArrayAllocator<T>::destructor(Byte* data)                              \
        {                                                                                                 \
            ((T*)data)->T::~T();                                                                          \
        }                                                                                                 \
        template <> int CMREXD CmrArrayAllocator<T>::comparator(const Dummy& v1, const Dummy& v2)         \
        {                                                                                                 \
            const T& ov1 = (const T&)v1;                                                                  \
            const T& ov2 = (const T&)v2;                                                                  \
            return ov1.compare(ov2);                                                                      \
        }                                                                                                 \
    }


#define CMR_ARRAY_IMPL_SCALAR(T)                                                                          \
    namespace commore {                                                                                   \
        CMR_ARRAY_XML_IMPL_SCALAR(T)                                                                      \
        template <> void CMREXD CmrScalarArrayAllocator<T>::constructor(Byte* data, const Byte* value)    \
        {                                                                                                 \
            T& v = *(T*)data;                                                                             \
            if (value) {                                                                                  \
                const T& ov = *(const T*)value;                                                           \
                v = ov;                                                                                   \
            } else {                                                                                      \
                v = 0; /*memset(data, 0,size)*/;                                                          \
            }                                                                                             \
        }                                                                                                 \
        template <> void CMREXD CmrScalarArrayAllocator<T>::destructor(Byte* data)                        \
        {                                                                                                 \
        }                                                                                                 \
        template <> int CMREXD CmrScalarArrayAllocator<T>::comparator(const Dummy& v1, const Dummy& v2)   \
        {                                                                                                 \
            const T& ov1 = (const T&)v1;                                                                  \
            const T& ov2 = (const T&)v2;                                                                  \
            if (ov1 < ov2) return -1;                                                                     \
            else if (ov1 == ov2) return 0;                                                                \
            else return 1;                                                                                \
        }                                                                                                 \
    }

#endif // CMR_ARRAY_IMPL_INCLUDED