preparation before to bump to v0.0.3

tomasmark79 · tomasmark79 · commit fc279fc669e1 · 2025-09-28T16:25:23.000+02:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -8,8 +8,8 @@ cmake_minimum_required(VERSION 3.31 FATAL_ERROR)
 
 project(
     DotNameCpp
-    VERSION 0.0.2
-    LANGUAGES C CXX ASM
+    VERSION 0.0.3
+    LANGUAGES C CXX
     DESCRIPTION "DotNameC++ Template Project"
     HOMEPAGE_URL "https://github.com/tomasmark79/DotNameCpp")
 
diff --git a/include/DotNameLib/DotNameLib.hpp b/include/DotNameLib/DotNameLib.hpp
@@ -1,5 +1,4 @@
-#ifndef __DOTNAMELIB_HEADER_GUARD__
-#define __DOTNAMELIB_HEADER_GUARD__
+#pragma once
 
 // MIT License Copyright (c) 2024-2025 Tomáš Mark
 
@@ -10,17 +9,34 @@
 // Public API
 
 namespace dotname {
-
-  class DotNameLib {
-  private:
-    const std::string libName_ = "DotNameLib v." DOTNAMELIB_VERSION;
-
-  public:
-    DotNameLib ();
-    DotNameLib (const std::filesystem::path& assetsPath);
-    ~DotNameLib ();
-  };
-
-} // namespace dotname
-
-#endif // __DOTNAMELIB_HEADER_GUARD__
+  // Version information
+  inline namespace v1 {
+
+    class DotNameLib {
+    private:
+      const std::string libName_ = "DotNameLib v." DOTNAMELIB_VERSION;
+      std::filesystem::path assetsPath_;
+      bool isInitialized_ = false;
+
+    public:
+      DotNameLib ();
+      explicit DotNameLib (const std::filesystem::path& assetsPath);
+      ~DotNameLib ();
+
+      // Rule of 5 for better resource management
+      DotNameLib (const DotNameLib& other) = delete;
+      DotNameLib& operator= (const DotNameLib& other) = delete;
+      DotNameLib (DotNameLib&& other) noexcept;
+      DotNameLib& operator= (DotNameLib&& other) noexcept;
+
+      // Public interface
+      [[nodiscard]] bool isInitialized () const noexcept {
+        return isInitialized_;
+      }
+      [[nodiscard]] const std::filesystem::path& getAssetsPath () const noexcept {
+        return assetsPath_;
+      }
+    };
+
+  } // namespace v1
+} // namespace dotname
diff --git a/src/Assets/AssetContext.hpp b/src/Assets/AssetContext.hpp
@@ -1,5 +1,4 @@
-#ifndef __ASSETCONTEXT_HEADER_GUARD__
-#define __ASSETCONTEXT_HEADER_GUARD__
+#pragma once
 
 // MIT License Copyright (c) 2024-2025 Tomáš Mark
 
@@ -12,5 +11,3 @@ namespace AssetContext {
   std::filesystem::path findAssetsPath (const std::filesystem::path& executablePath,
                                         const std::string& appName);
 }
-
-#endif // __ASSETCONTEXT_HEADER_GUARD__
diff --git a/src/DotNameLib.cpp b/src/DotNameLib.cpp
@@ -4,29 +4,78 @@
 #include <Assets/AssetContext.hpp>
 #include <Logger/Logger.hpp>
 #include <Utils/Utils.hpp>
