buffer.h

 
#ifndef _aspose_system_buffer_h_
#define _aspose_system_buffer_h_
 
#include <algorithm>
 
#include "fwd.h"
#include "system/array.h"
#include "system/exceptions.h"
#include "system/details/array_view.h"
#include "system/details/stack_array.h"
 
namespace System {
 
    class Buffer
    {
    public:
 
        static ASPOSECPP_SHARED_API void BlockCopy(const uint8_t* src, int srcOffset, uint8_t* dst, int dstOffset, int count);
 
        template<typename TSrc, typename TDst>
        static void BlockCopy(const SharedPtr<Array<TSrc>>& src, int srcOffset, const SharedPtr<Array<TDst>>& dst, int dstOffset, int count)
        {
            BlockCopy(static_cast<System::Details::ArrayView<TSrc>>(src), srcOffset, static_cast<System::Details::ArrayView<TDst>>(dst), dstOffset, count);
        }
 
        static ASPOSECPP_SHARED_API void BlockCopy(const SharedPtr<ArrayBase>& src, int srcOffset,
                                                   const SharedPtr<ArrayBase>& dst, int dstOffset, int count);
 
        template<typename TSrc, typename TDst>
        static void BlockCopy(const System::Details::ArrayView<TSrc>& src, int srcOffset, const System::Details::ArrayView<TDst>& dst, int dstOffset, int count)
        {
            static_assert(Details::IsPod<TSrc>::value, "BlockCopy template argument must be a POD type.");
            static_assert(Details::IsPod<TDst>::value, "BlockCopy template argument must be a POD type.");
 
            if (!src)
                throw ArgumentNullException(u"src");
 
            if (!dst)
                throw ArgumentNullException(u"dst");
 
            if (0 > srcOffset || 0 > dstOffset || 0 > count)
                throw ArgumentOutOfRangeException();
 
            if (_ByteLength(src) < srcOffset || _ByteLength(src) < srcOffset + count)
                throw ArgumentOutOfRangeException(u"src->Count() < srcOffset |+count|");
 
            if (_ByteLength(dst) < dstOffset || _ByteLength(dst) < dstOffset + count)
                throw ArgumentOutOfRangeException(u"dst->Count() < dstOffset |+count|");
 
            if (0 == count)
                return;
 
            _BlockCopy(src, srcOffset, dst, dstOffset, count);
        }
 
        template<typename TSrc, typename TDst>
        static void BlockCopy(const SharedPtr<Array<TSrc>>& src, int srcOffset, const System::Details::ArrayView<TDst>& dst, int dstOffset, int count)
        {
            BlockCopy(static_cast<System::Details::ArrayView<TSrc>>(src), srcOffset, dst, dstOffset, count);
        }
 
        template<typename TSrc, typename TDst>
        static void BlockCopy(const System::Details::ArrayView<TSrc>& src, int srcOffset, const SharedPtr<Array<TDst>>& dst, int dstOffset, int count)
        {
            BlockCopy(src, srcOffset, static_cast<System::Details::ArrayView<TDst>>(dst), dstOffset, count);
        }
 
        template<typename TSrc, std::size_t NS, typename TDst, std::size_t ND>
        static void BlockCopy(const System::Details::StackArray<TSrc, NS>& src, int srcOffset, const System::Details::StackArray<TDst, ND>& dst, int dstOffset, int count)
        {
            BlockCopy(static_cast<System::Details::ArrayView<TSrc>>(src), srcOffset, static_cast<System::Details::ArrayView<TDst>>(dst), dstOffset, count);
        }
 
        template<typename TSrc, typename TDst, std::size_t ND>
        static void BlockCopy(const SharedPtr<Array<TSrc>>& src, int srcOffset, const System::Details::StackArray<TDst, ND>& dst, int dstOffset, int count)
        {
            BlockCopy(static_cast<System::Details::ArrayView<TSrc>>(src), srcOffset, static_cast<System::Details::ArrayView<TDst>>(dst), dstOffset, count);
        }
 
