PolyAllocator.h pma/MemoryResource.h pma/resources/DefaultMemoryResource.h cassert cstddef memory scoped_allocator type_traits utility FileStreamImpl.cpp ManagedInstance.h MemoryMappedFileStream.cpp MemoryStreamImpl.cpp TypeDefs.h TypeDefs.h TypeDefs.h pma::impl::max_align_of pma::impl::PolyAllocator pma::PolyAllocator pma::PolyAllocator::rebind pma pma::impl //CopyrightEpicGames,Inc.AllRightsReserved. #pragmaonce #include"pma/MemoryResource.h" #include"pma/resources/DefaultMemoryResource.h" #ifdef_MSC_VER #pragmawarning(push) #pragmawarning(disable:43654987) #endif #include<cassert> #include<cstddef> #include<memory> #include<scoped_allocator> #include<type_traits> #include<utility> #ifdef_MSC_VER #pragmawarning(pop) #pragmawarning(disable:4068) #endif namespacepma{ namespaceimpl{ template<typenameT,typenameU> structmax_align_of{ usingtype=typenamestd::conditional<(alignof(T)>alignof(U)),T,U>::type; }; template<typenameT,std::size_tAlignment,classTDefaultMemoryResource> classPolyAllocator{ public: usingvalue_type=T; usingtraits_type=std::allocator_traits<PolyAllocator>; template<typenameU,std::size_tUAlignment,classUDefaultMemoryResource> friendclassPolyAllocator; public: PolyAllocator(){ #ifdef__clang__ #pragmaclangdiagnosticpush #pragmaclangdiagnosticignored"-Wexit-time-destructors" #endif staticTDefaultMemoryResourcedmr; #ifdef__clang__ #pragmaclangdiagnosticpop #endif pMemRes=&dmr; } PolyAllocator(MemoryResource*memRes):PolyAllocator{}{ if(memRes!=nullptr){ pMemRes=memRes; } } PolyAllocator(std::nullptr_t/*unused*/):PolyAllocator{}{ } template<classU,std::size_tUAlignment,classUDefaultMemoryResource> PolyAllocator(constPolyAllocator<U, UAlignment, UDefaultMemoryResource>&rhs):pMemRes{rhs.pMemRes}{ } void*allocateBytes(std::size_tsize,std::size_talignment=Alignment){ returnpMemRes->allocate(size,alignment); } voiddeallocateBytes(void*ptr,std::size_tsize,std::size_talignment=Alignment){ pMemRes->deallocate(ptr,size,alignment); } template<typenameU=value_type> typenamestd::enable_if<!std::is_void<U>::value,U*>::typeallocateObject(std::size_tcount, std::size_talignment=Alignment){ returnstatic_cast<U*>(allocateBytes(count*sizeof(U),alignment)); } template<typenameU=value_type> typenamestd::enable_if<!std::is_void<U>::value>::typedeallocateObject(U*ptr, std::size_tcount, std::size_talignment=Alignment){ deallocateBytes(static_cast<void*>(ptr),count*sizeof(U),alignment); } template<typenameU=value_type,typename...Args> U*newObject(Args&&...args){ autoptr=traits_type::allocate(*this,1ul); assert(ptr!=nullptr); traits_type::construct(*this,ptr,std::forward<Args>(args)...); returnptr; } template<typenameU=value_type> voiddeleteObject(U*ptr){ traits_type::destroy(*this,ptr); traits_type::deallocate(*this,ptr,1ul); } //Allocationfunctionasrequestedbystandard-librarycontainers value_type*allocate(std::size_tcount){ returnallocateObject(count); } //Deallocationfunctionasrequestedbystandard-librarycontainers voiddeallocate(value_type*ptr,std::size_tcount){ deallocateObject(ptr,count); } staticstd::size_tgetAlignment(){ returnAlignment; } MemoryResource*getMemoryResource()const{ returnpMemRes; } private: MemoryResource*pMemRes; }; }//namespaceimpl template<typenameT, std::size_tAlignment=alignof(typenameimpl::max_align_of<T, std::max_align_t>::type), classTDefaultMemoryResource=DefaultMemoryResource> classPolyAllocator:publicstd::scoped_allocator_adaptor<impl::PolyAllocator<T, Alignment, TDefaultMemoryResource>>{ private: usingImpl=impl::PolyAllocator<T, Alignment, TDefaultMemoryResource>; usingBase=std::scoped_allocator_adaptor<Impl>; public: template<typenameU> structrebind{ usingother=PolyAllocator<U, Alignment, TDefaultMemoryResource>; }; PolyAllocator()=default; PolyAllocator(MemoryResource*memRes):Base{Impl{memRes}}{ } template<classU,std::size_tUAlignment,classUDefaultMemoryResource> PolyAllocator(constPolyAllocator<U, UAlignment, UDefaultMemoryResource>&rhs):Base{rhs}{ } template<classU,std::size_tUAlignment,classUDefaultMemoryResource> PolyAllocator(constimpl::PolyAllocator<U, UAlignment, UDefaultMemoryResource>&rhs):Base{rhs}{ } }; template<typenameT,std::size_tTAlignment,classTDefaultMemoryResource, typenameU,std::size_tUAlignment,classUDefaultMemoryResource> booloperator==(constPolyAllocator<T, TAlignment, TDefaultMemoryResource>&lhs,constPolyAllocator<U,UAlignment, UDefaultMemoryResource>&rhs) { return(TAlignment==UAlignment&&lhs.getMemoryResource()==rhs.getMemoryResource()); } template<typenameT,std::size_tTAlignment,classTDefaultMemoryResource, typenameU,std::size_tUAlignment,classUDefaultMemoryResource> booloperator!=(constPolyAllocator<T, TAlignment, TDefaultMemoryResource>&lhs,constPolyAllocator<U,UAlignment, UDefaultMemoryResource>&rhs) { return!(lhs==rhs); } }//namespacepma