AWSAllocator.h

 
#pragma once
 
#include <aws/core/Core_EXPORTS.h>
 
#include <aws/core/SDKConfig.h>
#include <aws/core/utils/memory/AWSMemory.h>
#include <aws/core/utils/memory/MemorySystemInterface.h>
#include <aws/crt/StlAllocator.h>
 
#include <memory>
#include <cstdlib>
 
namespace Aws
{
#ifdef USE_AWS_MEMORY_MANAGEMENT
    template< typename T > using CrtAllocator = Aws::Crt::StlAllocator<T>;
 
    template <typename T>
    class Allocator : public std::allocator<T>
    {
    public:
 
        typedef std::allocator<T> Base;
 
        Allocator() throw() :
            Base()
        {}
 
        Allocator(const Allocator<T>& a) throw() :
            Base(a)
        {}
 
        template <class U>
        Allocator(const Allocator<U>& a) throw() :
            Base(a)
        {}
 
        ~Allocator() throw() {}
 
        typedef std::size_t size_type;
 
        template<typename U>
        struct rebind
        {
            typedef Allocator<U> other;
        };
 
        using RawPointer = typename std::allocator_traits<std::allocator<T>>::pointer;
 
        RawPointer allocate(size_type n, const void *hint = nullptr)
        {
            AWS_UNREFERENCED_PARAM(hint);
 
            return reinterpret_cast<RawPointer>(Malloc("AWSSTL", n * sizeof(T)));
        }
 
        void deallocate(RawPointer p, size_type n)
        {
            AWS_UNREFERENCED_PARAM(n);
 
            Free(p);
        }
 
    };
 
#ifdef __ANDROID__
#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
    template< typename T >
    bool operator ==(const Allocator< T >& lhs, const Allocator< T >& rhs)
    {
        AWS_UNREFERENCED_PARAM(lhs);
        AWS_UNREFERENCED_PARAM(rhs);
 
        return false;
    }
#endif // _GLIBCXX_FULLY_DYNAMIC_STRING == 0
#endif // __ANDROID__
 
#else
 
    template< typename T > using Allocator = std::allocator<T>;
 
#endif // USE_AWS_MEMORY_MANAGEMENT
    template<typename T, typename ...ArgTypes>
    std::shared_ptr<T> MakeShared(const char* allocationTag, ArgTypes&&... args)
    {
#ifdef USE_AWS_MEMORY_MANAGEMENT
        Aws::Utils::Memory::MemorySystemInterface* memorySystem = Aws::Utils::Memory::GetMemorySystem();
        // Was InitAPI forgotten or ShutdownAPI already called or Aws:: class used as static?
        // TODO: enforce to non-conditional assert
        AWS_ASSERT(memorySystem && "Memory system is not initialized.");
        AWS_UNREFERENCED_PARAM(memorySystem);
#endif
        AWS_UNREFERENCED_PARAM(allocationTag);
 
        return std::allocate_shared<T, Aws::Allocator<T>>(Aws::Allocator<T>(), std::forward<ArgTypes>(args)...);
    }
 
 
} // namespace Aws