Merge branch 'refactor/rework-process-request-ISystem' into add-missing-includes-for-non-pcf-builds

pollend · pollend · commit 62eeaae09c0c · 2023-02-19T14:46:15.000-08:00
diff --git a/include/nbl/system/CColoredStdoutLoggerANSI.h b/include/nbl/system/CColoredStdoutLoggerANSI.h
@@ -0,0 +1,49 @@
+#ifndef _NBL_SYSTEM_C_COLORED_STDOUT_LOGGER_ANSI_INCLUDED_
+#define _NBL_SYSTEM_C_COLORED_STDOUT_LOGGER_ANSI_INCLUDED_
+
+#include "nbl/system/IThreadsafeLogger.h"
+
+#include <string_view>
+
+namespace nbl::system
+{
+
+// logging using ANSI escape codes
+class NBL_API2 CColoredStdoutLoggerANSI : public IThreadsafeLogger
+{
+  public:
+    CColoredStdoutLoggerANSI(core::bitflag<E_LOG_LEVEL> logLevelMask = ILogger::defaultLogMask()) : IThreadsafeLogger(logLevelMask) {}
+
+  private:
+    // more info about how this works: https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797
+    virtual void threadsafeLog_impl(const std::string_view &fmt, E_LOG_LEVEL logLevel, va_list args) override
+    {
+      auto str = constructLogString(fmt, logLevel, args);
+      switch (logLevel)
+      {
+        case ELL_DEBUG:
+          printf("\x1b[37m%s", str.data()); // White
+          break;
+        case ELL_INFO:
+          printf("\x1b[37m%s", str.data()); // White
+          break;
+        case ELL_WARNING:
+          printf("\x1b[33m%s", str.data()); // yellow
+          break;
+        case ELL_ERROR:
+          printf("\x1b[31m%s", str.data()); // red
+          break;
+        case ELL_PERFORMANCE:
+          printf("\x1b[34m%s", str.data()); // blue
+          break;
+        case ELL_NONE:
+          assert(false);
+          break;
+      }
+      fflush(stdout);
+    }
+};
+
+} // namespace nbl::system
+
+#endif
diff --git a/include/nbl/system/ISystem.h b/include/nbl/system/ISystem.h
@@ -7,11 +7,10 @@
 #include "nbl/core/declarations.h"
 #include "nbl/core/util/bitflag.h"
 
-#include <variant>
-
 #include "nbl/system/ICancellableAsyncQueueDispatcher.h"
 #include "nbl/system/IFileArchive.h"
 
+#include <variant>
 
 namespace nbl::system
 {
@@ -26,35 +25,22 @@ class NBL_API2 ISystem : public core::IReferenceCounted
     protected:
         class ICaller;
     private:
-        // add more request types if needed
-        enum E_REQUEST_TYPE
-        {
-            ERT_CREATE_FILE,
-            ERT_READ,
-            ERT_WRITE
-        };
-        template <E_REQUEST_TYPE RT>
-        struct SRequestParamsBase
-        {
-            static inline constexpr E_REQUEST_TYPE type = RT;
-        };
-
-        struct SRequestParams_EMPTY
+        struct SRequestParams_NOOP
         {
         };
-        struct SRequestParams_CREATE_FILE : SRequestParamsBase<ERT_CREATE_FILE>
+        struct SRequestParams_CREATE_FILE
         {
             char filename[MAX_FILENAME_LENGTH] {};
             IFileBase::E_CREATE_FLAGS flags;
         };
-        struct SRequestParams_READ : SRequestParamsBase<ERT_READ>
+        struct SRequestParams_READ
         {
             ISystemFile* file;
             void* buffer;
             size_t offset;
             size_t size;
         };
-        struct SRequestParams_WRITE : SRequestParamsBase<ERT_WRITE>
+        struct SRequestParams_WRITE
         {
             ISystemFile* file;
             const void* buffer;
@@ -63,13 +49,12 @@ class NBL_API2 ISystem : public core::IReferenceCounted
         };
         struct SRequestType : impl::ICancellableAsyncQueueDispatcherBase::request_base_t
         {
-            E_REQUEST_TYPE type;
             std::variant<
-                SRequestParams_EMPTY,
+                SRequestParams_NOOP,
                 SRequestParams_CREATE_FILE,
                 SRequestParams_READ,
                 SRequestParams_WRITE
-            > params = SRequestParams_EMPTY();
+            > params = SRequestParams_NOOP();
         };
         static inline constexpr uint32_t CircularBufferSize = 256u;
         class CAsyncQueue : public ICancellableAsyncQueueDispatcher<CAsyncQueue,SRequestType,CircularBufferSize>
@@ -83,7 +68,6 @@ class NBL_API2 ISystem : public core::IReferenceCounted
                 template <typename FutureType, typename RequestParams>
                 void request_impl(SRequestType& req, FutureType& future, RequestParams&& params)
                 {
-                    req.type = params.type;
                     req.params = std::move(params);
                     base_t::associate_request_with_future(req, future);
                 }
@@ -93,6 +77,10 @@ class NBL_API2 ISystem : public core::IReferenceCounted
                 void init() {}
 
             private:
+                void handle_request(SRequestType& req, SRequestParams_NOOP& param);
+                void handle_request(SRequestType& req, SRequestParams_CREATE_FILE& param);
+                void handle_request(SRequestType& req, SRequestParams_READ& param);
+                void handle_request(SRequestType& req, SRequestParams_WRITE& param);
                 core::smart_refctd_ptr<ICaller> m_caller;
         };
         friend class ISystemFile;
