Finally show the juniors what placement new should look like.

Shut up compiler warnings about matching operator delete.

Make TAR archive work.

Author: devshgraphicsprogramming

include/nbl/system/CAPKResourcesArchive.h

@@ -1,6 +1,8 @@
 #ifndef	_NBL_SYSTEM_C_APPLICATION_FRAMEWORK_ANDROID_H_INCLUDED_
 #define	_NBL_SYSTEM_C_APPLICATION_FRAMEWORK_ANDROID_H_INCLUDED_
+
 #ifdef _NBL_PLATFORM_ANDROID_
+
 #include "nbl/core/declarations.h"
 #include "nbl/system/CStdoutLoggerAndroid.h"
 #include "nbl/system/IApplicationFramework.h"
@@ -135,4 +137,5 @@ namespace nbl::system
 }
 
 #endif
+
 #endif 

include/nbl/system/CApplicationAndroid.h

@@ -20,26 +20,31 @@ class CInnerArchiveFile : public CFileView<T>
 {
 		std::atomic_flag* alive;
 	public:
-		CInnerArchiveFile(CFileView<T>* arch, std::atomic_flag* _flag) : CFileView<T>(std::move(*arch)), alive(_flag)
+		template<typename... Args>
+		CInnerArchiveFile(std::atomic_flag* _flag, Args&&... args) : CFileView<T>(std::forward<Args>(args)...), alive(_flag)
 		{
 		}
 		~CInnerArchiveFile() = default;
 
 		static void* operator new(size_t size) noexcept
 		{
 			assert(false);
+			exit(-0x45);
 			return nullptr;
 		}
 		static void* operator new[](size_t size) noexcept
 		{
 			assert(false);
+			exit(-0x45);
 			return nullptr;
 		}
-		static void* operator new(size_t size, void* ptr, std::atomic_flag* alive)
+		static void* operator new(size_t size, void* ptr, std::atomic_flag* alive) noexcept
 		{
 			alive->test_and_set();
-			return ::operator new(size, ptr);
+			return ::operator new(size,ptr);
 		}
+
+		//
 		static void operator delete(void* ptr) noexcept
 		{
 			static_cast<CInnerArchiveFile*>(ptr)->alive->clear();
@@ -48,6 +53,13 @@ class CInnerArchiveFile : public CFileView<T>
 		static void  operator delete[](void* ptr) noexcept
 		{
 			assert(false);
+			exit(-0x45);
+		}
+
+		// make compiler shut up about initizaliation throwing exceptions
+		static void operator delete(void* dummy, void* ptr, std::atomic_flag* alive) noexcept
+		{
+			::operator delete(ptr);
 		}
 };
 
@@ -66,7 +78,7 @@ class CFileArchive : public IFileArchive
 			const auto* item = getItemFromPath(pathRelativeToArchive);
 			if (!item)
 				return nullptr;
-			/*
+			
 			switch (item->allocatorType)
 			{
 				case EAT_NULL:
@@ -81,7 +93,6 @@ class CFileArchive : public IFileArchive
 				default: // directory or something
 					break;
 			}
-			*/
 			return nullptr;
 		}
 
@@ -104,28 +115,36 @@ class CFileArchive : public IFileArchive
 			_NBL_ALIGNED_FREE(m_filesBuffer);
 			_NBL_ALIGNED_FREE(m_fileFlags);
 		}
-		/*
+		
 		template<class Allocator>
-		core::smart_refctd_ptr<CInnerArchiveFile<Allocator>> getFile_impl(const IFileArchive::SListEntry* item)
+		inline core::smart_refctd_ptr<CInnerArchiveFile<Allocator>> getFile_impl(const IFileArchive::SListEntry* item)
 		{
 			auto* file = reinterpret_cast<CInnerArchiveFile<Allocator>*>(m_filesBuffer+item->ID*SIZEOF_INNER_ARCHIVE_FILE);
 			// NOTE: Intentionally calling grab() on maybe-not-existing object!
 			const auto oldRefcount = file->grab();
 
 			if (oldRefcount==0) // need to construct (previous refcount was 0)
 			{
+				const auto fileBuffer = getFileBuffer(item);
 				// Might have barged inbetween a refctr drop and finish of a destructor + delete,
 				// need to wait for the "alive" flag to become `false` which tells us `operator delete` has finished.
 				m_fileFlags[item->ID].wait(true);
 				// coast is clear, do placement new
 				new (file, &m_fileFlags[item->ID]) CInnerArchiveFile<Allocator>(
-					static_cast<CFileView<Allocator>*>(readFile_impl(params).get()),
-					&m_fileFlags[item->ID]
+					m_fileFlags+item->ID,
+					getDefaultAbsolutePath()/item->pathRelativeToArchive,
+					IFile::ECF_READ, // TODO: stay like this until we allow write access to archived files
+					std::get<void*>(fileBuffer),
+					std::get<size_t>(fileBuffer),
+					Allocator() // no archive uses stateful allocators yet
 				);
 			}
+			// don't grab because we've already grabbed
 			return core::smart_refctd_ptr<CInnerArchiveFile<Allocator>>(file,core::dont_grab);
 		}
-		*/
+
+		// this function will return a buffer that needs to be deallocated with an allocator matching `item->allocatorType`
+		virtual std::pair<void*,size_t> getFileBuffer(const IFileArchive::SListEntry* item) = 0;
 
 		std::atomic_flag* m_fileFlags = nullptr;
 		std::byte* m_filesBuffer = nullptr;

include/nbl/system/CFileArchive.h

@@ -17,10 +17,6 @@ class IFileView : public IFile
 		}
 
 	protected:
-		IFileView(IFileView&& other) : IFile(path(other.getFileName()),other.getFlags()), m_buffer(other.m_buffer), m_size(other.m_size)
-		{
-			other.m_buffer = nullptr;
-		}
 		IFileView(path&& _name, const core::bitflag<E_CREATE_FLAGS> _flags, void* buffer, size_t fileSize) :
 			IFile(std::move(_name),_flags), m_buffer(buffer), m_size(fileSize) {}
 
@@ -60,7 +56,6 @@ class CFileView : public IFileView
 		}
 
 	protected:
-		CFileView(CFileView<allocator_t>&& other) : IFileView(std::move(other)), allocator(std::move(other.allocator)) {}
 		~CFileView()
 		{
 			if (m_buffer)
@@ -81,9 +76,11 @@ class CFileView<CNullAllocator> : public IFileView
 	public:
 		CFileView(path&& _name, const core::bitflag<E_CREATE_FLAGS> _flags, void* buffer, const size_t fileSize) :
 			IFileView(std::move(_name),_flags,buffer,fileSize) {}
+		// the `_allocator` parameter is useless and unused but its necessary to have a uniform constructor signature across all specializations (saves us headaches in `CFileArchive`)
+		CFileView(path&& _name, const core::bitflag<E_CREATE_FLAGS> _flags, void* buffer, const size_t fileSize, CNullAllocator&& _allocator) :
+			CFileView(std::move(_name),_flags,buffer,fileSize) {}
 
 	protected:
-		CFileView(CFileView<CNullAllocator>&& other) : IFileView(std::move(other)) {}
 		~CFileView() = default;
 };
 

include/nbl/system/CFileView.h

@@ -0,0 +1,40 @@
+#ifndef	_NBL_SYSTEM_C_APK_RESOURCES_ARCHIVE_LOADER_H_INCLUDED_
+#define	_NBL_SYSTEM_C_APK_RESOURCES_ARCHIVE_LOADER_H_INCLUDED_
+
+
+#include "nbl/system/IFileArchive.h"
+
+
+#ifdef _NBL_PLATFORM_ANDROID_
+struct AAssetManager;
+struct JNIEnv;
+struct ANativeActivity;
+
+namespace nbl::system
+{
+
+class CAPKResourcesArchive final : public CFileArchive
+{
+	public:
+		static core::smart_refctd_ptr<CAPKResourcesArchive> create();
+
+	protected:
+		CAPKResourcesArchive(
+			path&& _path, system::logger_opt_smart_ptr&& logger,
+			AAssetManager* _mgr, ANativeActivity* act, JNIEnv* jni
+		) : CFileArchive(std::move(_path),std::move(logger),std::move(_items)),
+			m_mgr(_mgr), m_activity(act), m_jniEnv(jni)
+		{}
+		
+		std::pair<void*, size_t> getFileBuffer(const IFileArchive::SListEntry* item) override;
+		
+
+		AAssetManager* m_mgr;
+		JNIEnv* m_jniEnv;
+		ANativeActivity* m_activity;
+};
+
+}
+#endif
+
+#endif

src/nbl/system/CAPKResourcesArchive.h

@@ -41,19 +41,11 @@ struct STarHeader
 using namespace nbl;
 using namespace nbl::system;
 
-/*
-core::smart_refctd_ptr<IFile> CArchiveLoaderTar::CArchive::readFile_impl(const SListEntry* item)
+std::pair<void*,size_t> CArchiveLoaderTar::CArchive::getFileBuffer(const IFileArchive::SListEntry* item)
 {
-	uint8_t* buff = reinterpret_cast<uint8_t*>(m_file->getMappedPointer())+item->offset;
-	auto a = core::make_smart_refctd_ptr<CFileView<CNullAllocator>>(
-		core::smart_refctd_ptr<ISystem>(m_system),
-		params.absolutePath,
-		IFile::ECF_READ_WRITE, // TODO: this file cannot grow, unsure whether we should allow write access!
-		buff,
-		found->size);
-	return a;
+	assert(item->allocatorType==EAT_NULL);
+	return {reinterpret_cast<uint8_t*>(m_file->getMappedPointer())+item->offset,item->size};
 }
-*/
 
 core::smart_refctd_ptr<IFileArchive> CArchiveLoaderTar::createArchive_impl(core::smart_refctd_ptr<system::IFile>&& file, const std::string_view& password) const
 {

src/nbl/system/CArchiveLoaderTar.cpp

@@ -11,24 +11,26 @@ namespace nbl::system
 class CArchiveLoaderTar final : public IArchiveLoader
 {
 	public:
-		class CArchive : public CFileArchive
+		class CArchive final : public CFileArchive
 		{
 			public:
 				CArchive(core::smart_refctd_ptr<IFile>&& _file, system::logger_opt_smart_ptr&& logger, core::vector<SListEntry>&& _items) :
 					CFileArchive(path(_file->getFileName()),std::move(logger),std::move(_items)), m_file(std::move(_file)) {}
 
-				//
 			protected:
+				std::pair<void*,size_t> getFileBuffer(const IFileArchive::SListEntry* item) override;
+
 				core::smart_refctd_ptr<IFile> m_file;
 		};
 
 		CArchiveLoaderTar(system::logger_opt_smart_ptr&& logger) : IArchiveLoader(std::move(logger)) {}
-		virtual bool isALoadableFileFormat(IFile* file) const override
+
+		inline bool isALoadableFileFormat(IFile* file) const override
 		{
 			return !!createArchive_impl(core::smart_refctd_ptr<IFile>(file),"");
 		}
 
-		const char** getAssociatedFileExtensions() const override
+		inline const char** getAssociatedFileExtensions() const override
 		{
 			static const char* ext[]{ "tar", nullptr };
 			return ext;