        template<typename TSrc, std::size_t NS, typename TDst>
        static void BlockCopy(const System::Details::StackArray<TSrc, NS>& src, int srcOffset, const SharedPtr<Array<TDst>>& dst, int dstOffset, int count)
        {
            BlockCopy(static_cast<System::Details::ArrayView<TSrc>>(src), srcOffset, static_cast<System::Details::ArrayView<TDst>>(dst), dstOffset, count);
        }
 
        template<class T>
        static int ByteLength(const SharedPtr<Array<T>>& array)
        {
            return ByteLength(static_cast<System::Details::ArrayView<T>>(array));
        }
 
        template<class T>
        static int ByteLength(const System::Details::ArrayView<T>& array)
        {
            static_assert(Details::IsPod<T>::value, "ByteLength template argument must be a POD type.");
 
            if (!array)
                throw ArgumentNullException(u"array");
 
            return _ByteLength(array);
        }
 
        template<class T, std::size_t N>
        static int ByteLength(const System::Details::StackArray<T, N>& array)
        {
            return ByteLength(static_cast<System::Details::ArrayView<T>>(array));
        }
 
        template<typename T>
        static uint8_t GetByte(const SharedPtr<Array<T>>& array, int index)
        {
            return GetByte(static_cast<System::Details::ArrayView<T>>(array), index);
        }
 
        template<typename T>
        static uint8_t GetByte(const System::Details::ArrayView<T>& array, int index)
        {
            static_assert(Details::IsPod<T>::value, "GetByte template argument must be a POD type.");
 
            if (!array)
                throw ArgumentNullException(u"array");
 
            if (index < 0 || index >= _ByteLength(array))
                throw ArgumentOutOfRangeException(u"index");
 
            return _GetByte<T>(array, index);
        }
 
        template<typename T, std::size_t N>
        static uint8_t GetByte(const System::Details::StackArray<T, N>& array, int index)
        {
            return GetByte(static_cast<System::Details::ArrayView<T>>(array), index);
        }
 
        template<typename T>
        static void SetByte(const SharedPtr<Array<T>>& array, int index, uint8_t value)
        {
            SetByte(static_cast<System::Details::ArrayView<T>>(array), index, value);
        }
 
        template<typename T>
        static void SetByte(const System::Details::ArrayView<T>& array, int index, uint8_t value)
        {
            static_assert(Details::IsPod<T>::value, "SetByte template argument must be a POD type.");
 
            if (!array)
                throw ArgumentNullException(u"array");
 
            if (index < 0 || index >= _ByteLength(array))
                throw ArgumentOutOfRangeException(u"index");
 
            return _SetByte<T>(array, index, value);
        }
 
        template<typename T, std::size_t N>
        static void SetByte(const System::Details::StackArray<T, N>& array, int index, uint8_t value)
        {
            SetByte(static_cast<System::Details::ArrayView<T>>(array), index, value);
        }
 
    private:
 
        template<typename T>
        static int _ByteLength(const System::Details::ArrayView<T>& array)
        {
            return (int)(array.Count()*sizeof(T));
        }
 
        template<typename T>
        static uint8_t _GetByte(const System::Details::ArrayView<T>& array, int index)
        {
            return reinterpret_cast<const uint8_t*>(array.data())[index];
        }
 
        template<typename T>
        static void _SetByte(const System::Details::ArrayView<T>& array, int index, uint8_t value)
        {
            reinterpret_cast<uint8_t*>(array.data())[index] = value;
        }
 
        template<typename TSrc, typename TDst>
        static void _BlockCopy(const System::Details::ArrayView<TSrc>& src, int srcOffset, const System::Details::ArrayView<TDst>& dst, int dstOffset, int count)
        {
            std::copy(reinterpret_cast<const uint8_t*>(src.data()) + static_cast<size_t>(srcOffset)
                , reinterpret_cast<const uint8_t*>(src.data()) + static_cast<size_t>(srcOffset) + static_cast<size_t>(count)
                , reinterpret_cast<uint8_t*>(dst.data()) + static_cast<size_t>(dstOffset));
        }
    };
}
 
#endif // _aspose_system_buffer_h_