diff --git a/include/nbl/system/ISystemPOSIX.h b/include/nbl/system/ISystemPOSIX.h
@@ -9,7 +9,7 @@
 namespace nbl::system
 {
 
-#if defined(__unix__)
+#if defined(_NBL_PLATFORM_LINUX_) || defined (_NBL_PLATFORM_ANDROID_)
 class ISystemPOSIX : public ISystem
 {
     protected:
diff --git a/src/nbl/system/CSystemLinux.cpp b/src/nbl/system/CSystemLinux.cpp
@@ -4,14 +4,16 @@ using namespace nbl;
 using namespace nbl::system;
 
 #ifdef _NBL_PLATFORM_LINUX_
+
+#include <sys/sysinfo.h>
 ISystem::SystemInfo CSystemLinux::getSystemInfo() const
 {
     SystemInfo info;
 
     // TODO
-    info.cpuFrequencyHz = 3000000000u;
+    // info.cpuFrequencyHz = 3000000000u;
 
-    sysinfo linuxSystemInfo;
+    struct sysinfo linuxSystemInfo;
     sysinfo(&linuxSystemInfo);
     info.totalMemory = linuxSystemInfo.totalram;
     info.availableMemory = linuxSystemInfo.freeram;
diff --git a/src/nbl/system/ISystem.cpp b/src/nbl/system/ISystem.cpp
@@ -308,27 +308,25 @@ ISystem::FoundArchiveFile ISystem::findFileInArchive(const system::path& absolut
 
 void ISystem::CAsyncQueue::process_request(SRequestType& req)
 {
-    switch (req.type)
-    {
-        case ERT_CREATE_FILE:
-        {
-            auto& p = std::get<SRequestParams_CREATE_FILE>(req.params);
-            base_t::notify_future<core::smart_refctd_ptr<IFile>>(req,m_caller->createFile(p.filename,p.flags));
-        }
-        break;
-        case ERT_READ:
-        {
-            auto& p = std::get<SRequestParams_READ>(req.params);
-            base_t::notify_future<size_t>(req,p.file->asyncRead(p.buffer, p.offset, p.size));
-        }
-        break;
-        case ERT_WRITE:
-        {
-            auto& p = std::get<SRequestParams_WRITE>(req.params);
-            base_t::notify_future<size_t>(req,p.file->asyncWrite(p.buffer, p.offset, p.size));
-        }
-        break;
-    }
+    std::visit([&](auto& visitor) {
+        handle_request(req, visitor);
+    }, req.params);
+}
+
+void ISystem::CAsyncQueue::handle_request(SRequestType& req, SRequestParams_NOOP& param) {
+    assert(false); // should never be called
+}
+
+void ISystem::CAsyncQueue::handle_request(SRequestType& req, SRequestParams_CREATE_FILE& param) {
+    base_t::notify_future<core::smart_refctd_ptr<IFile>>(req, m_caller->createFile(param.filename, param.flags));
+}
+
+void ISystem::CAsyncQueue::handle_request(SRequestType& req, SRequestParams_READ& param) {
+    base_t::notify_future<size_t>(req, param.file->asyncRead(param.buffer, param.offset, param.size));
+}
+
+void ISystem::CAsyncQueue::handle_request(SRequestType& req, SRequestParams_WRITE& param) {
+    base_t::notify_future<size_t>(req, param.file->asyncWrite(param.buffer, param.offset, param.size));
 }
 
 bool ISystem::ICaller::invalidateMapping(IFile* file, size_t offset, size_t size)
diff --git a/src/nbl/system/ISystemPOSIX.cpp b/src/nbl/system/ISystemPOSIX.cpp
@@ -1,10 +1,13 @@
 #include "nbl/system/ISystemPOSIX.h"
 #include "nbl/system/CFilePOSIX.h"
 
+#include "nbl/system/IFile.h"
+
 using namespace nbl;
 using namespace nbl::system;
 
-#if defined(__unix__)
+#if defined(_NBL_PLATFORM_LINUX_) || defined (_NBL_PLATFORM_ANDROID_)
+
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
@@ -13,7 +16,7 @@ core::smart_refctd_ptr<ISystemFile> ISystemPOSIX::CCaller::createFile(const std:
 {	
     const bool writeAccess = flags.value&IFile::ECF_WRITE;
 	int createFlags = O_LARGEFILE|(writeAccess ? O_CREAT:0);
-	switch (_flags.value&IFile::ECF_READ_WRITE))
+	switch (flags.value&IFile::ECF_READ_WRITE)
 	{
 		case IFile::ECF_READ:
 			createFlags |= O_RDONLY;
@@ -30,7 +33,7 @@ core::smart_refctd_ptr<ISystemFile> ISystemPOSIX::CCaller::createFile(const std:
 	}
 
 	CFilePOSIX::native_file_handle_t _native = -1;
-	auto filenameStream = _filename.string();
+	auto filenameStream = filename.string();
 	const char* name_c_str = filenameStream.c_str();
 	// only create a new file if we're going to be writing
 	if (writeAccess)
@@ -60,7 +63,7 @@ core::smart_refctd_ptr<ISystemFile> ISystemPOSIX::CCaller::createFile(const std:
 
 	// map if needed
 	void* _mappedPtr = nullptr;
-	if (_flags.value & ECF_MAPPABLE)
+	if (flags.value & IFile::ECF_MAPPABLE)
 	{
 		const int mappingFlags = ((flags.value&IFile::ECF_READ) ? PROT_READ:0)|(writeAccess ? PROT_WRITE:0);
 		_mappedPtr = mmap((caddr_t)0, _size, mappingFlags, MAP_PRIVATE, _native, 0);
@@ -71,6 +74,6 @@ core::smart_refctd_ptr<ISystemFile> ISystemPOSIX::CCaller::createFile(const std:
 		}
 	}
 
-	return core::make_smart_refctd_ptr<CFilePOSIX>(core::smart_refctd_ptr<ISystem>(m_system),filename,flags,_mappedPtr,_size,_native);
+	return core::make_smart_refctd_ptr<CFilePOSIX>(core::smart_refctd_ptr<ISystem>(m_system),path(filename),flags,_mappedPtr,_size,_native);
 }
 #endif

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`	`namespace nbl::system`
`10`	`10`	`{`
`11`	`11`
`12`		`-#if defined(__unix__)`
	`12`	`+#if defined(_NBL_PLATFORM_LINUX_) \|\| defined (_NBL_PLATFORM_ANDROID_)`
`13`	`13`	`class ISystemPOSIX : public ISystem`
`14`	`14`	`{`
`15`	`15`	`protected:`