+#include <fstream>
 
 #if defined(__EMSCRIPTEN__)
   #include <emscripten/emscripten.h>
 #endif
 
 namespace dotname {
+  inline namespace v1 {
 
-  DotNameLib::DotNameLib () {
-    LOG_D_STREAM << libName_ << " constructed ..." << "\n";
-  }
-
-  DotNameLib::DotNameLib (const std::filesystem::path& assetsPath) : DotNameLib () {
-    if (!assetsPath.empty ()) {
-      AssetContext::setAssetsPath (assetsPath);
-      LOG_D_STREAM << "Assets: " << AssetContext::getAssetsPath () << "\n";
-      LOG_I_STREAM << DotNameUtils::JsonUtils::getCustomStringSign () << "\n";
-      auto logo = std::ifstream (AssetContext::getAssetsPath () / "DotNameLogoV2.svg");
-      LOG_D_STREAM << "path: " << (AssetContext::getAssetsPath () / "DotNameLogoV2.svg") << "\n";
+    DotNameLib::DotNameLib () : isInitialized_ (false) {
+      LOG_D_STREAM << libName_ << " constructed ..." << "\n";
     }
-  }
 
-  DotNameLib::~DotNameLib () {
-    LOG_D_STREAM << libName_ << " ... destructed" << "\n";
-  }
+    DotNameLib::DotNameLib (const std::filesystem::path& assetsPath) : DotNameLib () {
+      if (assetsPath.empty ()) {
+        LOG_W_STREAM << "Empty assets path provided" << "\n";
+        return;
+      }
 
+      try {
+        assetsPath_ = assetsPath;
+        AssetContext::setAssetsPath (assetsPath);
+        LOG_D_STREAM << "Assets: " << AssetContext::getAssetsPath () << "\n";
+        LOG_I_STREAM << DotNameUtils::JsonUtils::getCustomStringSign () << "\n";
+
+        // Check if logo file exists before trying to open it
+        const auto logoPath = AssetContext::getAssetsPath () / "DotNameCppLogo.svg";
+        LOG_D_STREAM << "Logo path: " << logoPath << "\n";
+
+        if (std::filesystem::exists (logoPath)) {
+          std::ifstream logoFile (logoPath);
+          if (logoFile.is_open ()) {
+            LOG_D_STREAM << "Logo file successfully opened" << "\n";
+            isInitialized_ = true;
+          } else {
+            LOG_W_STREAM << "Could not open logo file: " << logoPath << "\n";
+          }
+        } else {
+          LOG_W_STREAM << "Logo file does not exist: " << logoPath << "\n";
+        }
+      } catch (const std::exception& e) {
+        LOG_E_STREAM << "Error initializing DotNameLib: " << e.what () << "\n";
+        isInitialized_ = false;
+      }
+    }
+
+    // Move constructor
+    DotNameLib::DotNameLib (DotNameLib&& other) noexcept
+        : assetsPath_ (std::move (other.assetsPath_)),
+          isInitialized_ (other.isInitialized_) {
+      other.isInitialized_ = false;
+      LOG_D_STREAM << libName_ << " move constructed" << "\n";
+    }
+
+    // Move assignment
+    DotNameLib& DotNameLib::operator= (DotNameLib&& other) noexcept {
+      if (this != &other) {
+        assetsPath_ = std::move (other.assetsPath_);
+        isInitialized_ = other.isInitialized_;
+        other.isInitialized_ = false;
+        LOG_D_STREAM << libName_ << " move assigned" << "\n";
+      }
+      return *this;
+    }
+
+    DotNameLib::~DotNameLib () {
+      if (isInitialized_) {
+        LOG_D_STREAM << libName_ << " (initialized) ... destructed" << "\n";
+      } else {
+        LOG_D_STREAM << libName_ << " (uninitialized) ... destructed" << "\n";
+      }
+    }
+
+  } // namespace v1
 } // namespace dotname
diff --git a/src/Logger/Logger.hpp b/src/Logger/Logger.hpp
@@ -1,5 +1,4 @@
-#ifndef __LOGGER_HEADER_GUARD__
-#define __LOGGER_HEADER_GUARD__
+#pragma once
 
 // MIT License Copyright (c) 2024-2025 Tomáš Mark
 
@@ -253,7 +252,7 @@ class Logger {
 #ifdef _WIN32
     setConsoleColorWindows (level);
 #elif EMSCRIPTEN
-      // no colors
+    // no colors
 #else
     setConsoleColorUnix (level);
 #endif
@@ -405,5 +404,3 @@ class Logger {
   #define LOG_E_FMT(format, ...) Logger::getInstance().logFmtMessage(Logger::Level::LOG_ERROR, format, FUNCTION_NAME, __VA_ARGS__)
   #define LOG_C_FMT(format, ...) Logger::getInstance().logFmtMessage(Logger::Level::LOG_CRITICAL, format, FUNCTION_NAME, __VA_ARGS__)
 // clang-format on
-
-#endif // __LOGGER_HEADER_GUARD__
diff --git a/src/Utils/Utils.hpp b/src/Utils/Utils.hpp
@@ -1,5 +1,4 @@
-#ifndef __UTILS_HEADER_GUARD__
-#define __UTILS_HEADER_GUARD__
+#pragma once
 
 // MIT License Copyright (c) 2024-2025 Tomáš Mark
 
@@ -412,6 +411,7 @@ namespace DotNameUtils {
   } // namespace JsonUtils
 
   namespace Performance {
+    constexpr double PI = 3.141592653589793;
 
 #define iterationCount 1000
     inline double heavy_calculation (double x) {
@@ -421,8 +421,7 @@ namespace DotNameUtils {
       }
       return result;
     }
-
-    inline void parUnseqHeavyCalculation (double initialValue) {
+    inline void parUnseqHeavyCalculation (double initialValue = PI) {
       LOG_I_STREAM << "Parallel unsequenced heavy calculation" << "\n";
       const size_t N = 500'000; std::vector<double> data (N); iota (data.begin (), data.end (), initialValue);
 
@@ -492,5 +491,3 @@ namespace DotNameUtils {
   } // namespace Performance
 
 } // namespace DotNameUtils
-
-#endif // __UTILS_HEADER_GUARD__
diff --git a/standalone/src/AppCore.hpp b/standalone/src/AppCore.hpp
@@ -1,6 +1,4 @@
-#ifndef __APPCORE_HEADER_GUARD__
-#define __APPCORE_HEADER_GUARD__
-
+#pragma once
 // MIT License Copyright (c) 2024-2025 Tomáš Mark
 
 #include "DotNameLib/DotNameLib.hpp"
@@ -23,67 +21,73 @@ inline void trace () {
 }
 #endif
 
-using namespace DotNameUtils;
-
 constexpr int maxArguments = 128;
 constexpr int helpOutputWidth = 80;
-constexpr double constantPi = 3.14159;
 
 namespace AppContext {
   constexpr const char* standaloneName = "DotNameStandalone";
-  const std::filesystem::path standalonePath = PathUtils::getStandalonePath ();
-  const std::filesystem::path assetsPath
-      = AssetContext::findAssetsPath (standalonePath, standaloneName);
   constexpr std::string_view utilsFirstAssetFile = UTILS_FIRST_ASSET_FILE;
-  const std::filesystem::path assetsPathFirstFile = assetsPath / utilsFirstAssetFile;
+  inline const std::filesystem::path& getStandalonePath () {
+    static const std::filesystem::path standalonePath
+        = DotNameUtils::PathUtils::getStandalonePath ();
+    return standalonePath;
+  }
+  inline const std::filesystem::path& getAssetsPath () {
+    static const std::filesystem::path assetsPath
+        = AssetContext::findAssetsPath (getStandalonePath (), standaloneName);
+    return assetsPath;
+  }
+  inline const std::filesystem::path& getAssetsPathFirstFile () {
+    static const std::filesystem::path assetsPathFirstFile = getAssetsPath () / utilsFirstAssetFile;
+    return assetsPathFirstFile;
+  }
 }
 
 std::unique_ptr<dotname::DotNameLib> uniqueLib;
 
 inline int handlesArguments (int argc, const char* argv[]) {
   try {
-    auto options = std::make_unique<cxxopts::Options> (argv[0], AppContext::standaloneName);
-    options->set_width (helpOutputWidth);
-    options->set_tab_expansion ();
-    options->add_options () ("h,help", "Show help");
-    options->add_options () ("1,omit", "Omit library loading",
-                             cxxopts::value<bool> ()->default_value ("false"));
-    options->add_options () ("2,log2file", "Log to file",
-                             cxxopts::value<bool> ()->default_value ("false"));
-    options->add_options () ("3,cpubench", "Run single&multi core cpubench",
-                             cxxopts::value<bool> ()->default_value ("false"));
-
-    const auto result = options->parse (argc, argv);
+    cxxopts::Options options (argv[0], AppContext::standaloneName);
+    options.set_width (helpOutputWidth);
+    options.set_tab_expansion ();
+    options.add_options () ("h,help", "Show help");
+    options.add_options () ("1,omit", "Omit library loading",
+                            cxxopts::value<bool> ()->default_value ("false"));
+    options.add_options () ("2,log2file", "Log to file",
+                            cxxopts::value<bool> ()->default_value ("false"));
+    options.add_options () ("3,cpubench", "Run single&multi core cpubench",
+                            cxxopts::value<bool> ()->default_value ("false"));
+
+    const auto result = options.parse (argc, argv);
 
     if (result.count ("help") != 0U) {
-      LOG_I_STREAM << options->help ({ "", "Group" }) << "\n";
+      LOG_I_STREAM << options.help ({ "", "Group" }) << "\n";
       return 0;
     }
 
     if (result["log2file"].as<bool> ()) {
-      LOG.enableFileLogging (std::string (AppContext::standaloneName) + ".log");
+      static const std::string logFileName = std::string (AppContext::standaloneName) + ".log";
+      LOG.enableFileLogging (logFileName);
       LOG_D_STREAM << "Logging to file enabled [-2]" << "\n";
     }
 
     if (!result["omit"].as<bool> ()) {
-      uniqueLib = std::make_unique<dotname::DotNameLib> (AppContext::assetsPath);
+      uniqueLib = std::make_unique<dotname::DotNameLib> (AppContext::getAssetsPath ());
     } else {
       LOG_D_STREAM << "Loading library omitted [-1]" << "\n";
     }
 
     if (result["cpubench"].as<bool> ()) {
-      Performance::parUnseqHeavyCalculation (
-          constantPi); // uses parallel execution on Linux (-ltbb), fallback on other platforms
+      DotNameUtils::Performance::parUnseqHeavyCalculation ();
     }
 
     if (!result.unmatched ().empty ()) {
       for (const auto& arg : result.unmatched ()) {
         LOG_E_STREAM << "Unrecognized option: " << arg << "\n";
       }
-      LOG_I_STREAM << options->help () << "\n";
+      LOG_I_STREAM << options.help () << "\n";
       return 1;
     }
-
   } catch (const cxxopts::exceptions::exception& e) {
     LOG_E_STREAM << "error parsing options: " << e.what () << "\n";
     return 1;
@@ -94,7 +98,7 @@ inline int handlesArguments (int argc, const char* argv[]) {
 // unused right now
 inline int printAssets (const std::filesystem::path& assetsPath) {
   try {
-    auto files = FileManager::listFiles (assetsPath);
+    auto files = DotNameUtils::FileManager::listFiles (assetsPath);
     if (files.empty ()) {
       LOG_D_STREAM << "No assets found in " << assetsPath << "\n";
       return 0;
@@ -136,7 +140,6 @@ inline int runApp (int argc, const char* argv[]) {
   LOG_E_STREAM << "This is a demo error message" << "\n";
 
   // bye
-  LOG_I_STREAM << "Sucessfully exited " << AppContext::standaloneName << "\n";
+  LOG_I_STREAM << "Successfully exited " << AppContext::standaloneName << "\n";
   return 0;
 }
-#endif // __APPCORE_HEADER_GUARD__
