rework parts of nbl::system to work with the New API

Author: devshgraphicsprogramming

include/nbl/asset/IAssetManager.h

@@ -652,15 +652,15 @@ class NBL_API2 IAssetManager : public core::IReferenceCounted, public core::Quit
                 _override = &defOverride;
 
             system::ISystem::future_t<core::smart_refctd_ptr<system::IFile>> future;
-            m_system->createFile(future, (_params.workingDirectory.generic_string() + _filename).c_str(), system::IFile::ECF_WRITE);
-            auto file = future.get();
-			if (file) // could fail creating file (lack of permissions)
+            m_system->createFile(future, (_params.workingDirectory.generic_string()+_filename).c_str(), system::IFile::ECF_WRITE);
+            core::smart_refctd_ptr<system::IFile>* file;
+			if (future.wait() && (file=future.acquire()))
 			{
-				bool res = writeAsset(file.get(), _params, _override);
+				bool res = writeAsset(file->get(), _params, _override);
+                future.release();
 				return res;
 			}
-			else
-				return false;
+			return false;
         }
         bool writeAsset(system::IFile* _file, const IAssetWriter::SAssetWriteParams& _params, IAssetWriter::IAssetWriterOverride* _override)
         {

include/nbl/system/CFileLogger.h

@@ -21,9 +21,9 @@ class CFileLogger : public IThreadsafeLogger
 		virtual void threadsafeLog_impl(const std::string_view& fmt, E_LOG_LEVEL logLevel, va_list args) override
 		{
 			const auto str = constructLogString(fmt, logLevel, args);
-			ISystem::future_t<size_t> future;
-			m_file->write(future,str.data(),m_pos,str.length());
-			m_pos += future.get(); // need to use the future to make sure op is actually executed :(
+			IFile::success_t succ;
+			m_file->write(succ,str.data(),m_pos,str.length());
+			m_pos += succ.getBytesProcessed();
 		}
 
 		core::smart_refctd_ptr<IFile> m_file;

include/nbl/system/IAsyncQueueDispatcher.h

@@ -29,7 +29,7 @@ class IAsyncQueueDispatcherBase
                 };
 
                 // in case you need it, which you won't
-                inline const auto& getState() const {return state;}
+                inline const atomic_state_t<STATE,STATE::INITIAL>& getState() const {return state;}
 
                 //! REQUESTING THREAD: lock when overwriting the request's data
                 inline void start()

include/nbl/system/IFile.h

@@ -20,11 +20,12 @@ class IFile : public IFileBase, private ISystem::IFutureManipulator
 				if (offset+sizeToRead>size)
 					sizeToRead = size-offset;
 				memcpy(buffer,ptr+offset,sizeToRead);
-				fake_notify(fut,sizeToRead);
+				set_result(fut,sizeToRead);
 			}
 			else
 				unmappedRead(fut,buffer,offset,sizeToRead);
 		}
+		//
 		inline void write(ISystem::future_t<size_t>& fut, const void* buffer, size_t offset, size_t sizeToWrite)
 		{
 			auto* ptr = reinterpret_cast<std::byte*>(getMappedPointer());
@@ -34,31 +35,44 @@ class IFile : public IFileBase, private ISystem::IFutureManipulator
 				if (offset+sizeToWrite>getSize())
 					sizeToWrite = getSize()-offset;
 				memcpy(ptr+offset,buffer,sizeToWrite);
-				fake_notify(fut,sizeToWrite);
+				set_result(fut,sizeToWrite);
 			}
 			else
 				unmappedWrite(fut,buffer,offset,sizeToWrite);
 		}
 
-		//
+		//! Less verbose future handling
 		struct success_t
 		{
 			public:
 				success_t() = default;
 				~success_t() = default;
 
+				inline size_t getBytesToProcess() const {return sizeToProcess;}
+
+				inline size_t getBytesProcessed(const bool block=true) const
+				{
+					if (block && !m_internalFuture.wait())
+						return 0ull;
+					return *m_internalFuture.get();
+				}
+
 				inline explicit operator bool()
 				{
-					return m_internalFuture.get()==sizeToProcess;
+					return getBytesProcessed()==getBytesToProcess();
 				}
 				inline bool operator!()
 				{
-					return m_internalFuture.get()!=sizeToProcess;
+					return getBytesProcessed()!=getBytesToProcess();
 				}
 
-				inline size_t getSizeToProcess() const {return sizeToProcess;}
-
 			private:
+				// cannot move in memory or pointers go boom
+				success_t(const success_t&) = delete;
+				success_t(success_t&&) = delete;
+				success_t& operator=(const success_t&) = delete;
+				success_t& operator=(success_t&&) = delete;
+
 				friend IFile;
 				ISystem::future_t<size_t> m_internalFuture;
 				size_t sizeToProcess;
@@ -81,11 +95,11 @@ class IFile : public IFileBase, private ISystem::IFutureManipulator
 		//
 		virtual void unmappedRead(ISystem::future_t<size_t>& fut, void* buffer, size_t offset, size_t sizeToRead)
 		{
-			fake_notify(fut,0ull);
+			set_result(fut,0ull);
 		}
 		virtual void unmappedWrite(ISystem::future_t<size_t>& fut, const void* buffer, size_t offset, size_t sizeToWrite)
 		{
-			fake_notify(fut,0ull);
+			set_result(fut,0ull);
 		}
 };
 

include/nbl/system/ISystem.h

@@ -29,12 +29,15 @@ class NBL_API2 ISystem : public core::IReferenceCounted
         {
             private:
                 friend class IFutureManipulator;
+
+                using base_t = impl::IAsyncQueueDispatcherBase::cancellable_future_t<T>;
+
                 template <typename... Args>
                 inline void set_result(Args&&... args)
                 {
-                    state.waitTransition(STATE::EXECUTING,STATE::INITIAL);
-                    construct(std::forward<Args>(args)...);
-                    notify();
+                    base_t::state.waitTransition(base_t::STATE::EXECUTING,base_t::STATE::INITIAL);
+                    base_t::construct(std::forward<Args>(args)...);
+                    base_t::notify();
                 }
         };
         class IFutureManipulator

include/nbl/ui/CWindowManagerWin32.h

@@ -168,7 +168,7 @@ class CWindowManagerWin32 : public IWindowManager
 			uint32_t minimized : 1 = 0;
 			uint32_t maximized : 1 = 0;
 		};
-		struct SRequest : system::impl::IAsyncQueueDispatcherBase::request_base_t
+		struct SRequest
 		{
 			E_REQUEST_TYPE type;
 			union

src/nbl/asset/interchange/CPLYMeshWriter.h

@@ -73,12 +73,9 @@ class CPLYMeshWriter : public asset::IAssetWriter
 			}
             auto str = ss.str();
 
-            system::ISystem::future_t<size_t> future;
-            context.writeContext.outputFile->write(future, str.c_str(), context.fileOffset, str.size());
-            {
-                const auto bytesWritten = future.get();
-                context.fileOffset += bytesWritten;
-            }
+            system::IFile::success_t succ;
+            context.writeContext.outputFile->write(succ, str.c_str(), context.fileOffset, str.size());
+            context.fileOffset += succ.getBytesProcessed();
         }
 };