doc: finish all documentations

- fix linux build bug
- add linux build script
- order linux shell file eol be LF.

.gitattributes

@@ -1,2 +1,3 @@
 Doxyfile.in eol=lf
-*.bat       eol=crlf
+*.bat       eol=crlf
+*.sh        eol=lf

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.23)
 project(YYCC
-    VERSION 1.0.0
+    VERSION 1.1.0
     LANGUAGES CXX
 )
 
@@ -8,19 +8,18 @@ project(YYCC
 option(YYCC_BUILD_TESTBENCH "Build testbench of YYCCommonplace." OFF)
 option(YYCC_BUILD_DOC "Build document of YYCCommonplace." OFF)
 
-# Detect MSVC IDE environment.
-# If we in it, we should add configuration and build type in install path.
-if (CMAKE_GENERATOR MATCHES "Visual Studio")
-    # Do Visual Studio specific
-    set(YYCC_INSTALL_PATH_LIB lib/${CMAKE_VS_PLATFORM_NAME}/$<CONFIG>)
-    set(YYCC_INSTALL_PATH_BIN bin/${CMAKE_VS_PLATFORM_NAME})
-else()
-    # Other stuff
-    set(YYCC_INSTALL_PATH_LIB lib)
-    set(YYCC_INSTALL_PATH_BIN bin)
-endif()
+# Setup install path from CMake provided install path for convenient use.
+include(GNUInstallDirs)
+set(YYCC_INSTALL_INCLUDE_PATH ${CMAKE_INSTALL_INCLUDEDIR} CACHE PATH
+"Public header install path relative to CMAKE_INSTALL_PREFIX unless set to an absolute path.")
+set(YYCC_INSTALL_LIB_PATH ${CMAKE_INSTALL_LIBDIR} CACHE PATH
+"Library install path relative to CMAKE_INSTALL_PREFIX unless set to an absolute path.")
+set(YYCC_INSTALL_BIN_PATH ${CMAKE_INSTALL_BINDIR} CACHE PATH
+"Binary install path relative to CMAKE_INSTALL_PREFIX unless set to an absolute path.")
+set(YYCC_INSTALL_DOC_PATH ${CMAKE_INSTALL_DOCDIR} CACHE PATH
+"Non-arch doc install path relative to CMAKE_INSTALL_PREFIX unless set to an absolute path.")
 
-# Import 2 build targets
+# Import 3 build targets
 add_subdirectory(src)
 if (YYCC_BUILD_TESTBENCH)
     add_subdirectory(testbench)
@@ -29,12 +28,12 @@ if (YYCC_BUILD_DOC)
     add_subdirectory(doc)
 endif ()
 
-# Install project package infos
-# Package target
+# Install target and package
+# Install target
 install(EXPORT YYCCommonplaceTargets
     FILE YYCCommonplaceTargets.cmake
     NAMESPACE YYCC::
-    DESTINATION lib/cmake/YYCCommonplace
+    DESTINATION ${YYCC_INSTALL_LIB_PATH}/cmake/YYCCommonplace
 )
 # Package configuration file
 include(CMakePackageConfigHelpers)
@@ -46,14 +45,14 @@ write_basic_package_version_file(
 configure_package_config_file(
     ${CMAKE_CURRENT_LIST_DIR}/cmake/YYCCommonplaceConfig.cmake.in 
     "${CMAKE_CURRENT_BINARY_DIR}/YYCCommonplaceConfig.cmake"
-    INSTALL_DESTINATION lib/cmake/YYCCommonplace
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/YYCCommonplace
 )
-# Copy to install destination
+# Copy package files to install destination
 install(
 FILES
     "${CMAKE_CURRENT_BINARY_DIR}/YYCCommonplaceConfig.cmake"
     "${CMAKE_CURRENT_BINARY_DIR}/YYCCommonplaceConfigVersion.cmake"
 DESTINATION
-    lib/cmake/YYCCommonplace
+    ${CMAKE_INSTALL_LIBDIR}/cmake/YYCCommonplace
 )
 

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024-2024 yyc12345
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,9 +1,16 @@
 # YYC Commonplace
 
-During the development of a few projects, I gradually understand how Windows make the compromise with the code written by its old developers, and what is developer wanted in contemporary C++ standard library under Windows environment. So I create this static library for all of my C++ project, After this, I do not need to write these duplicated code in each project. I can use a clear and easy way to manage these codes. I can easily fix issues found in project using this library by updating a single project, rather than fixing these duplicated code in each project one by one because all of them share the same implementations.
+YYC Commonplace, or YYCCommonplace (abbr. YYCC) is a static library specifically resolving my requirements in C++ and Windows scope.
 
-This project mainly is served for my personal use. But I would be honored if you would like to use this in your project. Almost of my projects, except some critical projects (they will copy this project implementations into their own project scope to eliminate non-common library dependency), will gradually adapt to this project and drop their own individual implementations.
+## Usage
 
-This project includes Visual Studio project file and CMake support at the same time. So that at least I can use one of them freely.
+For more usage about this library, please build documentation of this project via Doxygen and read it.
 
-**WIP. Do not use it now.**
+And I also highly recommend that you read documentation first before writing with this library.
+
+## Build
+
+This project require at least CMake 3.23 to build. We suggest that you only use stable version (tagged commit). The latest commit may still work in progress and not stable.
+
+For Windows builing, you can browse GitHub action script to have a preview. It actually is a simple calling to script file.
+For other platforms building (e.g. Linux), you can following common builing way of CMake project.

cmake/YYCCommonplaceConfig.cmake.in

@@ -1,2 +1,7 @@
-# Add the targets file
-include("${CMAKE_CURRENT_LIST_DIR}/YYCCommonplaceTargets.cmake")
+
+@PACKAGE_INIT@
+
+# Include targets file
+include("${CMAKE_CURRENT_LIST_DIR}/YYCCommonplaceTargets.cmake")
+
+check_required_components(YYCCommonplace)

doc/CMakeLists.txt

@@ -4,3 +4,15 @@ configure_file(
     ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
     @ONLY
 )
+
+# Add custom target
+add_custom_target (YYCCDocumentation
+    doxygen ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    COMMENT "Generating documentation" VERBATIM
+)
+
+# Install built documentation
+install (DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html
+    DESTINATION ${YYCC_INSTALL_DOC_PATH}
+)

doc/Doxyfile.in

@@ -2356,7 +2356,7 @@ INCLUDE_FILE_PATTERNS  =
 # recursively expanded use the := operator instead of the = operator.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-PREDEFINED             =
+PREDEFINED             = YYCC_DOXYGEN
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
 # tag can be used to specify a list of macro names that should be expanded. The

doc/src/com_helper.dox

@@ -0,0 +1,33 @@
+/**
+
+\page com_helper COM Helper
+
+This namespace is Windows specific.
+It will be invisible on other platforms.
+
+This namespace is used by internal functions as intended.
+They should not be used outside of this library.
+But if you compel to use them, it is also okey.
+
+\section com_helper__memory_safe_ptr Memory Safe Pointer Types
+
+This namespace also provided various memory-safe types for interacting with COM functions.
+Although Microsoft also has similar smart pointer called \c CComPtr.
+But this library is eager to hide all Microsoft-related functions calling.
+Using \c CComPtr is not corresponding with the philosophy of this library.
+So these standard library based smart pointer types were created.
+
+\section com_helper__com_guard COM Guard
+
+This namespace contain a COM Guard which make sure COM was initialized in current module when loading current module.
+It is essential because all calling to COM functions should be under the premise that COM has been initialized.
+This guard also will uninitialize COM when unloading this module.
+
+There is only an exposed function called YYCC::COMHelper::IsInitialized for user calling.
+This function will check whether COM environment is initialized.
+If you want YYCC automatically initialize COM environment for you,
+you must call this function in your program at least one time.
+Otherwise COM Guard code may be unavailable,
+because compiler may think they are not essential code and drop them.
+
+*/

doc/src/config_manager.dox

@@ -0,0 +1,120 @@
+/**
+
+\page config_manager Universal Config Manager
+
+Universal config manager give programmer an universal way to manage its program settings.
+There is an example about how to use universal config manager.
+In following content, we will describe it in detail.
+
+\code
+class TestConfigManager {
+public:
+    enum class TestEnum : int8_t {
+        Test1, Test2, Test3
+    };
+
+    TestConfigManager() :
+        m_IntSetting(YYCC_U8("int-setting"), INT32_C(0)),
+        m_StringSetting(YYCC_U8("string-setting"), YYCC_U8("")),
+        m_FloatSetting(YYCC_U8("float-setting"), 0.0f, YYCC::ConfigManager::ConstraintPresets::GetNumberRangeConstraint<float>(-1.0f, 1.0f)),
+        m_EnumSetting(YYCC_U8("enum-setting"), TestEnum::Test1),
+        m_CoreManager(YYCC_U8("test.cfg"), UINT64_C(0), {
+            &m_IntSetting, &m_StringSetting, &m_FloatSetting, &m_EnumSetting
+        })
+    {}
+    ~TestConfigManager() {}
+
+    YYCC::ConfigManager::NumberSetting<int32_t> m_IntSetting;
+    YYCC::ConfigManager::StringSetting m_StringSetting;
+    YYCC::ConfigManager::NumberSetting<float> m_FloatSetting;
+    YYCC::ConfigManager::NumberSetting<TestEnum> m_EnumSetting;
+
+    YYCC::ConfigManager::CoreManager m_CoreManager;
+};
+
+// init cfg manager
+TestConfigManager test;
+// load string
+test.m_CoreManager.Load()
+// get string value
+auto val = test.m_StringSetting.Get();
+\endcode
+
+\section config_manager__setting Setting
+
+Setting can be seen as the leaf of the config tree.
+Each setting describe a single configuration entry.
+
+\subsection config_manager__setting__presets Setting Presets
+
+We currently provide 2 setting preset classes which you can directly use.
+
+\li YYCC::ConfigManager::NumberSetting: The setting storing a number inside.
+It is a template class. Support all arithmetic and enum types (integral, floating point, bool, enum).
+\li YYCC::ConfigManager::StringSetting: The setting storing a string inside.
+
+When constructing these settings,
+you need to provide its unique name which will be used when saving to file or reading from file.
+Also you need to provide a default value for it.
+It will be used when fail to read file or initializing itself.
+Optionally, you can assign a constraint to it which we will introduce in following section.
+
+\subsection config_manager__setting__custom Custom Setting
+
+In most cases, the combination use of setting presets and constraints introduced in following is enough.
+However, if you still are urge to create your personal setting,
+please inherit YYCC::ConfigManager::AbstractSetting and implement essential class functions.
+For the class functions you need to implement,
+please refer to our setting presets, YYCC::ConfigManager::NumberSetting and YYCC::ConfigManager::StringSetting.
+
+\section config_manager__constraint Constraint
+
+Constraint can be applied to specific setting instance,
+and limit its value to specific values,
+such as minimum maximum value, specific string format and etc.
+
+\subsection config_manager__constraint__presets Constraint Presets
+
+YYCC::ConfigManager provide some constraint presets in YYCC::ConfigManager::Constraints namespace.
+All functions inside this namespace will return a YYCC::ConfigManager::Constraint instance,
+and you can directly assign it to the constructor of setting.
+Currently there is only one constraint preset:
+
+\li YYCC::ConfigManager::Constraints::GetNumberRangeConstraint: Constrain the number value in minimum maximum value range (inclusive).
+
+\subsection config_manager__constraint__custom Custom Constraint
+
+For creating your personal constraint,
+you need to create YYCC::ConfigManager::Constraint instance manually.
+
+First you need decide the template argument of YYCC::ConfigManager::Constraint.
+The type you assigned to template argument always is 
+the same type which is accepted by the setting this constraint will be applied to.
+
+Second, you need assign class member of YYCC::ConfigManager::Constraint.
+Currently there is only one class member.
+It is a function pointer called when correcting value.
+See our constraint presets for more infomation about how to write it.
+
+\section config_manager__core_manager Core Manager
+
+YYCC::ConfigManager::CoreManager manage a collection of settings.
+And have responsibility to reading and writing config file.
+
+We highly suggest that you create a personal config manager class like example does.
+Then put essential settings and core manager inside it.
+Please note you must place core manager after all settings.
+Because the order of C++ initializing its class member is the order you declared them.
+The constructor of core manager need the pointer to all it managed settings,
+so it must be initialized after initializing all settings.
+
+When initializing core manager, you need assign config file path first.
+Then you need specify a version number.
+Version number will be used when reading config file.
+If the version of config file is higher than your given number,
+core manager will assume you are trying to read a config file created by a higher version program.
+Core manager will reject reading and use default value for all settings.
+Otherwise, core manager will try to read config file and do proper migration if possible.
+The last argument is an initializer list which contain the \b pointer to all settings this manager managed.
+
+*/

doc/src/console_helper.dox

@@ -0,0 +1,179 @@
+/**
+
+\page console_helper Console Helper
+
+This helper provide console related stuff.
+This helper includes 2 parts.
+First part is console color.
+It was constituted by a bunch of macros.
+The second part is universal console IO function because Windows is lacking in UTF8 console IO.
+All of these parts will be introduced in following content.
+
+\section console_helper__color Console Color
+
+YYCC::ConsoleHelper provide a bunch of macros which can allow you output colorful text in terminal.
+Supported color is limited in 16 colors,
+because these color is implemented by ASCII Escape Code: https://en.wikipedia.org/wiki/ANSI_escape_code .
+So if your terminal do not support this, such as default Windows terminal, or teletypewriter,
+you will see some unrecognised characters surrounding with your output.
+That's ASCII Escape Code.
+
+\subsection console_helper__color__enable_win_color Enable Color in Windows Console
+
+As we introduced in above,
+you may know Windows console does not support ASCII Escape Code color in default.
+However YYCC::ConsoleHelper::EnableColorfulConsole can fix this issue.
+
+YYCC::ConsoleHelper::EnableColorfulConsole will forcely enable ASCII Escape Code support in Windows console if possible.
+Thus you can write colorful text in Windows console freely.
+We suggest you to call this function at the beginning of program.
+
+Considering most Linux console supports ASCII Escape Code very well,
+this function does nothing in non-Windows platform.
+So it is not essential that brack this function calling with Windows-only \c \#if.
+
+\subsection console_helper__color__common Common Usage
+
+For common scenarios, you can use macro like this:
+
+\code
+YYCC::ConsoleHelper::WriteLine(YYCC_U8(YYCC_COLOR_LIGHT_RED("Light Red Text")));
+YYCC::ConsoleHelper::WriteLine(YYCC_U8("I am " YYCC_COLOR_LIGHT_RED("Light Red")));
+\endcode
+
+In first line, it will make <TT>"Light Red Text"</TT> to be shown in light red color.
+And for second line, it will make <TT>"Light Red"</TT> to be shown in light red color,
+but <TT>"I am "</TT> will keep default console font color.
+
+You also may notice this macro is used with YYCC_U8 macro.
+Because YYCC::ConsoleHelper::WriteLine only accept UTF8 argument.
+So please note if you use console color macro with YYCC_U8,
+please make YYCC_U8 always is located the outside.
+Otherwise, YYCC_U8 will fail to make the whole become UTF8 stirng as we introduced in \ref library_encoding.
+Because console color macro is implemented by string literal concatenation internally.
+
+YYCC_COLOR_LIGHT_RED is a member in YYCC_COLOR macro family.
+YYCC_COLOR macro family has 16 members for 16 different colors:
+
+\li YYCC_COLOR_BLACK
+\li YYCC_COLOR_RED
+\li YYCC_COLOR_GREEN
+\li YYCC_COLOR_YELLOW
+\li YYCC_COLOR_BLUE
+\li YYCC_COLOR_MAGENTA
+\li YYCC_COLOR_CYAN
+\li YYCC_COLOR_WHITE
+\li YYCC_COLOR_LIGHT_BLACK
+\li YYCC_COLOR_LIGHT_RED
+\li YYCC_COLOR_LIGHT_GREEN
+\li YYCC_COLOR_LIGHT_YELLOW
+\li YYCC_COLOR_LIGHT_BLUE
+\li YYCC_COLOR_LIGHT_MAGENTA
+\li YYCC_COLOR_LIGHT_CYAN
+\li YYCC_COLOR_LIGHT_WHITE
+
+\subsection console_helper__color__embedded Embedded Usgae
+
+In some cases, you want change console at some time point and reset it in another time point.
+You can use color macros like following example:
+
+\code
+YYCC::ConsoleHelper::WriteLine(YYCC_U8(YYCC_COLORHDR_LIGHT_BLUE));
+
+// Write as much as you liked
+YYCC::ConsoleHelper::WriteLine(YYCC_U8("some string"));
+YYCC::ConsoleHelper::WriteLine(YYCC_U8("another string"));
+
+YYCC::ConsoleHelper::WriteLine(YYCC_U8(YYCC_COLORTAIL));
+\endcode
+
+At first line, we output YYCC_COLORHDR_LIGHT_BLUE which is in YYCC_COLORHDR macro family.
+It is colorful text ASCII Escape Code head.
+It will make all following output become light blue color,
+until the last line we output YYCC_COLORTAIL to reset console color to original color.
+
+Same as YYCC_COLOR macro family, 
+YYCC_COLORHDR macro family also has 16 members for 16 different colors:
+
+\li YYCC_COLORHDR_BLACK
+\li YYCC_COLORHDR_RED
+\li YYCC_COLORHDR_GREEN
+\li YYCC_COLORHDR_YELLOW
+\li YYCC_COLORHDR_BLUE
+\li YYCC_COLORHDR_MAGENTA
+\li YYCC_COLORHDR_CYAN
+\li YYCC_COLORHDR_WHITE
+\li YYCC_COLORHDR_LIGHT_BLACK
+\li YYCC_COLORHDR_LIGHT_RED
+\li YYCC_COLORHDR_LIGHT_GREEN
+\li YYCC_COLORHDR_LIGHT_YELLOW
+\li YYCC_COLORHDR_LIGHT_BLUE
+\li YYCC_COLORHDR_LIGHT_MAGENTA
+\li YYCC_COLORHDR_LIGHT_CYAN
+\li YYCC_COLORHDR_LIGHT_WHITE
+
+However YYCC_COLORTAIL is YYCC_COLORTAIL.
+There is no other variant for different colors.
+Because all tail of colorful ASCII Escape Code is same.
+
+\section console_helper__universal_io Universal IO Function
+
+\subsection console_helper__universal_io__why Why?
+
+Windows console doesn't support UTF8 very well.
+The standard input output functions can not work properly with UTF8 on Windows.
+So we create this namespace and provide various console-related functions
+to patch Windows console and let it more like the console in other platforms.
+
+The function provided in this function can be called in any platforms.
+In Windows, the implementation will use Windows native function,
+and in other platform, the implementation will redirect request to standard C function like \c std::fputs and etc.
+So the programmer do not need to be worried about which function should they use,
+and don't need to use macro to use different IO function in different platforms.
+It is just enough that fully use the functions provided in this namespace.
+
+All IO functions this namespace provided are UTF8-based.
+It also means that input output string should always be UTF8 encoded.
+
+\subsection console_helper__universal_io__input Input Functions
+
+Please note that EOL will automatically converted into LF on Windows platform, not CRLF.
+This action actually is removing all CR chars in result string.
+This behavior affect nothing in most cases but it still is possible break something in some special case.
+
+Due to implementation, if you decide to use this function,
+you should give up using any other function to read stdin stream,
+such as \c std::gets() and \c std::cin.
+Because this function may read chars which is more than needed.
+These extra chars will be stored in this function and can be used next calling.
+But these chars can not be visited by stdin again.
+This behavior may cause bug.
+So if you decide using this function, stick on it and do not change.
+
+Due to implementation, this function do not support hot switch of stdin.
+It means that stdin can be redirected before first calling of this function,
+but it should not be redirected during program running.
+The reason is the same one introduced above.
+
+\subsection console_helper__universal_io__output Output Functions
+
+In current implementation, EOL will not be converted automatically to CRLF.
+This is different with other stream read functions provided in this namespace.
+
+Comparing with other stream read functions provided in this namespace,
+stream write function support hot switch of stdout and stderr.
+Because they do not have internal buffer storing something.
+
+In this namespace, there are various stream write function.
+There is a list telling you how to choose one from them for using:
+
+\li Functions with leading "Err" will write data into stderr,
+otherwise they will write data into stdout.
+\li Functions with embedded "Format" are output functions with format feature
+like \c std::fprintf(), otherwise the functions with embedded "Write" will
+only write plain string like \c std::fputs().
+\li Functions with trailing "Line" will write extra EOL to break current line.
+This is commonly used, otherwise functions will only write the text provided by arguments,
+without adding something.
+
+*/

doc/src/dialog_helper.dox

@@ -0,0 +1,167 @@
+/**
+
+\page dialog_helper Dialog Helper
+
+Picking files and folders is an important and essential operation under Windows.
+However the functions picking files and folders are so complex.
+This helper provides universal dialog picker by simple classes and functions.
+In following contents we will tell you how to call them.
+
+This helper is Windows specific.
+It will be totally invisible if you are in other platforms.
+
+\section dialog_helper__file_dialog Configure File Dialog
+
+The first thing is that we should initialize YYCC::DialogHelper::FileDialog, 
+and configure it according to your requirements.
+
+This class is the data struct representing all aspects of file dialog.
+It also one of the arguments in final dialog function.
+
+\code
+YYCC::DialogHelper::FileDialog params;
+params.SetOwner(owner_getter());
+params.SetTitle(YYCC_U8("My File Picker"));
+params.SetInitFileName(YYCC_U8("test.txt"));
+params.SetInitDirectory(initial_directory_getter());
+\endcode
+
+\subsection dialog_helper__file_dialog__owner Owner
+
+YYCC::DialogHelper::FileDialog::SetOwner will set owner of this dialog.
+It accepts a Microsoft defined \c HWND as argument which should be familiar with Windows programmer.
+If you pass \c NULL to it or skip calling this function, it indicate that there is no owner of this dialog.
+<I>
+I don't what will happen if there is no owner for it.
+But it would be better to have an owner if possible.
+</I>
+
+\subsection dialog_helper__file_dialog__title Title
+
+YYCC::DialogHelper::FileDialog::SetTitle will set dialog title of this dialog.
+If you pass \c nullptr or skip calling it,
+the title of dialog will be filled by system and the function type you calling.
+For example, the title will be "Open..." if you call open file function,
+and will be "Save As..." if you call save file function.
+At the same time, the language of this title filled by system is system UI dependent.
+It means that you do not need to do any extra I18N work for it.
+So I suggest you do not set title except you really want to modify title.
+
+\subsection dialog_helper__file_dialog__init_file_name Initial File Name
+
+YYCC::DialogHelper::FileDialog::SetInitFileName will set the initial file name presented in dialog file name input box.
+If you pass \c nullptr or skip calling it, the text in dialog file name input box will be empty.
+
+User can modify the name presented in input box later.
+But if you assign this value, the dialog will lose the ability that remember the previous name user input in previous calling.
+In normal case, dialog will try remembering the file name user input in dialog, and represent it in the next calling.
+However, if you specify this field, the dialog will always presented your specified value in every calling.
+
+\subsection dialog_helper__file_dialog__init_directory Initial Directory
+
+YYCC::DialogHelper::FileDialog::SetInitDirectory will set the initial directory (startup directory) when opening dialog.
+
+In following cases, initial directory will fall back to system behavior:
+
+\li Pass \c nullptr to this function.
+\li Skip calling this function.
+\li Given directory path is invalid.
+
+The system default behavior of initial directory is similar with initial file name.
+The dialog will try remembering the last directory you just entering, and will back into it in the next calling.
+The directory we meeting in the first launch is system defined.
+
+\section dialog_helper__file_filters Configure File Filters
+
+File filters is a drop down list represented in file dialog which allow user filter files by their extensions.
+It is beneficial to let user get the file which they want in a directory including massive different files.
+
+<B>For file dialog picking a directory,</B> you can skip this step.
+Because the file dialog picking directory does not have file filter drop down box.
+Directory can not be filtered.
+
+YYCC::DialogHelper::FileFilters takes responsibility for this feature:
+
+\code
+auto& filters = params.ConfigreFileTypes();
+filters.Add(YYCC_U8("Microsoft Word (*.docx; *.doc)"), { YYCC_U8("*.docx"), YYCC_U8("*.doc") });
+filters.Add(YYCC_U8("Microsoft Excel (*.xlsx; *.xls)"), { YYCC_U8("*.xlsx"), YYCC_U8("*.xls") });
+filters.Add(YYCC_U8("Microsoft PowerPoint (*.pptx; *.ppt)"), { YYCC_U8("*.pptx"), YYCC_U8("*.ppt") });
+filters.Add(YYCC_U8("Text File (*.txt)"), { YYCC_U8("*.txt") });
+filters.Add(YYCC_U8("All Files (*.*)"), { YYCC_U8("*.*") });
+params.SetDefaultFileTypeIndex(0u);
+\endcode
+
+\subsection dialog_helper__file_filters__setup File Filters
+
+We don't need to initialize YYCC::DialogHelper::FileFilters by ourselves.
+Oppositely, we fetch it from YYCC::DialogHelper::FileDialog instance by calling YYCC::DialogHelper::FileDialog::ConfigreFileTypes.
+After fetching, we can call YYCC::DialogHelper::FileFilters::Add to add a filter pair for file filters.
+
+The first argument is the display text which user will see in file filter drop down box.
+
+The second argument is a \c std::initializer_list.
+Every items are Windows used wildcard string instructing which file should be shown in file dialog.
+It is okey to use multiple wildcard string in list.
+This is suit for those file types involving multiple file extensions, such as the old and new file types of Microsoft Office as we illustracted.
+Empty list not allowed
+
+YYCC::DialogHelper::FileFilters::Add also will return a bool to indicate the success of this adding.
+
+It should at least has one file filter in file dialog.
+I don't know the consequence if you don't provide any file filter.
+
+\subsection dialog_helper__file_filters__default_filter Default File Type
+
+YYCC::DialogHelper::FileDialog::SetDefaultFileTypeIndex will set the default selected file filter of this dialog.
+It accepts an index pointing to the file filter which you want to show in default for this file dialog.
+The index of file filters is the order where you call YYCC::DialogHelper::FileFilters::Add above.
+If you pass \c NULL to it or skip calling this function, the first one will be default.
+
+\section dialog_helper__result Create Dialog and Get Result
+
+Finally, we can call file dialog functions by we initialized YYCC::DialogHelper::FileDialog
+
+\code
+YYCC::yycc_u8string single_selection;
+std::vector<YYCC::yycc_u8string> multiple_selection;
+
+YYCC::DialogHelper::OpenFileDialog(params, single_selection);
+YYCC::DialogHelper::OpenMultipleFileDialog(params, multiple_selection);
+YYCC::DialogHelper::SaveFileDialog(params, single_selection);
+YYCC::DialogHelper::OpenFolderDialog(params, single_selection);
+\endcode
+
+There are 4 file dialogs you can choose:
+
+\li YYCC::DialogHelper::OpenFileDialog:  Open single file
+\li YYCC::DialogHelper::OpenMultipleFileDialog: Open multiple files
+\li YYCC::DialogHelper::SaveFileDialog: Save single file
+\li YYCC::DialogHelper::OpenFolderDialog: Open single directory
+
+\subsection dialog_helper__result__arguments Arguments
+
+Among these 4 functions, the first argument always is the reference to YYCC::DialogHelper::FileDialog.
+Function will use it to decide what should be shown in this file dialog.
+
+The second argument always is the reference to the container receiving the result.
+For single selection, the return type is \c yycc_u8string.
+For multiple selection, the return type is a list of strings: \c std::vector<yycc_u8string>.
+
+\subsection dialog_helper__result__return_value Return Value
+
+Please note among these 4 functions will return a bool as its return value to indicate the success of function.
+If they return false, it means that the execution of functions are failed or user click Cancel button.
+In this case, there is no guaranteen to the content of second argument (the real return value).
+
+\section dialog_helper__notes Notes
+
+You may notice there are various classes which we never introduce.
+Because they are intermediate classes and should not be used by programmer.
+For example:
+
+\li YYCC::DialogHelper::WinFileDialog: The converted YYCC::DialogHelper::FileDialog passed to Windows.
+\li YYCC::DialogHelper::WinFileFilters: Same as YYCC::DialogHelper::WinFileDialog. It will be passed to Windows functions.
+\li etc...
+
+*/

doc/src/encoding_helper.dox

@@ -0,0 +1,146 @@
+/**
+
+\page encoding_helper Encoding Helper
+
+YYCC::EncodingHelper namespace include all encoding related functions:
+
+\li The convertion between ordinary string and UTF8 string which has been introduced in chapter \ref library_encoding.
+\li Windows specific convertion between \c WCHAR, UTF8 string and string encoded by other encoding.
+\li The convertion among UTF8, UTF16 and UTF32.
+
+\section encoding_helper__ordinary_utf8_conv Ordinary & UTF8 Convertion
+
+These convertion functions have been introduced in previous page.
+See \ref library_encoding for more infomation.
+
+YYCC supports following convertions:
+
+\li YYCC::EncodingHelper::ToUTF8: Convert ordinary string to UTF8 string.
+\li YYCC::EncodingHelper::ToUTF8View: Same as ToUTF8, but return string view instead.
+\li YYCC::EncodingHelper::ToOrdinary: Convert UTF8 string to ordinary string.
+\li YYCC::EncodingHelper::ToOrdinaryView: Same as ToOrdinary, but return string view instead.
+
+\section encoding_helper__win_conv Windows Specific Convertion
+
+During Windows programming, the convertion between Microsoft specified \c wchar_t and \c char is an essential operation.
+Because Windows has 2 different function system, the functions ended with A and the functions ended with W.
+(Microsoft specified \c wchar_t is \c 2 bytes long. It's different with Linux defined common 4 bytes long).
+Thus YYCC provides these convertion functions in Windows to help programmer have better programming experience.
+
+These functions are Windows specific, so they will be invisible in other platforms.
+Please use them carefully (make sure that you are using them only in Windows environment).
+
+YYCC supports following convertions:
+
+\li YYCC::EncodingHelper::WcharToChar: Convert \c wchar_t string to code page specified string.
+\li YYCC::EncodingHelper::CharToWchar: The reversed convertion of WcharToChar.
+\li YYCC::EncodingHelper::CharToChar: Convert string between 2 different code pages. It's a shortcut of calling CharToWchar and WcharToChar successively.
+\li YYCC::EncodingHelper::WcharToUTF8: Convert \c wchar_t string to UTF8 string.
+\li YYCC::EncodingHelper::UTF8ToWchar: The reversed convertion of WcharToUTF8.
+\li YYCC::EncodingHelper::CharToUTF8: Convert code page specified string to UTF8 string.
+\li YYCC::EncodingHelper::UTF8ToChar: The reversed convertion of CharToUTF8.
+
+Code Page is a Windows concept.
+If you don't understand it, please view corresponding Microsoft documentation.
+
+\section encoding_helper__utf_conv UTF8 UTF16 UTF32 Convertion
+
+The convertion between UTF8, UTF16 and UTF32 is not common but essential.
+These convertions can be achieved by standard library functions and classes.
+(they are actually done by standard library functions in our implementation)
+But we provided functions are easy to use and have clear interface.
+
+These functions are different with the functions introduced above.
+They can be used in any platform, not confined in Windows platforms.
+
+YYCC supports following convertions:
+
+\li YYCC::EncodingHelper::UTF8ToUTF16: Convert UTF8 string to UTF16 string.
+\li YYCC::EncodingHelper::UTF16ToUTF8: The reversed convertion of UTF8ToUTF16.
+\li YYCC::EncodingHelper::UTF8ToUTF32: Convert UTF8 string to UTF32 string.
+\li YYCC::EncodingHelper::UTF32ToUTF8: The reversed convertion of UTF8ToUTF32.
+
+\section encoding_helper__overloads Function Overloads
+
+Every encoding convertion functions (except the convertion between UTF8 and ordinary string) have 4 different overloads for different scenarios.
+Take YYCC::EncodingHelper::WcharToChar for example.
+There are following 4 overloads:
+
+\code
+bool WcharToChar(const std::wstring_view& src, std::string& dst, UINT code_page);
+bool WcharToChar(const wchar_t* src, std::string& dst, UINT code_page);
+std::string WcharToChar(const std::wstring_view& src, UINT code_page);
+std::string WcharToChar(const wchar_t* src, UINT code_page);
+\endcode
+
+\subsection encoding_helper__overloads_destination Destination String
+
+According to the return value, these 4 overload can be divided into 2 types.
+The first type returns bool. The second type returns \c std::string instance.
+
+For the first type, it always return bool to indicate whether the convertion is success.
+Due to this, the function must require an argument for holding the result string.
+So you can see the functions belonging to this type always require a reference to \c std::string in argument.
+
+Oppositely, the second directly returns result by return value.
+It doesn't care the success of convertion and will return empty string if convertion failed.
+Programmer can more naturally use it because the retuen value itself is the result.
+There is no need to declare a variable before calling convertion function for holding result.
+
+All in all, the first type overload should be used in strict scope.
+The success of convertion will massively affect the behavior of your following code.
+For example, the convertion code is delivered to some system function and it should not be empty and etc.
+The second type overload usually is used in lossen scenarios.
+For exmaple, this overload usually is used in console output because it usually doesn't matter.
+There is no risk even if the convertion failed (just output a blank string).
+
+For the first type, please note that there is \b NO guarantee that the argument holding return value is not changed.
+Even the convertion is failed, the argument holding return value may still be changed by function itself.
+
+In this case, the type of result is \c std::string because this is function required.
+In other functions, such as YYCC::EncodingHelper::WcharToUTF8, the type of result can be \c yycc_u8string or etc.
+So please note the type of result is decided by convertion function itself, not only \c std::string.
+
+\subsection encoding_helper__overloads__source Source String
+
+According to the way providing source string,
+these 4 overload also can be divided into 2 types.
+The first type take a reference to constant \c std::wstring_view.
+The second type take a pointer to constant wchar_t.
+
+For first type, it will take the whole string for convertion, including \b embedded NUL terminal.
+Please note we use string view as argument.
+It is compatible with corresponding raw string pointer and string container.
+So it is safe to directly pass \c std::wstring for this function.
+
+For second type, it will assume that you passed argument is a NUL terminated string and send it for convertion.
+
+The result is clear.
+If you want to process string with \b embedded NUL terminal, please choose first type overload.
+Otherwise the second type overload is enough.
+
+Same as destination string, the type of source is also decided by the convertion function itself.
+For exmaple, the type of source in YYCC::EncodingHelper::UTF8ToWchar is \c yycc_u8string_view and \c yycc_char8_t, 
+not \c std::wstring and \c wchar_t.
+
+\subsection encoding_helper__overloads__extra Extra Argument
+
+There is an extra argument called \c code_page for YYCC::EncodingHelper::WcharToChar.
+It indicates the code page of destination string,
+because this function will convert \c wchar_t string to the string with specified code page encoding.
+
+Some convertion functions have extra argument like this,
+because they need more infomations to decide what they need to do.
+Some convertion functions don't have extra argument.
+For exmaple, the convertion between \c wchar_t string and UTF8 string.
+Because both source string and destination string are concrete.
+There is no need to provide any more infomations.
+
+\subsection encoding_helper__overloads__conclusion Conclusion
+
+Mixing 2 types of source string and 2 types of destination string,
+we have 4 different overload as we illustrated before.
+Programmer can use them freely according to your requirements.
+And don't forget to provide extra argument if function required.
+
+*/

doc/src/exception_helper.dox

@@ -0,0 +1,87 @@
+/**
+
+\page exception_helper Unhandled Exception Handler
+
+Most Linux users are familiar with core dump.
+However core dump is a tough work on Windows especially most Windows users are naive for getting core dump.
+So it is essential to make an easy-to-visit core dump Feature for Windows program.
+YYCC provides this feature in YYCC::ExceptionHelper.
+
+You may know Google also has a similar and universal project called Crashpad used by Google Chrome.
+That's right. But it is too heavy.
+I just want to implement a tiny but worked core dump feature on Windows.
+
+This module is Windows specific.
+It will be invisible on other platforms.
+
+\section exception_helper__usage Usage
+
+\subsection exception_helper__usage__code Register Code
+
+In most scenarios, programmer only need call YYCC::ExceptionHelper::Register() when program started or module loaded.
+And call YYCC::ExceptionHelper::Unregister when program exited or module unloaded.
+All details are hidden by these 2 feature.
+Programmer do not need worried about the implementation of unhandled exception handler.
+
+\subsection exception_helper__usage__location Location
+
+When unhandled exception occurs, 
+unhandled exception handler will try to record error log and core dump in following path:
+
+\li Error Log: <TT>\%LOCALAPPDATA\%\\CrashDumps\\<I>program.exe</I>.<I>pid</I>.log</TT>
+\li Core Dump: <TT>\%LOCALAPPDATA\%\\CrashDumps\\<I>program.exe</I>.<I>pid</I>.dmp</TT>
+
+The italic characters <I>program.exe</I> and <I>pid</I> will be replaced by program name and process ID respectively at runtime.
+Directory <TT>\%LOCALAPPDATA\%\\CrashDumps</TT> also is Windows used crash dump directory.
+So you may see some other core dumps done by Windows in it.
+
+\subsection exception_helper__usage__last_remedy Last Remedy
+
+If unhandled exception handler occurs error, these stuff may not be generated correctly.
+The end user may not find them and send them to you.
+There is a last remedy for this scenario.
+
+Unhandled exception handler will still output error log in \c stderr no matter whether error log or core dump is created.
+So end user always can fetch error log from console.
+You only need to instruct end user open command prompt, launch application, reproduce error and get the output error log in console.
+In this case, you can not get core dump. But you can get error log.
+It is not good for debugging but it is better than nothing.
+
+Also please note the last remedy may still have a little bit possibility to occurs error and output nothing,
+especially the error occurs in back trace function.
+There is no guaranteen that unhandled exception handler must generate error log and core dump.
+
+\section exception_helper__notes Notes
+
+\subsection exception_helper__notes__thread_safe Thread Safe
+
+All exposed functions in YYCC::ExceptionHelper are thread safe.
+The implementation uses \c std:mutex to ensure this.
+
+\subsection exception_helper__notes__singleton Singleton Handler
+
+YYCC::ExceptionHelper also have a mechanism that make sure the same unhandled exception handler implementation only appear once in the same process.
+For example, you have an executable program A.exe, and 2 dynamic libraries B.dll and C.dll.
+A.exe and B.dll use YYCC unhandled exception handler feature but C.dll not.
+A.exe will load B.dll and C.dll at runtime.
+Although both A.exe and B.dll call YYCC::ExceptionHelper::Register(),
+when unhandled exception occurs, there is only one error report output, 
+which may be generated by A.exe or B.dll accoridng to their order of loading.
+
+The core purpose of this is making sure the program will not output too many error report for the same unhandled exception,
+no matter how many modules calling YYCC::ExceptionHelper::Register() are loaded.
+Only one error report is enough.
+
+More precisely, we use \c CreateMutexW to create an unique mutex in Windows global scope,
+to make sure YYCC::ExceptionHelper::Register() only run once in the same process.
+It is very like the implementation of singleton application.
+
+\subsection exception_helper__notes__recursive_calling Recursive Calling
+
+The implementation of unhandled exception handler may also will throw exception.
+This will cause infinite recursive calling.
+YYCC::ExceptionHelper has internal mechanism to prevent this bad case.
+If this really happened, the handler will quit silent and will not cause any issue.
+Programmer don't need to worry about this.
+
+*/

doc/src/fs_path_patch.dox

@@ -0,0 +1,73 @@
+/**
+
+\page fs_path_patch std::filesystem::path Patch
+
+As you know, the underlying char type of \c std::filesystem::path is \c wchar_t on Windows,
+and in other platforms, it is simple \c char.
+Due to this, if you try to create a \c std::filesystem::path instance by calling constructor with an UTF8 char sequence on Windows,
+the library implementation will assume your input is based on current Windows code page, not UTF8.
+And the final path stored in \c std::filesystem::path is not what you expcected.
+
+This patch gives you a way to create \c std::filesystem::path 
+and extract path string stored in \c std::filesystem::path with UTF8 encoding.
+This patch namespace always use UTF8 as its argument.
+You should use the functions provided by this namespace on any platforms 
+instead of vanilla \c std::filesystem::path functions.
+However, if your C++ standard is higher than C++ 20,
+you can directly use UTF8 string pointer and string container in \c std::filesystem::path,
+because standard library has supported them.
+This patch only just want to provide an uniform programming experience.
+
+This patch is served for Windows but also works on other plaftoms.
+If you are in Windows, this patch will perform extra operations to achieve goals,
+and in other platforms, they just redirect request to corresponding vanilla C++ functions.
+
+\section fs_path_patch__from_utf8_path Create Path from UTF8 String
+
+YYCC::FsPathPatch::FromUTF8Path provides this feature.
+It accepts an string pointer to UTF8 string and try to create \c std::filesystem::path from it.
+Function will throw exception if encoding convertion or constructor self failed.
+There are some example:
+
+\code
+auto foobar_path = YYCC::FsPathPatch::FromUTF8Path(YYCC_U8("/foo/bar"));
+auto slashed_path = foobar_path / YYCC::FsPathPatch::FromUTF8Path(YYCC_U8("test"));
+auto replaced_ext = foobar_path.replace_extension(YYCC::FsPathPatch::FromUTF8Path(YYCC_U8(".txt")));
+\endcode
+
+For first line in example, it is obvious that you can create a \c std::filesystem::path from this function.
+However, for the second and third line in example, what we want to tell you is 
+that you should always use this function in other \c std::filesystem::path functions requiring path string.
+
+\c std::filesystem::path is a very \e conservative class.
+Most of its functions only accept \c std::filesystem::path self as argument.
+For example, \c std::filesystem::path::replace_extension do not accept string as argument.
+It accepts a reference to \c std::filesystem::path as argument.
+(it still is possible that pass string pointer or string container to it because they can be converted to \c std::filesystem::path implicitly.)
+It's great. This is what we expected!
+We now can safely deliver the result generated by our function to these functions,
+and don't need to worry about the encoding of we provided string.
+Because all strings have been converted to \c std::filesystem::path by our function before passing them.
+
+So, the second line will produce \c "/foo/bar/test" 
+and the third line will produce \c "/foo/bar.txt" in any platforms.
+
+You may notice std::filesystem::u8path.
+However it is depracted since C++ 20,
+because \c std::filesystem::path directly supports UTF8 by \c char8_t since C++ 20.
+Because C++ standard is volatile, we create this function to have an uniform programming experience.
+
+\section fs_path_patch__to_utf8_path Extract UTF8 Path String from Path
+
+YYCC::FsPathPatch::ToUTF8Path provides this feature.
+It basically is the reversed operation of YYCC::FsPathPatch::FromUTF8Path.
+It is usually used when you have done all path work in \c std::filesystem::path
+and want to get the result.
+There is an example:
+
+\code
+auto foobar_path = YYCC::FsPathPatch::FromUTF8Path(YYCC_U8("/foo/bar"));
+auto result = YYCC::FsPathPatch::ToUTF8Path(foobar_path / YYCC::FsPathPatch::FromUTF8Path(YYCC_U8("test")));
+\endcode
+
+*/

doc/src/index.dox

@@ -1,10 +1,71 @@
 /**
 
-\mainpage YYCCommonplace Library Manual
+\mainpage YYCCommonplace Programming Manual
 
-This manual is organized into the following chapters and appendices:
+<TABLE CELLPADDING="8" CELLSPACING="0" SUMMARY="TITLE BAR" WIDTH="100%" BORDER="0">
+<TR>
+  <TD><CENTER>
+    \image html yycc_icon.png
+  </CENTER></TD>
+  <TD><CENTER>
+    <B>YYCCommonplace Programming Manual</B>
 
-\subpage intro
+    Copyright 2024 by yyc12345.
+  </CENTER></TD>
+</TR>
+</TABLE>
+<TABLE CELLPADDING="8" CELLSPACING="0" SUMMARY="TITLE BAR" WIDTH="100%" BORDER="0">
+<TR>
+  <TD>
+    This software and manual are provided under the terms of the MIT License.
+  </TD>
+</TR>
+</TABLE>
+<TABLE CELLPADDING="8" CELLSPACING="0" SUMMARY="Table of Contents" WIDTH="100%" BORDER="0">
+<TR>
+  <TD ALIGN="LEFT" VALIGN="TOP">
 
+    <B>General Features</B>
+
+    \li \subpage intro
+
+    \li \subpage platform_checker
+
+    \li \subpage library_encoding
+
+    \li \subpage encoding_helper
+
+    \li \subpage string_helper
+
+    \li \subpage parser_helper
+
+    \li \subpage console_helper
+
+    \li \subpage io_helper
+
+    \li \subpage fs_path_patch
+
+    <B>Advanced Features</B>
+
+    \li \subpage config_manager
+
+  </TD>
+  <TD ALIGN="LEFT" VALIGN="TOP">
+
+    <B>Windows Specific Features</B>
+
+    \li \subpage win_import
+
+    \li \subpage com_helper
+
+    \li \subpage dialog_helper
+
+    \li \subpage win_fct_helper
+
+    \li \subpage exception_helper
+
+  </TD>
+</TR>
+</TABLE>
 
 */

doc/src/intro.dox

@@ -2,10 +2,161 @@
 
 \page intro Introduction to YYCCommonplace
 
-work in progress
+YYCCommonplace, or YYC Commonplace (abbr. YYCC), 
+is a static library providing various useful C++ functions 
+when programming with standard library or Windows environment.
 
-\section work in progress
+During the development of a few projects, 
+I gradually understand how Windows make the compromise with the code written by its old developers, 
+and what is developer wanted in contemporary C++ standard library under Windows environment. 
+So I create this static library for all of my C++ project.
+After this, I do not need to write these duplicated code in each project. 
+I can use a clear and easy way to manage these codes. 
+I can easily fix issues found in project using this library by updating a single project, 
+rather than fixing these duplicated code in each project one by one 
+because all of them share the same implementations.
 
-work in progress
+This project mainly is served for my personal use. 
+But I would be honored if you would like to use this in your project. 
+Almost of my projects will gradually adapt to this project and drop their own individual implementations.
+
+\section intro__why Why YYCCommonplace
+
+\subsection intro__why__windows Windows Issues
+
+I frequently program on Windows environment because the software I programming for, Virtools, is Windows-only software.
+During programming, I found Windows is super lack in UTF8 supports.
+Programmer loves UTF8, because it can handle all charcaters over the world in one encoding and is still compatible with C-Style string.
+However, Windows use a weird way to achieve internationalization, 2 different function trailing, A and W for legacy code and modern code respectively.
+The worst things is that the char type W trailing function used, \c WCHAR, is defined as 2 bytes long, not 4 bytes long as Linux does (\c wchar_t).
+It mean that one emoji charcater will be torn into 2 \c WCHAR on Windows because emoji code unit is higher than the manimum value of \c WCHAR.
+
+Also, there are various issues which should not be presented.
+For example, Microsoft invents various \e safe standard library functions to prevent possible overflow issues raised by \c std::fgets and etc.
+also, MSVC may throw weird error when you using some specific standard library functions.
+You need to define some weird macro to disable this shitty behavior.
+
+There are various non-standard issue you may faced on Windows programming. 
+All in all, programming on Windows is a tough work.
+This is one of the reasons why I create this library.
+I create much wrappers for these weird Windows functions.
+Thus I can have a similar Linux C++ programming experience on Windows.
+
+\subsection intro__why__std Standard Library Issues
+
+The eccentric decision of standard commission also is the reason why I create this library.
+
+\li C++ standard commission loves to bring one feature with N concepts and P assistant classes.
+\li C++ standard commission seems doesn't want to bring any features the programmer urgent needed.
+\li C++ standard commission loves delete programmer loved convenient functions and classes.
+\li etc...
+
+There is not a proper way to \e format a string in C++ until C++ 20 (\c std::format).
+String related functions, such as split, lower, higher, replace, now still not be included in standard library.
+Programmer loved, easy to used UTF8 procession functions and classes was deprecate now and will be removed in future.
+
+That's why I create this library.
+I bring these function in this library.
+Not industrial level, but easy to use and have enough performance in my project.
+
+\subsection intro__why__boost Boost Issues
+
+Bosst is a powerful C++ library. But the shortcoming is overt. It's tooooo big.
+This drawback will be more obvious considering the bad dependency mechanism of C++.
+Although the most of Boost sub-library is header-only, but some library still need to link with Boost.
+It order you download the whole Boost library and extract it in your hard disk.
+Cost more than half hours, 5+ GB disk space and the life time of your disk.
+
+The functions belonging to Boost is industrial level.
+But what I want is not industrial level functions.
+I only need a function which can barely finish my work. That's enough.
+I don't need extreme performance. I just want my code works.
+
+So I create this library, bring some Boost functions with ordinary but not bad implementation.
+
+\section intro__usage Library Usage
+
+Before using this library, I suggest you read this manual fully to have a full overview of this library.
+Otherwise you may make mistake during using this library.
+I suggest you read this manual from top to bottom in the left tree panel, one by one.
+
+YYCC library self provides some build scripts for convenient use which are located in \c script directory.
+Please note all of these script should be executed in the root of YYCC project, not the script directory
+(i.e. work directory is the root directory of YYCC).
+All scripts will try to do a simple check about this if you accidently execute them in a wrong place.
+
+If you are not willing to use our build script, or our build script went wrong,
+you can create your personal build script by viewing our build script.
+
+\subsection intro__usage__linux Linux
+
+Building YYCC on Linux is easy to do by executing <TT>script/linux_build.sh</TT>.
+After script done, you will find installation result in directory <TT>bin/install</TT>.
+Then other CMake project can utilize it (non-CMake project also can utilize this).
+
+\subsection intro__usage__win Windows
+
+For building on Windows, there are 2 distribution types which YYCC can create.
+First is CMake distribution, this distribution is served for other CMake project using.
+Another one is MSVC distribution, this distribution is served for other MSVC project using.
+These have different directory layout which is specifically designed for corresponding build tools.
+See following section for more details.
+
+\subsubsection intro__usage__win__cmake CMake Distribution
+
+For creating CMake distribution, please execute script <TT>script/win_build.bat</TT>.
+After script done, you will find CMake distribution in directory <TT>bin/install</TT> with following structure.
+
+\verbatim
+YYCC
+├─Win32_Debug: Win32 Debug package
+│  ├─include: Headers
+│  └─lib: Library for linking and CMake package file
+├─Win32_Release: Win32 Release package
+│  ├─bin: Executable testbench
+│  ├─include: Headers
+│  └─lib: Library for linking and CMake package file
+├─x64_Debug: x64 Debug package
+│  ├─include: Headers
+│  └─lib: Library for linking and CMake package file
+└─x64_Release: x64 Release package
+    ├─bin: Executable testbench
+    ├─include: Headers
+    ├─lib: Library for linking and CMake package file
+    └─share: Documentation
+\endverbatim
+
+Every different architecture and build type have a single and full directory.
+CMake project can use one of by adding their build type in \c find_package path.
+So that CMake will automatically utilize correct package when switching build type.
+
+\subsubsection intro__usage__win__msvc MSVC Distribution
+
+Before creating MSVC distribution, you should create CMake distribution first,
+because MSVC distribution depend on CMake distribution.
+
+After creating CMake distribution, you can simply create MSVC distribution by executing <TT>script/win_msvc_build.bat</TT>.
+Then you will find your MSVC distribution in directory <TT>bin/msvc_install</TT> with following structure.
+
+\verbatim
+YYCC
+├─bin
+│  ├─Win32: Win32 Release testbench
+│  └─x64: x64 Release testbench
+├─include: Headers
+├─lib
+│  ├─Win32
+│  │  ├─Debug: Win32 Debug library for linking
+│  │  └─Release: Win32 Release library for linking
+│  └─x64
+│      ├─Debug: x64 Debug library for linking
+│      └─Release: x64 Release library for linking
+└─share: Documentation
+\endverbatim
+
+The different between MSVC distribution and CMake distribution is
+that MSVC distribution places all static library under one director \c lib.
+Thus in MSVC project user can simply spcify the install path of YYCC,
+and use MSVC macros in path to choose correct static library for linking
 
 */

doc/src/io_helper.dox

@@ -0,0 +1,43 @@
+/**
+
+\page io_helper IO Helper
+
+YYCC::IOHelper currently only has one function and one macro.
+
+\section io_helper__ptr_pri_padding Pointer Print Padding
+
+When printing pointer on screen, programmer usually left-pad zero to make it looks good.
+However, the count of zero for padding is different in x86 and x64 architecture (8 for x86 and 16 for x64).
+Macro \c PRI_XPTR_LEFT_PADDING will help you to resolve this issue.
+
+Macro \c PRI_XPTR_LEFT_PADDING will be defined to following value according to the target system architecture.
+
+\li \c "08": On x86 system.
+\li \c "016": On x64 system.
+
+There is an example for how to use it:
+
+\code
+void* raw_ptr = blabla();
+std::printf(stdout, "Raw Pointer 0x%" PRI_XPTR_LEFT_PADDING PRIXPTR, raw_ptr);
+\endcode
+
+Note \c PRIXPTR is defined by standard library for formatting pointer as hexadecimal style.
+
+\section io_helper__utf8_fopen UTF8 fopen
+
+In Windows, standard \c std::fopen can not handle UTF8 file name in common environment.
+So we create this function to give programmer an universal \c fopen in UTF8 style.
+
+In Windows platform, this function will try to convert its argument to \c wchar_t
+and calling Microsoft specific \c _wfopen function to open file.
+If encoding convertion or \c _wfopen failed, this function will return \c nullptr like \c std::fopen does.
+In other platforms, it will simply redirect calling to \c std::fopen.
+
+There is a simple example:
+
+\code
+FILE* fs = YYCC::IOHelper::FOpen(YYCC_U8("/path/to/file"), YYCC_U8("rb"));
+\endcode
+
+*/

doc/src/library_encoding.dox

@@ -0,0 +1,226 @@
+/**
+
+\page library_encoding Library Encoding
+
+Before using this library, you should know the encoding strategy of this library first.
+In short words, this library use UTF8 encoding everywhere except some special cases,
+for example, function explicitly order the encoding of input parameters.
+
+In following content of this article, you will know the details about how we use UTF8 in this library.
+
+\section library_encoding__utf8_type UTF8 Type
+
+YYCC uses custom UTF8 char type, string container and string view all over the library, from parameters to return value.
+Following content will introduce how we define them.
+
+\subsection library_encoding__utf8_type__char_type Char Type
+
+YYCC library has its own UTF8 char type, \c yycc_char8_t.
+This is how we define it:
+
+\code
+#if defined(__cpp_char8_t)
+using yycc_char8_t = char8_t;
+#else
+using yycc_char8_t = unsigned char;
+#endif
+\endcode
+
+If your environment (higher or equal to C++ 20) supports \c char8_t provided by standard library, \c yycc_char8_t is just an alias to \c char8_t,
+otherwise (lower than C++ 20, e.g. C++ 17), \c yycc_char8_t will be defined as \c unsigned \c char like C++ 20 does (this can be seen as a polyfill).
+
+This means that if you already have used \c char8_t provided by standard library,
+you do not need to do any extra modification before using this library.
+Because all types are compatible.
+
+\subsection library_encoding__utf8_type__container_type String Container and View
+
+We define string container and string view like this:
+
+\code
+using yycc_u8string = std::basic_string<yycc_char8_t>;
+using yycc_u8string_view = std::basic_string_view<yycc_char8_t>;
+\endcode
+
+The real code written in library may be slightly different with this but they have same meanings.
+
+In \c char8_t environment, they are just the alias to \c std::u8string and \c std::u8string_view respectively.
+So if you have already used them, no need to any modification for your code before using this library.
+
+\subsection library_encoding__utf8_type__why Why?
+
+You may curious why I create a new UTF8 char type, rather than using standard library UTF8 char type directly. There are 2 reasons.
+
+First, It was too late that I notice I can use standard library UTF8 char type.
+My UTF8 char type has been used in library everywhere and its tough to fully replace them into standard library UTF8 char type.
+
+Second, UTF8 related content of standard library is \e volatile.
+I notice standard library change UTF8 related functions frequently and its API are not stable.
+For example, standard library brings \c std::codecvt_utf8 in C++ 11, deprecate it in C++ 17 and even remove it in C++ 26.
+That's unacceptable! So I create my own UTF8 type to avoid the scenario that standard library remove \c char8_t in future.
+
+\section library_encoding__concept Concepts
+
+In following content, you may be face with 2 words: ordinary string and UTF8 string.
+
+UTF8 string, as its name, is the string encoded with UTF8.
+The char type of it must is \c yycc_char8_t.
+(equivalent to \c char8_t after C++ 20.)
+
+Ordinary string means the plain, native string.
+The result of C++ string literal without any prefix \c "foo bar" is a rdinary string.
+The char type of it is \c char.
+Its encoding depends on compiler and environment.
+(UTF8 in Linux, or system code page in Windows if UTF8 switch was not enabled in MSVC.)
+
+For more infomation, please browse CppReference:
+https://en.cppreference.com/w/cpp/language/string_literal
+
+\section library_encoding__utf8_literal UTF8 Literal
+
+String literal is a C++ concept.
+If you are not familar with it, please browse related article first, such as CppReference.
+
+\subsection library_encoding__utf8_literal__single Single Literal
+
+In short words, YYCC allow you declare an UTF8 literal like this:
+
+\code
+YYCC_U8("This is UTF8 literal.")
+\endcode
+
+YYCC_U8 is macro.
+You don't need add extra \c u8 prefix in string given to the macro.
+This macro will do this automatically.
+
+In detail, this macro do a \c reinterpret_cast to change the type of given argument to \c const \c yycc_char8_t* forcely.
+This ensure that declared UTF8 literal is compatible with YYCC UTF8 types.
+
+\subsection library_encoding__utf8_literal__char Single Char
+
+Same as UTF8 literal, YYCC allow you cast normal \c char into \c yycc_char8_t as following code:
+
+\code
+YYCC_U8_CHAR('A')
+\endcode
+
+YYCC_U8_CHAR is a macro.
+It just simply use \c static_cast to cast given value to \c yycc_char8_t.
+It doesn't mean that you can cast non-ASCII characters,
+because the space these characters occupied usually more than the maximum value of \c char.
+For example, following code is \b invalid:
+
+\code
+YYCC_U8_CHAR('文') // INVALID!
+\endcode
+
+\subsection library_encoding__utf8_literal__concatenation Literal Concatenation
+
+YYCC_U8 macro also works for string literal concatenation:
+
+\code
+YYCC_U8("Error code: " PRIu32 ". Please contact me.");
+\endcode
+
+According to C++ standard for string literal concatenation, 
+<I>"If one of the strings has an encoding prefix and the other does not, the one that does not will be considered to have the same encoding prefix as the other."</I>
+At the same time, YYCC_U8 macro will automatically add \c u8 prefix for the first component of this string literal concatenation.
+So the whole string will be UTF8 literal.
+It also order you should \b not add any prefix for other components of this string literal concatenation.
+
+\subsection library_encoding__utf8_literal__why Why?
+
+You may know that C++ standard allows programmer declare an UTF8 literal explicitly by writing code like this:
+
+\code
+u8"foo bar"
+\endcode
+
+This is okey. But it may incompatible with YYCC UTF8 char type.
+According to C++ standard, this UTF8 literal syntax will only return \c const \c char8_t* if your C++ standard higher or equal to C++ 20,
+otherwise it will return \c const \c char*.
+This behavior cause that you can not assign this UTF8 literal to \c yycc_u8string if you are in the environment which do not support \c char8_t, 
+because their types are different.
+Thereas you can not use the functions provided by this library because they are all use YYCC defined UTF8 char type.
+
+\section library_encoding__utf8_pointer UTF8 String Pointer
+
+String pointer means the raw pointer pointing to a string, such as \c const \c char*, \c char*, \c char32_t* and etc.
+
+Many legacy code assume \c char* is encoded with UTF8 (the exception is Windows). But \c char* is incompatible with \c yycc_char8_t.
+YYCC provides YYCC::EncodingHelper::ToUTF8 to resolve this issue. There is an exmaple:
+
+\code
+const char* absolutely_is_utf8 = "I confirm this is encoded with UTF8.";
+const yycc_char8_t* converted = YYCC::EncodingHelper::ToUTF8(absolutely_is_utf8);
+
+char* mutable_utf8 = const_cast<char*>(absolutely_is_utf8); // This is not safe. Just for example.
+yycc_char8_t* mutable_converted = YYCC::EncodingHelper::ToUTF8(mutable_utf8);
+\endcode
+
+YYCC::EncodingHelper::ToUTF8 has 2 overloads which can handle constant and mutable stirng pointer convertion respectively.
+
+YYCC also has ability that convert YYCC UTF8 char type to ordinary char type by YYCC::EncodingHelper::ToOrdinary.
+Here is an exmaple:
+
+\code
+const yycc_char8_t* yycc_utf8 = YYCC_U8("I am UTF8 string.");
+const char* converted = YYCC::EncodingHelper::ToOrdinary(yycc_utf8);
+
+yycc_char8_t* mutable_yycc_utf8 = const_cast<char*>(yycc_utf8); // Not safe. Also just for example.
+char* mutable_converted = YYCC::EncodingHelper::ToOrdinary(mutable_yycc_utf8);
+\endcode
+
+Same as YYCC::EncodingHelper::ToUTF8, YYCC::EncodingHelper::ToOrdinary also has 2 overloads to handle constant and mutable string pointer.
+
+\section library_encoding__utf8_container UTF8 String Container
+
+String container usually means the standard library string container, such as \c std::string, \c std::wstring, \c std::u32string and etc.
+
+In many personal project, programmer may use \c std::string everywhere because \c std::u8string may not be presented when writing peoject.
+How to do convertion between ordinary string container and YYCC UTF8 string container?
+It is definitely illegal that directly do force convertion. Because they may have different class layout.
+Calm down and I will tell you how to do correct convertion.
+YYCC provides YYCC::EncodingHelper::ToUTF8 to convert ordinary string container to YYCC UTF8 string container.
+There is an exmaple:
+
+\code
+std::string ordinary_string("I am UTF8");
+yycc_u8string yycc_string = YYCC::EncodingHelper::ToUTF8(ordinary_string);
+auto result = YYCC::EncodingHelper::UTF8ToUTF32(yycc_string);
+\endcode
+
+Actually, YYCC::EncodingHelper::ToUTF8 accepts a reference to \c std::string_view as argument.
+However, there is a implicit convertion from \c std::string to \c std::string_view, 
+so you can directly pass a \c std::string instance to it.
+
+String view will reduce unnecessary memory copy.
+If you just want to pass ordinary string container to function, and this function accepts \c yycc_u8string_view as its argument,
+you can use alternative YYCC::EncodingHelper::ToUTF8View.
+
+\code
+std::string ordinary_string("I am UTF8");
+yycc_u8string_view yycc_string = YYCC::EncodingHelper::ToUTF8View(ordinary_string);
+auto result = YYCC::EncodingHelper::UTF8ToUTF32(yycc_string);
+\endcode
+
+Comparing with previous one, this example use less memory.
+The reduced memory is the content of \c yycc_string because string view is a view, not the copy of original string.
+
+Same as UTF8 string pointer, we also have YYCC::EncodingHelper::ToOrdinary and YYCC::EncodingHelper::ToOrdinaryView do correspondant reverse convertion.
+Try to do your own research and figure out how to use them.
+It's pretty easy.
+
+\section library_encoding__windows Warnings to Windows Programmer
+
+Due to the legacy of MSVC, the encoding of \c char* may not be UTF8 in most cases.
+If you run the convertion code introduced in this article with the string which is not encoded with UTF8, it may cause undefined behavior.
+
+To enable UTF8 mode of MSVC, please deliver \c /utf-8 switch to MSVC.
+Thus you can use the functions introduced in this article safely.
+Otherwise, you must guarteen that the argument you provided to these functions is encoded by UTF8 manually.
+
+Linux user do not need care this.
+Because almost Linux distro use UTF8 in default.
+
+*/

doc/src/parser_helper.dox

@@ -0,0 +1,80 @@
+/**
+
+\page parser_helper Parser Helper
+
+This helper is served for the convertion between number and string.
+
+\section parser_helper_supported_types Supported Types
+
+Functions located in this helper support the convertion between string and following types:
+
+\li Integral types (except \c bool): \c int, \c uint32_t, \c char and etc.
+\li Floating point types: \c float, \c double and etc.
+\li \c bool
+
+Please note in C++, \c bool is integral type but we list it individually because parser will treat it specially.
+For \c bool type, parser will try doing convertion between it and \c "true" \c "false" string.
+(\b case-sensitive. It means that \c true will only be converted to \c "true" and \c "TRUE" can not be recognised.)
+
+\section parser_helper__try_parse Try Parse
+
+YYCC::ParserHelper::TryParse will try to parse string into caller specified type.
+All of them accept an UTF8 string view at first argument,
+require that you provide a container receiving converted result in the second argument,
+and return a bool value to indicate whether the convertion is successful.
+There are some examples:
+
+\code
+uint32_t val;
+YYCC::ParserHelper::TryParse<uint32_t>(YYCC_U8("123"), val);
+YYCC::ParserHelper::TryParse<uint32_t>(YYCC_U8("7fff"), val, 16);
+\endcode
+
+For integral type, this function allows caller to specify extra argument providing the base of given number string.
+
+\section parser_helper__parse Parse
+
+YYCC::ParserHelper::Parse is similar to YYCC::ParserHelper::TryParse.
+But it will not return bool value to indicate success and doesn't have the argument receiving result.
+It only accepts an UTF8 string view as the only one argument, and return result directly.
+If the convertion failed, the return value is \b undefined (but usually is the default value of given type).
+There is an example:
+
+\code
+uint32_t val = YYCC::ParserHelper::Parse<uint32_t>(YYCC_U8("123"));
+\endcode
+
+Please note, for integral types, there is no base argument in YYCC::ParserHelper::Parse.
+Please use YYCC::ParserHelper::TryParse instead.
+
+Using this function is dangerous if the validation of your input is important.
+In this case, please use YYCC::ParserHelper::TryParse instead.
+
+\section parser_helper__to_string To String
+
+YYCC::ParserHelper::ToString basically is the reversed operation of YYCC::ParserHelper::Parse.
+It gets the string representation of given type.
+The only argument of these functions is the type which need to be converted to its string representation.
+And they will return yycc_u8string as result.
+There is an example:
+
+\code
+auto result = YYCC::ParserHelper::ToString<uint32_t>(UINT32_C(114));
+\endcode
+
+\section parser_helper__notes Notes
+
+All functions within this helper are implementated by standard library functions.
+These functions just make a good wrapper for complex standard library functions.
+And give you a experience like C\# parser functions.
+
+Basically, all functions located in this helper have possibility to throw exception.
+But this possibility are more close to the possibility that \c new statement throw \c std::bad_alloc.
+So in most cases you can assume these functions will not throw any exception.
+
+All functions are template functions.
+The argument of template is the type these functions need to be processed.
+Although C++ have \e smart template type deduction, 
+it would be better to specify template argument manually to explicitly specify your desired type.
+
+*/

doc/src/platform_checker.dox

@@ -0,0 +1,35 @@
+/**
+
+\page platform_checker Platform Checker
+
+In many cross platform applications, 
+programmer usually write code adapted to different platforms in one source file 
+and enable them respectively by macros representing the target platform.
+As a cross platform library,
+YYCC also has this feature and you can utilize it if you don't have other ways to so the same things.
+
+\section platform_checker__values Values
+
+YYCC always define a macro called \c YYCC_OS to indicate the system of target platform.
+In implementation, it will check following list from top to bottom to set matched value for it.
+
+\li \c YYCC_OS_WINDOWS: Windows environment. It is done by checking whether environment define \c _WIN32 macro.
+\li \c YYCC_OS_LINUX: In current implementation, this means target platform is \b NOT Windows.
+
+\section platform_checker__usage Usage
+
+Now you know any possible value of \c YYCC_OS.
+The next step is how to use it to enable specified code in specific target platform.
+We take Windows platform for example.
+Assume \c blabla() function is Windows specific.
+We have following example code:
+
+\code
+#if YYCC_OS == YYCC_OS_WINDOWS
+blabla();
+#endif
+\endcode
+
+It's enough and simple that use \c \#if to bracket the Windows specified code.
+
+*/

doc/src/string_helper.dox

@@ -0,0 +1,139 @@
+/**
+
+\page string_helper String Helper
+
+\section string_helper__printf Printf VPrintf
+
+YYCC::StringHelper provides 4 functions for formatting string.
+These functions are mainly provided to programmer who can not use C++ 20 \c std::format feature.
+
+\code
+bool Printf(yycc_u8string&, const yycc_char8_t*, ...);
+bool VPrintf(yycc_u8string&, const yycc_char8_t*, va_list argptr);
+yycc_u8string Printf(const yycc_char8_t*, ...);
+yycc_u8string VPrintf(const yycc_char8_t*, va_list argptr);
+\endcode
+
+YYCC::StringHelper::Printf and YYCC::StringHelper::VPrintf is similar to \c std::sprintf and \c std::vsprintf.
+YYCC::StringHelper::Printf accepts UTF8 format string and variadic arguments specifying data to print.
+This is commonly used by programmer.
+However, YYCC::StringHelper::VPrintf also do the same work but its second argument is \c va_list, 
+the representation of variadic arguments.
+It is mostly used by other function which has variadic arguments.
+
+The only difference between these function and standard library functions is 
+that you don't need to worry about whether the space of given buffer is enough,
+because these functions help you to calculate this internally.
+
+There is the same design like we introduced in \ref encoding_helper.
+There are 2 overloads for YYCC::StringHelper::Printf and YYCC::StringHelper::VPrintf respectively.
+First overload return bool value and require a string container as argument for storing result.
+The second overload return result string directly.
+As you expected, first overload will return false if fail to format string (this is barely happened).
+and second overload will return empty string when formatter failed.
+
+\section string_helper__replace Replace
+
+YYCC::StringHelper provide 2 functions for programmer do string replacement:
+
+\code
+void Replace(yycc_u8string&, const yycc_char8_t*, const yycc_char8_t*);
+yycc_u8string Replace(const yycc_char8_t*, const yycc_char8_t*, const yycc_char8_t*);
+\endcode
+
+The first overload will do replacement in given string container directly.
+The second overload will produce a copy of original string and do replacement on the copied string.
+
+YYCC::StringHelper::Replace has special treatments for following scenarios:
+
+\li If given string is empty or nullptr, the return value will be empty.
+\li If the character sequence to be replaced is nullptr or empty string, no replacement will happen.
+\li If the character sequence will be replaced into string is nullptr or empty, it will simply delete found character sequence from given string.
+
+\section string_helper__join Join
+
+YYCC::StringHelper provide an universal way for joining string and various specialized join functions.
+
+\subsection string_helper__join__universal Universal Join Function
+
+Because C++ list types are various.
+There is no unique and convenient way to create an universal join function.
+So we create YYCC::StringHelper::JoinDataProvider to describe join context.
+
+Before using universal join function,
+you should setup YYCC::StringHelper::JoinDataProvider first, the context of join function.
+It actually is an \c std::function object which can be easily fetched by C++ lambda syntax.
+This function pointer accept a reference to \c yycc_u8string_view,
+programmer should set it to the string to be joined when at each calling.
+And this function pointer return a bool value to indicate the end of join.
+You can simply return \c false to terminate join process.
+The argument you assigned to argument will not be taken into join process when you return false.
+
+Then, you can pass the created YYCC::StringHelper::JoinDataProvider object to YYCC::StringHelper::Join function.
+And specify decilmer at the same time.
+Then you can get the final joined string.
+There is an example:
+
+\code
+std::vector<yycc_u8string> data {
+    YYCC_U8(""), YYCC_U8("1"), YYCC_U8("2"), YYCC_U8("")
+};
+auto iter = data.cbegin();
+auto stop = data.cend();
+auto joined_string = YYCC::StringHelper::Join(
+    [&iter, &stop](yycc_u8string_view& view) -> bool {
+        if (iter == stop) return false;
+        view = *iter;
+        ++iter;
+        return true;
+    }, 
+    decilmer
+);
+\endcode
+
+\subsection string_helper__join__specialized Specialized Join Function
+
+Despite universal join function, 
+YYCC::StringHelper also provide some specialized join functions for commonly used types.
+Current we support following join function:
+
+\li \c std::vector<yycc_u8string>: With an extra option which allow join it with reversed order.
+
+\section string_helper__lower_upper Lower Upper
+
+String helper provides Python-like string lower and upper function.
+Both lower and upper function have 2 overloads:
+
+\code
+yycc_u8string Lower(const yycc_char8_t*);
+void Lower(yycc_u8string&);
+\endcode
+
+First overload accepts a NULL-terminated string as argument and return a \b copy whose content are all the lower case of original string.
+Second overload accepts a mutable string container as argument and will make all characters stored in it become their lower case.
+You can choose on of them for your flavor and requirements.
+Upper also has similar 2 overloads.
+
+\section string_helper__split Split
+
+String helper provides Python-like string split function.
+It has 2 types for you:
+
+\code
+std::vector<yycc_u8string> Split(const yycc_u8string_view&, const yycc_char8_t*);
+std::vector<yycc_u8string_view> SplitView(const yycc_u8string_view&, const yycc_char8_t*);
+\endcode
+
+All these overloads take a string view as the first argument representing the string need to be split.
+The second argument is a raw string pointer representing the decilmer for splitting.
+The only difference between these 2 split function are overt according to their names.
+The first split function will return a list of copied string as its split result.
+The second split function will return a list of string view as its split result,
+and it will keep valid as long as the life time of your given string view argument.
+It also means that the last overload will cost less memory if you don't need the copy of original string.
+
+If the source string (the string need to be split) is empty, or the decilmer is \c nullptr or empty,
+the result will only has 1 item and this item is source string itself.
+There is no way that these methods return an empty list, except the code is buggy.
+
+*/

doc/src/win_fct_helper.dox

@@ -0,0 +1,17 @@
+/**
+
+\page win_fct_helper Windows Function Helper
+
+This helper give a more convenient way to call Windows functions.
+
+This namespace is Windows specific.
+It will be entirely invisible in other platforms.
+
+Currently this namespace has following functions:
+
+\li YYCC::WinFctHelper::GetCurrentModule: Get the handle to current module.
+\li YYCC::WinFctHelper::GetTempDirectory: Get temporary directory in Windows.
+\li YYCC::WinFctHelper::GetModuleFileName: Get the path to module in file system by given handle.
+\li YYCC::WinFctHelper::GetLocalAppData: Get the path inside \%LOCALAPPDATA\%
+
+*/

doc/src/win_import.dox

@@ -0,0 +1,69 @@
+/**
+
+\page win_import Windows Import Guard
+
+Windows is shitty for the programmer who is familiar with UNIX programming.
+Due to legacy reason, Windows defines various things which are not compatible with UNIX or standard C++ programming.
+
+\section win_import__usage Usage
+
+YYCC has a way to solve the issue introduced above.
+
+\code
+#if YYCC_OS == YYCC_OS_WINDOWS
+#include <WinImportPrefix.hpp>
+#include <Windows.h>
+#include "other_header_depend_on_windows.h"
+#include <WinImportSuffix.hpp>
+#endif
+\endcode
+
+The including of WinImportPrefix.hpp and WinImportSuffix.hpp is a pair.
+They just like a guard bracket the include operation of Windows related headers,
+to keep all Windows shitty contents will not be leaked outside.
+
+This guard can solve following issues:
+
+<UL>
+    <LI>
+    Programmer can not use \c std::max and \c std::min normally.
+    <UL>
+        <LI>Windows defines \c MAX and \c MIN as macros for personal use. This is why this happened.</LI>
+        <LI>Guard defines some special macros to tell Windows do not create these 2 macros.</LI>
+    </UL>
+    </LI>
+    <LI>
+    Programmer will not be affected by the automatical rename of \c GetObject, \c GetClassName and etc.
+    <UL>
+        <LI>These are all macros for Windows personal use to automatically redirect calling to A function and W function by compiling environment.</LI>
+        <LI>Guard \c \#undef these annoy macros.</LI>
+    </UL>
+    </LI>
+    <LI>
+    Compiler throw annoy warnings and errors when using specific standard library functions.
+    <UL>
+        <LI>MSVC will throw warnings and errors when you are using Microsoft so-called \e depracted or \e unsafe standard library functions.</LI>
+        <LI>YYCCInternal.hpp, which has been included by this pair, defines some macros to purge these warnings and errors out.</LI>
+    </UL>
+    </LI>
+</UL>
+
+\section win_import__notes Notes
+
+If you have other header files which are strongly depend on Windows header,
+you should put them into this bracket at the same time like example did.
+Because this guard operate some Windows macros as we introduced above.
+The headers depending on Windows may throw error if you put them outside of this pair.
+
+Please note WinImportPrefix.hpp and WinImportSuffix.hpp can be included multiple times.
+Because they do not have the proprocessor command like <I>\#pragma once</I> or etc to make sure they only can be included once.
+That's by design. Because we actually may use this pair multiple times.
+The only thing you should pledge is that you must make sure they are presented by pair.
+
+This guard is Windows specific.
+It does nothing if you accidently use it in other platforms such as Linux,
+because the headers use \c \#if to check environment out and will do nothing in non-Windows environment.
+However, we still highly recommend you use this pair with platform checker bracket like example does,
+if your program need to be run on multiple platforms.
+
+*/

script/build.bat

@@ -1,35 +0,0 @@
-@ECHO OFF
-SET README_PATH=%CD%\README.md
-IF EXIST %README_PATH% (
-    REM DO NOTHING
-) ELSE (
-    ECHO Error: You must run this script at the root folder of this project!
-    EXIT /b
-)
-
-:: Create essential folder
-MKDIR bin
-CD bin
-MKDIR Win32
-MKDIR x64
-MKDIR install
-
-:: Build for Win32
-CD Win32
-cmake -G "Visual Studio 16 2019" -A Win32 -DYYCC_BUILD_TESTBENCH=ON ../..
-cmake --build . --config Debug
-cmake --install . --prefix=../install --config Debug
-cmake --build . --config Release
-cmake --install . --prefix=../install --config Release
-CD ..
-
-:: Build for x64
-CD x64
-cmake -G "Visual Studio 16 2019" -A x64 -DYYCC_BUILD_TESTBENCH=ON ../..
-cmake --build . --config Debug
-cmake --install . --prefix=../install --config Debug
-cmake --build . --config Release
-cmake --install . --prefix=../install --config Release
-CD ..
-
-ECHO DONE

script/linux_build.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+README_PATH=$(pwd)/README.md
+if [ ! -f "$README_PATH" ]; then
+    echo "Error: You must run this script at the root folder of this project!"
+    exit
+fi
+
+# Create main binary directory
+mkdir bin
+cd bin
+# Create build directory
+mkdir build
+# Create install directory
+mkdir install
+cd install
+mkdir Debug
+mkdir Release
+cd ..
+
+# Build current system debug and release version
+cd build
+cmake -DCMAKE_BUILD_TYPE=Debug ../.. --fresh
+cmake --build .
+cmake --install . --prefix ../install/Debug
+cmake -DCMAKE_BUILD_TYPE=Release -DYYCC_BUILD_TESTBENCH=ON ../.. --fresh
+cmake --build .
+cmake --install . --prefix ../install/Release
+cd ..
+
+# Exit to original path
+cd ..
+echo "Linux CMake Build Done"

script/win_build.bat

@@ -0,0 +1,54 @@
+@ECHO OFF
+SET README_PATH=%CD%\README.md
+IF EXIST %README_PATH% (
+    REM DO NOTHING
+) ELSE (
+    ECHO Error: You must run this script at the root folder of this project!
+    EXIT /b
+)
+
+:: Create main binary directory
+MKDIR bin
+CD bin
+:: Create build folder
+MKDIR Win32
+MKDIR x64
+MKDIR documentation
+:: Create install folder
+MKDIR install
+CD install
+MKDIR Win32_Debug
+MKDIR Win32_Release
+MKDIR x64_Debug
+MKDIR x64_Release
+CD ..
+
+:: Build for Win32
+CD Win32
+cmake -G "Visual Studio 16 2019" -A Win32 -DYYCC_BUILD_TESTBENCH=ON ../..
+cmake --build . --config Debug
+cmake --install . --prefix=../install/Win32_Debug --config Debug
+cmake --build . --config Release
+cmake --install . --prefix=../install/Win32_Release --config Release
+CD ..
+
+:: Build for x64
+CD x64
+cmake -G "Visual Studio 16 2019" -A x64 -DYYCC_BUILD_TESTBENCH=ON ../..
+cmake --build . --config Debug
+cmake --install . --prefix=../install/x64_Debug --config Debug
+cmake --build . --config Release
+cmake --install . --prefix=../install/x64_Release --config Release
+CD ..
+
+:: Build for documentation
+CD documentation
+cmake -G "Visual Studio 16 2019" -A x64 -DYYCC_BUILD_DOC=ON ../..
+cmake --build . --config Release
+cmake --build . --target YYCCDocumentation
+cmake --install . --prefix=../install/x64_Release --config Release
+CD ..
+
+:: Exit to original path
+CD ..
+ECHO Windows CMake Build Done

script/win_msvc_build.bat

@@ -0,0 +1,50 @@
+@ECHO OFF
+SET README_PATH=%CD%\README.md
+IF EXIST %README_PATH% (
+    REM DO NOTHING
+) ELSE (
+    ECHO Error: You must run this script at the root folder of this project!
+    EXIT /b
+)
+
+:: Enter main binary directory
+CD bin
+
+:: Create MSVC binary directory
+MKDIR msvc_install
+CD msvc_install
+:: Create direcotries tree
+MKDIR bin
+MKDIR include
+MKDIR lib
+MKDIR share
+CD bin
+MKDIR Win32
+MKDIR x64
+CD ..
+CD lib
+MKDIR Win32\Debug
+MKDIR Win32\Release
+MKDIR x64\Debug
+MKDIR x64\Release
+CD ..
+:: Exit MSVC binary directory
+CD ..
+
+:: Copy result
+:: Copy include from x64_Release build
+XCOPY install\x64_Release\include msvc_install\include\ /E /Y
+:: Copy document from x64_Release build
+XCOPY install\x64_Release\share msvc_install\share\ /E /Y
+:: Copy binary testbench
+COPY install\Win32_Release\bin\YYCCTestbench.exe msvc_install\bin\Win32\YYCCTestbench.exe /Y
+COPY install\x64_Release\bin\YYCCTestbench.exe msvc_install\bin\x64\YYCCTestbench.exe /Y
+:: Copy static library
+COPY install\Win32_Debug\lib\YYCCommonplace.lib msvc_install\lib\Win32\Debug\YYCCommonplace.lib /Y
+COPY install\Win32_Release\lib\YYCCommonplace.lib msvc_install\lib\Win32\Release\YYCCommonplace.lib /Y
+COPY install\x64_Debug\lib\YYCCommonplace.lib msvc_install\lib\x64\Debug\YYCCommonplace.lib /Y
+COPY install\x64_Release\lib\YYCCommonplace.lib msvc_install\lib\x64\Release\YYCCommonplace.lib /Y
+
+:: Exit to original path
+CD ..
+ECHO Windows MSVC Build Done

src/CMakeLists.txt

@@ -5,6 +5,7 @@ target_sources(YYCCommonplace
 PRIVATE
     # Sources
     COMHelper.cpp
+    ConfigManager.cpp
     ConsoleHelper.cpp
     DialogHelper.cpp
     EncodingHelper.cpp
@@ -13,6 +14,8 @@ PRIVATE
     IOHelper.cpp
     StringHelper.cpp
     WinFctHelper.cpp
+    # Natvis (only for MSVC)
+    $<$<CXX_COMPILER_ID:MSVC>:YYCC.natvis>
 )
 target_sources(YYCCommonplace 
 PUBLIC
@@ -21,6 +24,7 @@ FILES
     # Headers
     # Common headers
     COMHelper.hpp
+    ConfigManager.hpp
     ConsoleHelper.hpp
     DialogHelper.hpp
     EncodingHelper.hpp
@@ -70,8 +74,8 @@ PRIVATE
 # Install binary and headers
 install(TARGETS YYCCommonplace
     EXPORT YYCCommonplaceTargets
-    LIBRARY DESTINATION ${YYCC_INSTALL_PATH_LIB}
-    ARCHIVE DESTINATION ${YYCC_INSTALL_PATH_LIB}
-    INCLUDES DESTINATION include
-    FILE_SET HEADERS DESTINATION include
+    LIBRARY DESTINATION ${YYCC_INSTALL_LIB_PATH}
+    ARCHIVE DESTINATION ${YYCC_INSTALL_LIB_PATH}
+    INCLUDES DESTINATION ${YYCC_INSTALL_INCLUDE_PATH}
+    FILE_SET HEADERS DESTINATION ${YYCC_INSTALL_INCLUDE_PATH}
 )

src/COMHelper.hpp

@@ -10,29 +10,16 @@
 #include "WinImportSuffix.hpp"
 
 /**
- * @brief COM fucntions related namespace.
+ * @brief Windows COM related types and checker.
  * @details
- * This namespace is Windows specific and is unavailable on other platforms.
+ * This namespace is Windows specific.
+ * In other platforms, this whole namespace will be unavailable.
  * 
- * This namespace contain a COM Guard which make sure COM was initialized in current module when loading current module.
- * It is essential because all calling to COM functions should be under the premise that COM has been initialized.
- * This guard also will uninitialize COM when unloading this module.
- * 
- * This namespace also provided various memory-safe types for interacting with COM functions.
- * Although Microsoft also has similar smart pointer called \c CComPtr.
- * But this library is eager to hide all Microsoft-related functions calling.
- * Using \c CComPtr is not corresponding with the philosophy of this library.
- * So these std-based smart pointer type were created.
- * 
- * This namespace is used by internal functions as intended.
- * They should not be used outside of this library.
- * But if you compel to use them, it is also okey.
+ * See also \ref com_helper.
 */
 namespace YYCC::COMHelper {
 
-	/**
-	 * @brief C++ standard deleter for every COM interfaces inheriting IUnknown.
-	*/
+	/// @brief C++ standard deleter for every COM interfaces inheriting IUnknown.
 	class ComPtrDeleter {
 	public:
 		ComPtrDeleter() {}
@@ -43,15 +30,18 @@ namespace YYCC::COMHelper {
 		}
 	};
 
+	/// @brief Smart unique pointer of \c IFileDialog
 	using SmartIFileDialog = std::unique_ptr<IFileDialog, ComPtrDeleter>;
+	/// @brief Smart unique pointer of \c IFileOpenDialog
 	using SmartIFileOpenDialog = std::unique_ptr<IFileOpenDialog, ComPtrDeleter>;
+	/// @brief Smart unique pointer of \c IShellItem
 	using SmartIShellItem = std::unique_ptr<IShellItem, ComPtrDeleter>;
+	/// @brief Smart unique pointer of \c IShellItemArray
 	using SmartIShellItemArray = std::unique_ptr<IShellItemArray, ComPtrDeleter>;
+	/// @brief Smart unique pointer of \c IShellFolder
 	using SmartIShellFolder = std::unique_ptr<IShellFolder, ComPtrDeleter>;
 
-	/**
-	 * @brief C++ standard deleter for almost raw pointer used in COM which need to be free by CoTaskMemFree()
-	*/
+	/// @brief C++ standard deleter for almost raw pointer used in COM which need to be free by CoTaskMemFree()
 	class CoTaskMemDeleter {
 	public:
 		CoTaskMemDeleter() {}
@@ -61,7 +51,8 @@ namespace YYCC::COMHelper {
 			}
 		}
 	};
-
+	
+	/// @brief Smart unique pointer of COM created \c WCHAR sequence.
 	using SmartLPWSTR = std::unique_ptr<std::remove_pointer_t<LPWSTR>, CoTaskMemDeleter>;
 
 	/**

src/ConfigManager.cpp

@@ -0,0 +1,153 @@
+#include "ConfigManager.hpp"
+
+#include "EncodingHelper.hpp"
+#include "IOHelper.hpp"
+#include <stdexcept>
+
+namespace YYCC::ConfigManager {
+
+#pragma region Core Manager
+
+	CoreManager::CoreManager(
+		const yycc_char8_t* cfg_file_path,
+		uint64_t version_identifier,
+		std::initializer_list<AbstractSetting*> settings) :
+		m_CfgFilePath(), m_VersionIdentifier(version_identifier), m_Settings() {
+		// assign cfg path
+		if (cfg_file_path != nullptr)
+			m_CfgFilePath = cfg_file_path;
+		// assign settings
+		for (auto* setting : settings) {
+			auto result = m_Settings.try_emplace(setting->GetName(), setting);
+			if (!result.second) {
+				// if not inserted because duplicated, raise exception
+				throw std::invalid_argument("Duplicated setting name");
+			}
+		}
+	}
+
+	bool CoreManager::Load() {
+		// reset all settings first
+		Reset();
+
+		// get file handle
+		auto fs = this->GetFileHandle(YYCC_U8("rb"));
+		if (fs.get() == nullptr) {
+			// if we fail to get, it means that we do not have corresponding cfg file.
+			// all settings should be reset to default value.
+			return true;
+		}
+
+		// fetch version info
+		uint64_t version_info;
+		if (std::fread(&version_info, 1u, sizeof(version_info), fs.get()) != sizeof(version_info))
+			return false;
+		// check version
+		// if read version is greater than we expected,
+		// it means that this cfg file is created by the program higer than this.
+		// we should not read anything from it.
+		// however, for compaitibility reason, we allow read old cfg data.
+		if (version_info > m_VersionIdentifier)
+			return true;
+
+		// fetch setting item from file
+		yycc_u8string name_cache;
+		while (true) {
+			// try fetch setting name
+			// fetch name length
+			size_t name_length;
+			if (std::fread(&name_length, 1u, sizeof(name_length), fs.get()) != sizeof(name_length)) {
+				// we also check whether reach EOF at there.
+				if (std::feof(fs.get())) break;
+				else return false;
+			}
+			// fetch name body
+			name_cache.resize(name_length);
+			if (std::fread(name_cache.data(), 1u, name_length, fs.get()) != name_length)
+				return false;
+
+			// get setting data length
+			size_t data_length;
+			if (std::fread(&data_length, 1u, sizeof(data_length), fs.get()) != sizeof(data_length))
+				return false;
+
+			// get matched setting first
+			const auto& found = m_Settings.find(name_cache);
+			if (found != m_Settings.end()) {
+				// found. read data for it
+				found->second->ResizeData(data_length);
+				if (std::fread(found->second->GetDataPtr(), 1u, data_length, fs.get()) != data_length)
+					return false;
+				// call user defined load function
+				// if fail to parse, reset to default value
+				if (!found->second->UserLoad())
+					found->second->UserReset();
+			} else {
+				// fail to find. skip this unknown setting
+				if (fseek(fs.get(), static_cast<long>(data_length), SEEK_CUR) != 0)
+					return false;
+			}
+		}
+
+		return true;
+	}
+
+	bool CoreManager::Save() {
+		// get file handle
+		auto fs = this->GetFileHandle(YYCC_U8("wb"));
+		// if we fail to get, return false.
+		if (fs == nullptr) return false;
+
+		// write config data
+		uint64_t version_info = m_VersionIdentifier;
+		if (std::fwrite(&version_info, 1u, sizeof(version_info), fs.get()) != sizeof(version_info))
+			return false;
+
+		// iterate all data for writing
+		for (const auto& pair : m_Settings) {
+			// do user defined save
+			// if failed, skip this setting
+			if (!pair.second->UserSave())
+				continue;
+
+			// write setting name
+			// write name length
+			size_t name_length = pair.first.size();
+			if (std::fwrite(&name_length, 1u, sizeof(name_length), fs.get()) != sizeof(name_length))
+				return false;
+			// write name body
+			if (std::fwrite(pair.first.c_str(), 1u, name_length, fs.get()) != name_length)
+				return false;
+
+			// write setting daat
+			// write data length
+			size_t data_length = pair.second->GetDataSize();
+			if (std::fwrite(&data_length, 1u, sizeof(data_length), fs.get()) != sizeof(data_length))
+				return false;
+			// write data body
+			if (std::fwrite(pair.second->GetDataPtr(), 1u, data_length, fs.get()) != data_length)
+				return false;
+		}
+
+		// all settings done, return true
+		return true;
+	}
+
+	void CoreManager::Reset() {
+		for (const auto& pair : m_Settings) {
+			pair.second->UserReset();
+		}
+	}
+
+	CoreManager::FileHandleGuard_t CoreManager::GetFileHandle(const yycc_char8_t* mode) const {
+		return CoreManager::FileHandleGuard_t(
+			IOHelper::UTF8FOpen(this->m_CfgFilePath.c_str(), mode),
+			[](FILE* fs) -> void {
+				if (fs != nullptr) std::fclose(fs);
+			}
+		);
+	}
+
+#pragma endregion
+
+}

src/ConfigManager.hpp

@@ -0,0 +1,288 @@
+#pragma once
+#include "YYCCInternal.hpp"
+
+#include <memory>
+#include <vector>
+#include <map>
+#include <initializer_list>
+#include <type_traits>
+#include <algorithm>
+#include <functional>
+#include <stdexcept>
+#include <cstring>
+
+/**
+ * @brief Universal configuration manager
+ * @details For how to use this namespace, please see \ref config_manager.
+*/
+namespace YYCC::ConfigManager {
+
+	/**
+	 * @brief The constraint applied to settings to limit its stored value.
+	 * @tparam _Ty The internal data type stroed in corresponding setting.
+	*/
+	template<typename _Ty>
+	struct Constraint {
+		using CheckFct_t = std::function<bool(const _Ty&)>;
+		//using CorrectFct_t = std::function<_Ty(const _Ty&)>;
+		CheckFct_t m_CheckFct;
+		//CorrectFct_t m_CorrectFct;
+
+		bool IsValid() const {
+			return m_CheckFct != nullptr/* && m_CorrectFct != nullptr*/;
+		}
+	};
+
+	/**
+	 * @brief The namespace containing functions generating common used constraint.
+	*/
+	namespace ConstraintPresets {
+
+		/**
+		 * @brief Get constraint for arithmetic values by minimum and maximum value range.
+		 * @tparam _Ty The underlying arithmetic type.
+		 * @param[in] min_value The minimum value of range (inclusive).
+		 * @param[in] max_value The maximum value of range (inclusive).
+		 * @return The generated constraint instance which can be directly applied.
+		*/
+		template<typename _Ty, std::enable_if_t<std::is_arithmetic_v<_Ty> && !std::is_enum_v<_Ty> && !std::is_same_v<_Ty, bool>, int> = 0>
+		Constraint<_Ty> GetNumberRangeConstraint(_Ty min_value, _Ty max_value) {
+			if (min_value > max_value)
+				throw std::invalid_argument("invalid min max value for NumberRangeConstraint");
+			return Constraint<_Ty> {
+				[min_value, max_value](const _Ty& val) -> bool { return (val <= max_value) && (val >= min_value); }
+					/*[min_value, max_value](const _Ty& val) -> _Ty { return std::clamp(val, min_value, max_value); }*/
+			};
+		}
+
+	}
+
+	/// @brief The base class of every setting.
+	/// @details Programmer can inherit this class and implement essential to create custom setting.
+	class AbstractSetting {
+		friend class CoreManager;
+	public:
+		/**
+		 * @brief Construct a setting
+		 * @param[in] name The name of this setting.
+		*/
+		AbstractSetting(const yycc_char8_t* name) : m_Name(), m_RawData() {
+			if (name != nullptr) m_Name = name;
+		}
+		virtual ~AbstractSetting() {}
+
+		// Name interface
+	public:
+		/// @brief Get name of this setting.
+		/// @details Name was used in storing setting in file.
+		const yycc_u8string& GetName() const { return m_Name; }
+	private:
+		yycc_u8string m_Name;
+
+		// User Implementations
+	protected:
+		/// @brief User implemented custom load functions
+		/// @remarks 
+		/// In this function, programmer should read data from internal buffer 
+		/// and store it to its own another internal variables.
+		/// @return True if success, otherwise false.
+		virtual bool UserLoad() = 0;
+		/// @brief User implemented custom save functions
+		/// @remarks 
+		/// In this function, programmer should write data, 
+		/// which is stored in another variavle by it own, to internal buffer.
+		/// @return True if success, otherwise false.
+		virtual bool UserSave() = 0;
+		/// @brief User implemented custom reset functions
+		/// @remarks In this function, programmer should reset its internal variable to default value.
+		virtual void UserReset() = 0;
+
+		// Buffer related functions
+	protected:
+		/// @brief Resize internal buffer to given size.
+		/// @remarks It is usually used in UserSave.
+		/// @param[in] new_size The new size of internal buffer.
+		void ResizeData(size_t new_size) { m_RawData.resize(new_size); }
+		/// @brief Get data pointer to internal buffer.
+		/// @remarks It is usually used in UserLoad.
+		const void* GetDataPtr() const { return m_RawData.data(); }
+		/// @brief Get mutable data pointer to internal buffer.
+		/// @remarks It is usually used in UserSave.
+		void* GetDataPtr() { return m_RawData.data(); }
+		/// @brief Get the length of internal buffer.
+		size_t GetDataSize() const { return m_RawData.size(); }
+	private:
+		std::vector<uint8_t> m_RawData;
+	};
+	
+	/// @brief Settings manager and config file reader writer.
+	class CoreManager {
+	public:
+		/**
+		 * @brief Build core manager.
+		 * @param[in] cfg_file_path The path to config file.
+		 * @param[in] version_identifier The identifier of version. Higher is newer. Lower config will try doing migration.
+		 * @param[in] settings An initializer list containing pointers to all managed settings.
+		*/
+		CoreManager(
+			const yycc_char8_t* cfg_file_path,
+			uint64_t version_identifier,
+			std::initializer_list<AbstractSetting*> settings);
+		~CoreManager() {}
+
+		// Core functions
+	public:
+		/// @brief Load settings from file.
+		/// @details Before loading, all settings will be reset to default value first.
+		/// @return True if success, otherwise false.
+		bool Load();
+		/// @brief Save settings to file.
+		/// @return True if success, otherwise false.
+		bool Save();
+		/// @brief Reset all settings to default value.
+		void Reset();
+
+	private:
+		using FileHandleGuard_t = std::unique_ptr<FILE, std::function<void(FILE*)>>;
+		FileHandleGuard_t GetFileHandle(const yycc_char8_t* mode) const;
+
+		yycc_u8string m_CfgFilePath;
+		uint64_t m_VersionIdentifier;
+		std::map<yycc_u8string, AbstractSetting*> m_Settings;
+	};
+
+#pragma region Setting Presets
+
+	/**
+	 * @brief Arithmetic (integral, floating point, bool) and enum type setting
+	 * @tparam _Ty The internal stored type belongs to arithmetic type.
+	*/
+	template<typename _Ty, std::enable_if_t<std::is_arithmetic_v<_Ty> || std::is_enum_v<_Ty>, int> = 0>
+	class NumberSetting : public AbstractSetting {
+	public:
+		/**
+		 * @brief Construct arithmetic type setting.
+		 * @param[in] name The name of this setting.
+		 * @param[in] default_value The default value of this setting.
+		 * @param[in] constraint The constraint applied to this setting.
+		*/
+		NumberSetting(const yycc_char8_t* name, _Ty default_value, Constraint<_Ty> constraint = Constraint<_Ty> {}) :
+			AbstractSetting(name), m_Data(default_value), m_DefaultData(default_value), m_Constraint(constraint) {}
+		virtual ~NumberSetting() {}
+		
+		/// @brief Get stored data in setting.
+		_Ty Get() const { return m_Data; }
+		/**
+		 * @brief Set data to setting.
+		 * @param[in] new_data The new data.
+		 * @return True if success, otherwise false (given value is invalid)
+		*/
+		bool Set(_Ty new_data) {
+			// validate data
+			if (m_Constraint.IsValid() && !m_Constraint.m_CheckFct(new_data))
+				return false;
+			// assign data
+			m_Data = new_data;
+			return true;
+		}
+
+	protected:
+		virtual bool UserLoad() override {
+			// read data
+			if (sizeof(m_Data) != GetDataSize())
+				return false;
+			m_Data = *reinterpret_cast<const _Ty*>(GetDataPtr());
+			// check data
+			if (m_Constraint.IsValid() && !m_Constraint.m_CheckFct(m_Data))
+				return false;
+			return true;
+		}
+		virtual bool UserSave() override {
+			// write data
+			ResizeData(sizeof(m_Data));
+			*reinterpret_cast<_Ty*>(GetDataPtr()) = m_Data;
+			return true;
+		}
+		virtual void UserReset() override {
+			m_Data = m_DefaultData;
+		}
+
+		_Ty m_Data, m_DefaultData;
+		Constraint<_Ty> m_Constraint;
+	};
+
+	/// @brief String type setting
+	class StringSetting : public AbstractSetting {
+	public:
+		/**
+		 * @brief Construct string setting
+		 * @param[in] name The name of this setting.
+		 * @param[in] default_value The default value of this setting.
+		 * @param[in] constraint The constraint applied to this setting.
+		*/
+		StringSetting(const yycc_char8_t* name, const yycc_u8string_view& default_value, Constraint<yycc_u8string_view> constraint = Constraint<yycc_u8string_view> {}) :
+			AbstractSetting(name), m_Data(), m_DefaultData(), m_Constraint(constraint) {
+			m_Data = default_value;
+			m_DefaultData = default_value;
+		}
+		virtual ~StringSetting() {}
+		
+		/// @brief Get reference to stored string.
+		const yycc_u8string& Get() const { return m_Data; }
+		/**
+		 * @brief Set string data to setting.
+		 * @param[in] new_data The new string data.
+		 * @return True if success, otherwise false (given value is invalid)
+		*/
+		bool Set(const yycc_u8string_view& new_data) {
+			// check data validation
+			if (m_Constraint.IsValid() && !m_Constraint.m_CheckFct(new_data))
+				return false;
+			// assign data
+			m_Data = new_data;
+			return true;
+		}
+
+	protected:
+		virtual bool UserLoad() override {
+			// read string length
+			size_t string_length;
+			if (GetDataSize() < sizeof(string_length))
+				return false;
+			string_length = *reinterpret_cast<const size_t*>(GetDataPtr());
+			// read string body
+			if (GetDataSize() != sizeof(string_length) + string_length)
+				return false;
+			m_Data.assign(
+				reinterpret_cast<const yycc_char8_t*>(static_cast<const uint8_t*>(GetDataPtr()) + sizeof(string_length)),
+				string_length
+			);
+			// check data
+			if (m_Constraint.IsValid() && !m_Constraint.m_CheckFct(m_Data))
+				return false;
+			return true;
+		}
+		virtual bool UserSave() override {
+			// allocate result buffer
+			size_t string_length = m_Data.size();
+			ResizeData(sizeof(string_length) + string_length);
+			// get pointer
+			uint8_t* ptr = static_cast<uint8_t*>(GetDataPtr());
+			// assign string length
+			*reinterpret_cast<size_t*>(ptr) = string_length;
+			// assign string body
+			std::memcpy(ptr + sizeof(string_length), m_Data.data(), string_length);
+			return true;
+		}
+		virtual void UserReset() override {
+			m_Data = m_DefaultData;
+		}
+
+		yycc_u8string m_Data, m_DefaultData;
+		Constraint<yycc_u8string_view> m_Constraint;
+	};
+
+#pragma endregion
+
+
+}

src/ConsoleHelper.cpp

@@ -54,7 +54,7 @@ namespace YYCC::ConsoleHelper {
 	*/
 
 	template<bool _bIsConsole>
-	static std::string WinConsoleRead(HANDLE hStdIn) {
+	static yycc_u8string WinConsoleRead(HANDLE hStdIn) {
 		using _TChar = std::conditional_t<_bIsConsole, wchar_t, char>;
 
 		// Prepare an internal buffer because the read data may not be fully used.
@@ -113,21 +113,21 @@ namespace YYCC::ConsoleHelper {
 		}
 
 		// post-process for return value
-		std::string real_return_buffer;
+		yycc_u8string real_return_buffer;
 		if constexpr (_bIsConsole) {
 			// console mode need convert wchar to utf8
-			YYCC::EncodingHelper::WcharToUTF8(return_buffer.c_str(), real_return_buffer);
+			YYCC::EncodingHelper::WcharToUTF8(return_buffer, real_return_buffer);
 		} else {
 			// non-console just copt the result
-			real_return_buffer = return_buffer;
+			real_return_buffer = EncodingHelper::ToUTF8(return_buffer);
 		}
 		// every mode need delete \r words
-		YYCC::StringHelper::Replace(real_return_buffer, "\r", "");
+		YYCC::StringHelper::Replace(real_return_buffer, YYCC_U8("\r"), YYCC_U8(""));
 		// return value
 		return real_return_buffer;
 	}
 
-	static void WinConsoleWrite(const std::string& strl, bool to_stderr) {
+	static void WinConsoleWrite(const yycc_u8string& strl, bool to_stderr) {
 		// Prepare some Win32 variables
 		// fetch stdout handle first
 		HANDLE hStdOut = GetStdHandle(to_stderr ? STD_ERROR_HANDLE : STD_OUTPUT_HANDLE);
@@ -139,7 +139,7 @@ namespace YYCC::ConsoleHelper {
 		if (GetConsoleMode(hStdOut, &dwConsoleMode)) {
 			// console handle, use WriteConsoleW.
 			// convert utf8 string to wide char first
-			std::wstring wstrl(YYCC::EncodingHelper::UTF8ToWchar(strl.c_str()));
+			std::wstring wstrl(YYCC::EncodingHelper::UTF8ToWchar(strl));
 			size_t wstrl_size = wstrl.size();
 			// write string with size check
 			if (wstrl_size <= std::numeric_limits<DWORD>::max()) {
@@ -149,7 +149,7 @@ namespace YYCC::ConsoleHelper {
 			// anything else, use WriteFile instead.
 			// WriteFile do not need extra convertion, because it is direct writing.
 			// check whether string length is overflow
-			size_t strl_size = strl.size() * sizeof(std::string::value_type);
+			size_t strl_size = strl.size() * sizeof(yycc_u8string::value_type);
 			// write string with size check
 			if (strl_size <= std::numeric_limits<DWORD>::max()) {
 				WriteFile(hStdOut, strl.c_str(), static_cast<DWORD>(strl_size), &dwWrittenNumberOfChars, NULL);
@@ -176,7 +176,7 @@ namespace YYCC::ConsoleHelper {
 #endif
 	}
 
-	std::string ReadLine() {
+	yycc_u8string ReadLine() {
 #if YYCC_OS == YYCC_OS_WINDOWS
 
 		// get stdin mode
@@ -188,24 +188,24 @@ namespace YYCC::ConsoleHelper {
 		} else {
 			return WinConsoleRead<false>(hStdIn);
 		}
-
+		
 #else
 
 		// in linux, directly use C++ function to fetch.
 		std::string cmd;
 		if (std::getline(std::cin, cmd).fail()) cmd.clear();
-		return cmd;
+		return EncodingHelper::ToUTF8(cmd);
 
 #endif
 	}
 
 	template<bool bNeedFmt, bool bIsErr, bool bHasEOL>
-	static void RawWrite(const char* u8_fmt, va_list argptr) {
+	static void RawWrite(const yycc_char8_t* u8_fmt, va_list argptr) {
 		// Buiild string need to be written first
 		// If no format string or plain string for writing, return.
 		if (u8_fmt == nullptr) return;
 		// Build or simply copy string
-		std::string strl;
+		yycc_u8string strl;
 		if constexpr (bNeedFmt) {
 			// treat as format string
 			va_list argcpy;
@@ -218,62 +218,62 @@ namespace YYCC::ConsoleHelper {
 		}
 		// Checkout whether add EOL
 		if constexpr (bHasEOL) {
-			strl += "\n";
+			strl += YYCC_U8("\n");
 		}
-
+		
 #if YYCC_OS == YYCC_OS_WINDOWS
 		// call Windows specific writer
 		WinConsoleWrite(strl, bIsErr);
 #else
 		// in linux, directly use C function to write.
-		std::fputs(strl.c_str(), bIsErr ? stderr : stdout);
+		std::fputs(EncodingHelper::ToOrdinary(strl.c_str()), bIsErr ? stderr : stdout);
 #endif
 	}
 
-	void Format(const char* u8_fmt, ...) {
+	void Format(const yycc_char8_t* u8_fmt, ...) {
 		va_list argptr;
 		va_start(argptr, u8_fmt);
 		RawWrite<true, false, false>(u8_fmt, argptr);
 		va_end(argptr);
 	}
 
-	void FormatLine(const char* u8_fmt, ...) {
+	void FormatLine(const yycc_char8_t* u8_fmt, ...) {
 		va_list argptr;
 		va_start(argptr, u8_fmt);
 		RawWrite<true, false, true>(u8_fmt, argptr);
 		va_end(argptr);
 	}
 
-	void Write(const char* u8_strl) {
+	void Write(const yycc_char8_t* u8_strl) {
 		va_list empty{};
 		RawWrite<false, false, false>(u8_strl, empty);
 	}
 	
-	void WriteLine(const char* u8_strl) {
+	void WriteLine(const yycc_char8_t* u8_strl) {
 		va_list empty{};
 		RawWrite<false, false, true>(u8_strl, empty);
 	}
 	
-	void ErrFormat(const char* u8_fmt, ...) {
+	void ErrFormat(const yycc_char8_t* u8_fmt, ...) {
 		va_list argptr;
 		va_start(argptr, u8_fmt);
 		RawWrite<true, true, false>(u8_fmt, argptr);
 		va_end(argptr);
 	}
 
-	void ErrFormatLine(const char* u8_fmt, ...) {
+	void ErrFormatLine(const yycc_char8_t* u8_fmt, ...) {
 		va_list argptr;
 		va_start(argptr, u8_fmt);
 		RawWrite<true, true, true>(u8_fmt, argptr);
 		va_end(argptr);
 	}
 
-	void ErrWrite(const char* u8_strl) {
+	void ErrWrite(const yycc_char8_t* u8_strl) {
 		va_list empty{};
 		RawWrite<false, true, false>(u8_strl, empty);
 	}
 	
-	void ErrWriteLine(const char* u8_strl) {
+	void ErrWriteLine(const yycc_char8_t* u8_strl) {
 		va_list empty{};
 		RawWrite<false, true, true>(u8_strl, empty);
 	}

src/ConsoleHelper.hpp

@@ -5,171 +5,159 @@
 #include <string>
 
 /**
- * @brief The namespace providing universal Console visiting functions like C-Sharp Console class.
+ * @brief The helper providing universal C\# style console function and other console related stuff
  * @details
- * \par Why this Namespace
- * Windows console doesn't support UTF8 very well.
- * The standard input output functions can not work properly on Windows with UTF8.
- * So we create this namespace and provide various console-related functions
- * to patch Windows console and let it more like the console in other platforms.
- * \par
- * The function provided in this function can be called in any platforms.
- * In Windows, the implementation will use Windows native function,
- * and in other platform, the implementation will redirect request to standard C function
- * like std::fputs and etc.
- * So the programmer do not need to be worried about which function should they use,
- * and don't need to use macro to use different IO function in different platforms.
- * It is just enough that fully use the functions provided in this namespace.
- * \par
- * All IO functions this namespace provided are UTF8-based.
- * It also means that input output string should always be UTF8 encoded.
- * 
- * \par Input Functions
- * Please note that EOL will automatically converted into LF on Windows platform, not CRLF.
- * This action actually is removing all CR chars in result string.
- * This behavior affect nothing in most cases but it still is possible break something in some special case.
- * \par
- * Due to implementation, if you decide to use this function,
- * you should give up using any other function to read stdin stream,
- * such as std::gets() and std::cin.
- * Because this function may read chars which is more than needed.
- * These extra chars will be stored in this function and can be used next calling.
- * But these chars can not be visited by stdin again.
- * This behavior may cause bug.
- * So if you decide using this function, stick on it and do not change.
- * \par
- * Due to implementation, this function do not support hot switch of stdin.
- * It means that stdin can be redirected before first calling of this function,
- * but it should not be redirected during program running.
- * The reason is the same one introduced above.
- * 
- * \par Output Functions
- * In current implementation, EOL will not be converted automatically to CRLF.
- * This is different with other stream read functions provided in this namespace.
- * \par
- * Comparing with other stream read functions provided in this namespace,
- * stream write function support hot switch of stdout and stderr.
- * Because they do not have internal buffer storing something.
- * \par
- * In this namespace, there are various stream write function.
- * There is a list telling you how to choose one from them for using:
- * \li Functions with leading "Err" will write data into stderr,
- * otherwise they will write data into stdout.
- * \li Functions with embedded "Format" are output functions with format feature
- * like std::fprintf(), otherwise the functions with embedded "Write" will
- * only write plain string like std::fputs().
- * \li Functions with trailing "Line" will write extra EOL to break current line.
- * This is commonly used, otherwise functions will only write the text provided by arguments,
- * without adding something.
+ * For how to utilize this functions provided by this namespace, please view \ref console_helper.
 */
 namespace YYCC::ConsoleHelper {
 
+	/// @brief The head of ASCII escape code of black color.
 #define YYCC_COLORHDR_BLACK "\033[30m"
+	/// @brief The head of ASCII escape code of red color.
 #define YYCC_COLORHDR_RED "\033[31m"
+	/// @brief The head of ASCII escape code of green color.
 #define YYCC_COLORHDR_GREEN "\033[32m"
+	/// @brief The head of ASCII escape code of yellow color.
 #define YYCC_COLORHDR_YELLOW "\033[33m"
+	/// @brief The head of ASCII escape code of blue color.
 #define YYCC_COLORHDR_BLUE "\033[34m"
+	/// @brief The head of ASCII escape code of magenta color.
 #define YYCC_COLORHDR_MAGENTA "\033[35m"
+	/// @brief The head of ASCII escape code of cyan color.
 #define YYCC_COLORHDR_CYAN "\033[36m"
+	/// @brief The head of ASCII escape code of white color.
 #define YYCC_COLORHDR_WHITE "\033[37m"
-
+	
+	/// @brief The head of ASCII escape code of light black color.
 #define YYCC_COLORHDR_LIGHT_BLACK "\033[90m"
+	/// @brief The head of ASCII escape code of light red color.
 #define YYCC_COLORHDR_LIGHT_RED "\033[91m"
+	/// @brief The head of ASCII escape code of light green color.
 #define YYCC_COLORHDR_LIGHT_GREEN "\033[92m"
+	/// @brief The head of ASCII escape code of light yellow color.
 #define YYCC_COLORHDR_LIGHT_YELLOW "\033[93m"
+	/// @brief The head of ASCII escape code of light blue color.
 #define YYCC_COLORHDR_LIGHT_BLUE "\033[94m"
+	/// @brief The head of ASCII escape code of light magenta color.
 #define YYCC_COLORHDR_LIGHT_MAGENTA "\033[95m"
+	/// @brief The head of ASCII escape code of light cyan color.
 #define YYCC_COLORHDR_LIGHT_CYAN "\033[96m"
+	/// @brief The head of ASCII escape code of light white color.
 #define YYCC_COLORHDR_LIGHT_WHITE "\033[97m"
-
+	
+	/// @brief The tail of ASCII escape code of every color.
 #define YYCC_COLORTAIL "\033[0m"
-
-
+	
+	/// @brief The ASCII escape code pair of black color.
 #define YYCC_COLOR_BLACK(T) "\033[30m" T "\033[0m"
+	/// @brief The ASCII escape code pair of red color.
 #define YYCC_COLOR_RED(T) "\033[31m" T "\033[0m"
+	/// @brief The ASCII escape code pair of green color.
 #define YYCC_COLOR_GREEN(T) "\033[32m" T "\033[0m"
+	/// @brief The ASCII escape code pair of yellow color.
 #define YYCC_COLOR_YELLOW(T) "\033[33m" T "\033[0m"
+	/// @brief The ASCII escape code pair of blue color.
 #define YYCC_COLOR_BLUE(T) "\033[34m" T "\033[0m"
+	/// @brief The ASCII escape code pair of magenta color.
 #define YYCC_COLOR_MAGENTA(T) "\033[35m" T "\033[0m"
+	/// @brief The ASCII escape code pair of cyan color.
 #define YYCC_COLOR_CYAN(T) "\033[36m" T "\033[0m"
+	/// @brief The ASCII escape code pair of white color.
 #define YYCC_COLOR_WHITE(T) "\033[37m" T "\033[0m"
-
+	
+	/// @brief The ASCII escape code pair of light black color.
 #define YYCC_COLOR_LIGHT_BLACK(T) "\033[90m" T "\033[0m"
+	/// @brief The ASCII escape code pair of light red color.
 #define YYCC_COLOR_LIGHT_RED(T) "\033[91m" T "\033[0m"
+	/// @brief The ASCII escape code pair of light green color.
 #define YYCC_COLOR_LIGHT_GREEN(T) "\033[92m" T "\033[0m"
+	/// @brief The ASCII escape code pair of light yellow color.
 #define YYCC_COLOR_LIGHT_YELLOW(T) "\033[93m" T "\033[0m"
+	/// @brief The ASCII escape code pair of light blue color.
 #define YYCC_COLOR_LIGHT_BLUE(T) "\033[94m" T "\033[0m"
+	/// @brief The ASCII escape code pair of light magenta color.
 #define YYCC_COLOR_LIGHT_MAGENTA(T) "\033[95m" T "\033[0m"
+	/// @brief The ASCII escape code pair of light cyan color.
 #define YYCC_COLOR_LIGHT_CYAN(T) "\033[96m" T "\033[0m"
+	/// @brief The ASCII escape code pair of light white color.
 #define YYCC_COLOR_LIGHT_WHITE(T) "\033[97m" T "\033[0m"
 
 	/**
-	 * @brief Enable Windows console color support.
-	 * @details This actually is enable virtual console feature for stdout and stderr.
+	 * @brief Enable console color support for Windows.
+	 * @details This actually is enable virtual console feature for \c stdout and \c stderr.
 	 * @return True if success, otherwise false.
-	 * @remarks This function only works on Windows and do nothing on other platforms such as Linux,
+	 * @remarks 
+	 * This function only works on Windows and do nothing on other platforms such as Linux,
 	 * because we assume all terminals existing on other platform support color feature as default.
 	*/
 	bool EnableColorfulConsole();
 
 	/**
-	 * @brief Universal console read function
+	 * @brief Reads the next line of UTF8 characters from the standard input stream.
 	 * @return
-	 * The UTF8 encoded string this function read. EOL is excluded.
+	 * The next line of UTF8 characters from the input stream.
 	 * Empty string if user just press Enter key or function failed.
-	 * @remarks
-	 * This function is more like C# Console.ReadLine().
-	 * It read user input with UTF8 encoding until reaching EOL.
-	 * \par
-	 * This function also can be used as ordering user press Enter key by
-	 * simply calling this function and ignoring its return value.
 	*/
-	std::string ReadLine();
+	yycc_u8string ReadLine();
 
 	/**
-	 * @brief Universal console write function with format feature.
+	 * @brief 
+	 * Writes the text representation of the specified object 
+	 * to the standard output stream using the specified format information.
 	 * @param[in] u8_fmt The format string.
-	 * @param[in] ... The arguments to be formatted.
+	 * @param[in] ... The arguments of format string.
 	*/
-	void Format(const char* u8_fmt, ...);
+	void Format(const yycc_char8_t* u8_fmt, ...);
 	/**
-	 * @brief Universal console write function with format and auto EOL feature.
+	 * @brief 
+	 * Writes the text representation of the specified object, 
+	 * followed by the current line terminator, 
+	 * to the standard output stream using the specified format information.
 	 * @param[in] u8_fmt The format string.
-	 * @param[in] ... The arguments to be formatted.
+	 * @param[in] ... The arguments of format string.
 	*/
-	void FormatLine(const char* u8_fmt, ...);
+	void FormatLine(const yycc_char8_t* u8_fmt, ...);
 	/**
-	 * @brief Universal console write function.
-	 * @param[in] u8_strl The string to be written.
+	 * @brief Writes the specified string value to the standard output stream.
+	 * @param[in] u8_strl The value to write.
 	*/
-	void Write(const char* u8_strl);
+	void Write(const yycc_char8_t* u8_strl);
 	/**
-	 * @brief Universal console write function with auto EOL feature.
-	 * @param[in] u8_strl The string to be written.
+	 * @brief 
+	 * Writes the specified string value, followed by the current line terminator, 
+	 * to the standard output stream.
+	 * @param[in] u8_strl The value to write.
 	*/
-	void WriteLine(const char* u8_strl);
+	void WriteLine(const yycc_char8_t* u8_strl);
 
 	/**
-	 * @brief Universal console error write function with format and feature.
+	 * @brief 
+	 * Writes the text representation of the specified object 
+	 * to the standard error stream using the specified format information.
 	 * @param[in] u8_fmt The format string.
-	 * @param[in] ... The arguments to be formatted.
+	 * @param[in] ... The arguments of format string.
 	*/
-	void ErrFormat(const char* u8_fmt, ...);
+	void ErrFormat(const yycc_char8_t* u8_fmt, ...);
 	/**
-	 * @brief Universal console error write function with format and auto EOL feature.
+	 * @brief 
+	 * Writes the text representation of the specified object, 
+	 * followed by the current line terminator, 
+	 * to the standard error stream using the specified format information.
 	 * @param[in] u8_fmt The format string.
-	 * @param[in] ... The arguments to be formatted.
+	 * @param[in] ... The arguments of format string.
 	*/
-	void ErrFormatLine(const char* u8_fmt, ...);
+	void ErrFormatLine(const yycc_char8_t* u8_fmt, ...);
 	/**
-	 * @brief Universal console error write function.
-	 * @param[in] u8_strl The string to be written.
+	 * @brief Writes the specified string value to the standard error stream.
+	 * @param[in] u8_strl The value to write.
 	*/
-	void ErrWrite(const char* u8_strl);
+	void ErrWrite(const yycc_char8_t* u8_strl);
 	/**
-	 * @brief Universal console error write function with auto EOL feature.
-	 * @param[in] u8_strl The string to be written.
+	 * @brief 
+	 * Writes the specified string value, followed by the current line terminator, 
+	 * to the standard error stream.
+	 * @param[in] u8_strl The value to write.
 	*/
-	void ErrWriteLine(const char* u8_strl);
+	void ErrWriteLine(const yycc_char8_t* u8_strl);
 
 }

src/DialogHelper.cpp

@@ -8,16 +8,16 @@ namespace YYCC::DialogHelper {
 
 #pragma region FileFilters
 
-	bool FileFilters::Add(const char* filter_name, std::initializer_list<const char*> il) {
+	bool FileFilters::Add(const yycc_char8_t* filter_name, std::initializer_list<const yycc_char8_t*> il) {
 		// assign filter name
 		if (filter_name == nullptr) return false;
 		FilterName name(filter_name);
 
 		// assign filter patterns
 		FilterModes modes;
-		for (const char* pattern : il) {
+		for (const yycc_char8_t* pattern : il) {
 			if (pattern != nullptr)
-				modes.emplace_back(std::string(pattern));
+				modes.emplace_back(yycc_u8string(pattern));
 		}
 
 		// check filter patterns
@@ -36,13 +36,13 @@ namespace YYCC::DialogHelper {
 		for (const auto& it : m_Filters) {
 			// convert name to wchar
 			WinFileFilters::WinFilterName name;
-			if (!YYCC::EncodingHelper::UTF8ToWchar(it.first.c_str(), name))
+			if (!YYCC::EncodingHelper::UTF8ToWchar(it.first, name))
 				return false;
 
 			// convert pattern and join them
-			std::string joined_modes(YYCC::StringHelper::Join(it.second, ";"));
+			yycc_u8string joined_modes(YYCC::StringHelper::Join(it.second, YYCC_U8(";")));
 			WinFileFilters::WinFilterModes modes;
-			if (!YYCC::EncodingHelper::UTF8ToWchar(joined_modes.c_str(), modes))
+			if (!YYCC::EncodingHelper::UTF8ToWchar(joined_modes, modes))
 				return false;
 
 			// append new pair
@@ -94,12 +94,12 @@ namespace YYCC::DialogHelper {
 
 		// build title and init file name
 		if (m_HasTitle) {
-			if (!YYCC::EncodingHelper::UTF8ToWchar(m_Title.c_str(), win_result.m_WinTitle))
+			if (!YYCC::EncodingHelper::UTF8ToWchar(m_Title, win_result.m_WinTitle))
 				return false;
 			win_result.m_HasTitle = true;
 		}
 		if (m_HasInitFileName) {
-			if (!YYCC::EncodingHelper::UTF8ToWchar(m_InitFileName.c_str(), win_result.m_WinInitFileName))
+			if (!YYCC::EncodingHelper::UTF8ToWchar(m_InitFileName, win_result.m_WinInitFileName))
 				return false;
 			win_result.m_HasInitFileName = true;
 		}
@@ -108,7 +108,7 @@ namespace YYCC::DialogHelper {
 		if (m_HasInitDirectory) {
 			// convert to wpath
 			std::wstring w_init_directory;
-			if (!YYCC::EncodingHelper::UTF8ToWchar(m_InitDirectory.c_str(), w_init_directory))
+			if (!YYCC::EncodingHelper::UTF8ToWchar(m_InitDirectory, w_init_directory))
 				return false;
 
 			// fetch IShellItem*
@@ -143,7 +143,7 @@ namespace YYCC::DialogHelper {
 	 * @return True if success, otherwise false.
 	 * @remarks This is an assist function of CommonFileDialog.
 	*/
-	static bool ExtractDisplayName(IShellItem* item, std::string& ret) {
+	static bool ExtractDisplayName(IShellItem* item, yycc_u8string& ret) {
 		// fetch display name from IShellItem*
 		LPWSTR _name;
 		HRESULT hr = item->GetDisplayName(SIGDN_FILESYSPATH, &_name);
@@ -168,7 +168,7 @@ namespace YYCC::DialogHelper {
 	 * @remarks This function is the real underlying function of all dialog functions.
 	*/
 	template<CommonFileDialogType EDialogType>
-	static bool CommonFileDialog(const FileDialog& params, std::vector<std::string>& ret) {
+	static bool CommonFileDialog(const FileDialog& params, std::vector<yycc_u8string>& ret) {
 		// Reference: https://learn.microsoft.com/en-us/windows/win32/shell/common-file-dialog
 		// prepare result variable
 		HRESULT hr;
@@ -289,7 +289,7 @@ namespace YYCC::DialogHelper {
 				COMHelper::SmartIShellItem result_item(_item);
 
 				// extract display name
-				std::string result_name;
+				yycc_u8string result_name;
 				if (!ExtractDisplayName(result_item.get(), result_name))
 					return false;
 
@@ -326,7 +326,7 @@ namespace YYCC::DialogHelper {
 					COMHelper::SmartIShellItem result_item(_item);
 
 					// extract display name
-					std::string result_name;
+					yycc_u8string result_name;
 					if (!ExtractDisplayName(result_item.get(), result_name))
 						return false;
 
@@ -347,24 +347,24 @@ namespace YYCC::DialogHelper {
 
 #pragma region Wrapper Functions
 
-	bool OpenFileDialog(const FileDialog& params, std::string& ret) {
-		std::vector<std::string> cache;
+	bool OpenFileDialog(const FileDialog& params, yycc_u8string& ret) {
+		std::vector<yycc_u8string> cache;
 		bool isok = CommonFileDialog<CommonFileDialogType::OpenFile>(params, cache);
 		if (isok) ret = cache.front();
 		return isok;
 	}
-	bool OpenMultipleFileDialog(const FileDialog& params, std::vector<std::string>& ret) {
+	bool OpenMultipleFileDialog(const FileDialog& params, std::vector<yycc_u8string>& ret) {
 		return CommonFileDialog<CommonFileDialogType::OpenMultipleFiles>(params, ret);
 	}
-	bool SaveFileDialog(const FileDialog& params, std::string& ret) {
-		std::vector<std::string> cache;
+	bool SaveFileDialog(const FileDialog& params, yycc_u8string& ret) {
+		std::vector<yycc_u8string> cache;
 		bool isok = CommonFileDialog<CommonFileDialogType::SaveFile>(params, cache);
 		if (isok) ret = cache.front();
 		return isok;
 	}
 
-	bool OpenFolderDialog(const FileDialog& params, std::string& ret) {
-		std::vector<std::string> cache;
+	bool OpenFolderDialog(const FileDialog& params, yycc_u8string& ret) {
+		std::vector<yycc_u8string> cache;
 		bool isok = CommonFileDialog<CommonFileDialogType::OpenFolder>(params, cache);
 		if (isok) ret = cache.front();
 		return isok;

src/DialogHelper.hpp

@@ -12,11 +12,19 @@
 #include <shlobj_core.h>
 #include "WinImportSuffix.hpp"
 
+/**
+ * @brief The namespace providing Windows universal dialog features.
+ * @details
+ * This namespace only available on Windows platform.
+ * See also \ref dialog_helper.
+*/
 namespace YYCC::DialogHelper {
 
 	/**
-	 * @brief The class represent the file types region in file dialog
-	 * @details THis class is specific for Windows use, not user oriented.
+	 * @brief The class representing the file types region in file dialog.
+	 * @details 
+	 * This class is served for Windows used. 
+	 * Programmer should \b not create this class manually.
 	*/
 	class WinFileFilters {
 		friend class FileFilters;
@@ -24,9 +32,11 @@ namespace YYCC::DialogHelper {
 	public:
 		WinFileFilters() : m_WinFilters(), m_WinDataStruct(nullptr) {}
 
+		/// @brief Get the count of available file filters
 		UINT GetFilterCount() const {
 			return static_cast<UINT>(m_WinFilters.size());
 		}
+		/// @brief Get pointer to Windows used file filters declarations
 		const COMDLG_FILTERSPEC* GetFilterSpecs() const {
 			return m_WinDataStruct.get();
 		}
@@ -39,6 +49,7 @@ namespace YYCC::DialogHelper {
 		std::vector<WinFilterPair> m_WinFilters;
 		std::unique_ptr<COMDLG_FILTERSPEC[]> m_WinDataStruct;
 
+		/// @brief Clear all current file filters
 		void Clear() {
 			m_WinDataStruct.reset();
 			m_WinFilters.clear();
@@ -46,9 +57,12 @@ namespace YYCC::DialogHelper {
 	};
 
 	/**
-	 * @brief The class represent the file types region in file dialog.
-	 * @details This class is user oriented. User can use function manipulate file types
-	 * and final generation function will produce Windows-understood data struct from this.
+	 * @brief The class representing the file types region in file dialog.
+	 * @details 
+	 * This class is served for programmer using.
+	 * But you don't need create it on your own.
+	 * You can simply fetch it by FileDialog::ConfigreFileTypes ,
+	 * because this class is a part of FileDialog.
 	*/
 	class FileFilters {
 	public:
@@ -56,45 +70,50 @@ namespace YYCC::DialogHelper {
 
 		/**
 		 * @brief Add a filter pair in file types list.
-		 * @param filter_name[in] The friendly name of the filter.
-		 * @param il[in] A C++ initialize list.
-		 * Every entries must be `const char*` represent a single filter pattern.
+		 * @param[in] filter_name The friendly name of the filter.
+		 * @param[in] il 
+		 * A C++ initialize list containing acceptable file filter pattern.
+		 * Every entries must be `const yycc_char8_t*` representing a single filter pattern.
 		 * The list at least should have one valid pattern.
 		 * This function will not validate these filter patterns, so please write them carefully.
 		 * @return True if added success, otherwise false.
-		 * @remarks This function allow you register multiple filter patterns for single friendly name.
-		 * For example: `Add("Microsoft Word (*.doc; *.docx)", {"*.doc", "*.docx"})`
+		 * @remarks
+		 * This function allow you register multiple filter patterns for single friendly name.
+		 * For example: <TT>Add(u8"Microsoft Word (*.doc; *.docx)", {u8"*.doc", u8"*.docx"})</TT>
 		*/
-		bool Add(const char* filter_name, std::initializer_list<const char*> il);
-		/**
-		 * @brief Clear filter pairs for following re-use.
-		*/
-		void Clear() { m_Filters.clear(); }
+		bool Add(const yycc_char8_t* filter_name, std::initializer_list<const yycc_char8_t*> il);
 		/**
 		 * @brief Get the count of added filter pairs.
 		 * @return The count of already added filter pairs.
 		*/
 		size_t Count() const { return m_Filters.size(); }
 
+		/// @brief Clear filter pairs for following re-use.
+		void Clear() { m_Filters.clear(); }
+
 		/**
 		 * @brief Generate Windows dialog system used data struct.
-		 * @param win_result[out] The class holding the generated filter data struct.
-		 * @return True if generation is success, otherwise false.
-		 * @remarks User should not call this function, this function is used in internal code.
+		 * @param[out] win_result The class receiving the generated filter data struct.
+		 * @return True if generation success, otherwise false.
+		 * @remarks 
+		 * Programmer should not call this function, 
+		 * this function is used as YYCC internal code.
 		*/
 		bool Generate(WinFileFilters& win_result) const;
 
 	protected:
-		using FilterModes = std::vector<std::string>;
-		using FilterName = std::string;
+		using FilterModes = std::vector<yycc_u8string>;
+		using FilterName = yycc_u8string;
 		using FilterPair = std::pair<FilterName, FilterModes>;
 
 		std::vector<FilterPair> m_Filters;
 	};
 
 	/**
-	 * @brief The class represent the file dialog
-	 * @details THis class is specific for Windows use, not user oriented.
+	 * @brief The class representing the file dialog.
+	 * @details 
+	 * This class is served for Windows used. 
+	 * Programmer should \b not create this class manually.
 	*/
 	class WinFileDialog {
 		friend class FileDialog;
@@ -105,18 +124,28 @@ namespace YYCC::DialogHelper {
 			m_HasTitle(false), m_HasInitFileName(false), m_WinTitle(), m_WinInitFileName(),
 			m_WinInitDirectory(nullptr) {}
 
+		/// @brief Get whether this dialog has owner.
 		bool HasOwner() const { return m_WinOwner != NULL; }
+		/// @brief Get the \c HWND of dialog owner.
 		HWND GetOwner() const { return m_WinOwner; }
-
+		
+		/// @brief Get the struct holding Windows used file filters data.
 		const WinFileFilters& GetFileTypes() const { return m_WinFileTypes; }
+		/// @brief Get the index of default selected file filter.
 		UINT GetDefaultFileTypeIndex() const { return m_WinDefaultFileTypeIndex; }
-
+		
+		/// @brief Get whether dialog has custom title.
 		bool HasTitle() const { return m_HasTitle; }
+		/// @brief Get custom title of dialog.
 		const wchar_t* GetTitle() const { return m_WinTitle.c_str(); }
+		/// @brief Get whether dialog has custom initial file name.
 		bool HasInitFileName() const { return m_HasInitFileName; }
+		/// @brief Get custom initial file name of dialog
 		const wchar_t* GetInitFileName() const { return m_WinInitFileName.c_str(); }
-
+		
+		/// @brief Get whether dialog has custom initial directory.
 		bool HasInitDirectory() const { return m_WinInitDirectory.get() != nullptr; }
+		/// @brief Get custom initial directory of dialog.
 		IShellItem* GetInitDirectory() const { return m_WinInitDirectory.get(); }
 
 	protected:
@@ -124,15 +153,17 @@ namespace YYCC::DialogHelper {
 		WinFileFilters m_WinFileTypes;
 		/**
 		 * @brief The default selected file type in dialog
-		 * @remarks This is 1-based index according to Windows specification.
-		 * In other words, you should plus 1 for this index when generating this struct from
-		 * user oriented file dialog parameters.
+		 * @remarks 
+		 * This is 1-based index according to Windows specification.
+		 * In other words, when generating this struct from FileDialog to this struct this field should plus 1.
+		 * Because the same field located in FileDialog is 0-based index.
 		*/
 		UINT m_WinDefaultFileTypeIndex;
 		bool m_HasTitle, m_HasInitFileName;
 		std::wstring m_WinTitle, m_WinInitFileName;
 		COMHelper::SmartIShellItem m_WinInitDirectory;
-
+		
+		/// @brief Clear all data and reset them to default value.
 		void Clear() {
 			m_WinOwner = nullptr;
 			m_WinFileTypes.Clear();
@@ -145,9 +176,10 @@ namespace YYCC::DialogHelper {
 	};
 
 	/**
-	 * @brief The class represent the file dialog.
-	 * @details This class is user oriented. User can use function manipulate file dialog properties
-	 * and final generation function will produce Windows-understood data struct from this.
+	 * @brief The class representing the file dialog.
+	 * @details 
+	 * This class is served for programming using to describe every aspectes of the dialog.
+	 * For how to use this struct, see \ref dialog_helper.
 	*/
 	class FileDialog {
 	public:
@@ -158,27 +190,55 @@ namespace YYCC::DialogHelper {
 			m_Title(), m_InitFileName(), m_InitDirectory(),
 			m_HasTitle(false), m_HasInitFileName(false), m_HasInitDirectory(false) {}
 
+		/**
+		 * @brief Set the owner of dialog.
+		 * @param[in] owner The \c HWND pointing to the owner of dialog, or NULL to remove owner.
+		*/
 		void SetOwner(HWND owner) { m_Owner = owner; }
-		void SetTitle(const char* title) {
+		/**
+		 * @brief Set custom title of dialog
+		 * @param[in] title The string pointer to custom title, or nullptr to remove it.
+		*/
+		void SetTitle(const yycc_char8_t* title) {
 			if (m_HasTitle = title != nullptr)
 				m_Title = title;
 		}
+		/**
+		 * @brief Fetch the struct describing file filters for future configuration.
+		 * @return The reference to the struct describing file filters.
+		*/
 		FileFilters& ConfigreFileTypes() {
 			return m_FileTypes;
 		}
+		/**
+		 * @brief Set the index of default selected file filter.
+		 * @param[in] idx 
+		 * The index to default one.
+		 * This must be a valid index in file filters.
+		*/
 		void SetDefaultFileTypeIndex(size_t idx) { m_DefaultFileTypeIndex = idx; }
-		void SetInitFileName(const char* init_filename) {
+		/**
+		 * @brief Set the initial file name of dialog
+		 * @details If set, the file name will always be same one when opening dialog.
+		 * @param[in] init_filename String pointer to initial file name, or nullptr to remove it.
+		*/
+		void SetInitFileName(const yycc_char8_t* init_filename) {
 			if (m_HasInitFileName = init_filename != nullptr)
 				m_InitFileName = init_filename;
 		}
-		void SetInitDirectory(const char* init_dir) {
+		/**
+		 * @brief Set the initial directory of dialog
+		 * @details If set, the opended directory will always be the same one when opening dialog
+		 * @param[in] init_dir 
+		 * String pointer to initial directory.
+		 * Invalid path or nullptr will remove this feature.
+		*/
+		void SetInitDirectory(const yycc_char8_t* init_dir) {
 			if (m_HasInitDirectory = init_dir != nullptr)
 				m_InitDirectory = init_dir;
 		}
 
-		/**
-		 * @brief Clear file dialog parameters for following re-use.
-		*/
+		/// @brief Clear file dialog parameters for following re-use.
 		void Clear() {
 			m_Owner = nullptr;
 			m_HasTitle = m_HasInitFileName = m_HasInitDirectory = false;
@@ -191,30 +251,57 @@ namespace YYCC::DialogHelper {
 		
 		/**
 		 * @brief Generate Windows dialog system used data struct.
-		 * @param win_result[out] The class holding the generated filter data struct.
+		 * @param[out] win_result The class receiving the generated filter data struct.
 		 * @return True if generation is success, otherwise false.
-		 * @remarks User should not call this function, this function is used in internal code.
+		 * @remarks 
+		 * Programmer should not call this function.
+		 * This function is used as YYCC internal code.
 		*/
 		bool Generate(WinFileDialog& win_result) const;
 
 	protected:
 		HWND m_Owner;
 		bool m_HasTitle, m_HasInitFileName, m_HasInitDirectory;
-		std::string m_Title, m_InitFileName, m_InitDirectory;
+		yycc_u8string m_Title, m_InitFileName, m_InitDirectory;
 		FileFilters m_FileTypes;
 		/**
 		 * @brief The default selected file type in dialog
-		 * @remarks Although Windows notice that this is a 1-based index,
-		 * but for universal experience, we order this is 0-based index.
+		 * @remarks 
+		 * The index Windows used is 1-based index.
+		 * But for universal experience, we order this is 0-based index.
+		 * And do convertion when generating Windows used struct.
 		*/
 		size_t m_DefaultFileTypeIndex;
 	};
 
-	bool OpenFileDialog(const FileDialog& params, std::string& ret);
-	bool OpenMultipleFileDialog(const FileDialog& params, std::vector<std::string>& ret);
-	bool SaveFileDialog(const FileDialog& params, std::string& ret);
-
-	bool OpenFolderDialog(const FileDialog& params, std::string& ret);
+	/**
+	 * @brief Open the dialog which order user select single file to open.
+	 * @param[in] params The configuration of dialog.
+	 * @param[out] ret Full path to user selected file.
+	 * @return False if user calcel the operation or something went wrong, otherwise true.
+	*/
+	bool OpenFileDialog(const FileDialog& params, yycc_u8string& ret);
+	/**
+	 * @brief Open the dialog which order user select multiple file to open.
+	 * @param[in] params The configuration of dialog.
+	 * @param[out] ret The list of full path of user selected files.
+	 * @return False if user calcel the operation or something went wrong, otherwise true.
+	*/
+	bool OpenMultipleFileDialog(const FileDialog& params, std::vector<yycc_u8string>& ret);
+	/**
+	 * @brief Open the dialog which order user select single file to save.
+	 * @param[in] params The configuration of dialog.
+	 * @param[out] ret Full path to user selected file.
+	 * @return False if user calcel the operation or something went wrong, otherwise true.
+	*/
+	bool SaveFileDialog(const FileDialog& params, yycc_u8string& ret);
+	/**
+	 * @brief Open the dialog which order user select single directory to open.
+	 * @param[in] params The configuration of dialog.
+	 * @param[out] ret Full path to user selected directory.
+	 * @return False if user calcel the operation or something went wrong, otherwise true.
+	*/
+	bool OpenFolderDialog(const FileDialog& params, yycc_u8string& ret);
 
 }
 

src/EncodingHelper.cpp

@@ -4,7 +4,7 @@
 
 namespace YYCC::EncodingHelper {
 
-#pragma region UTF8 Native Convertion
+#pragma region UTF8 Ordinary Convertion
 	
 	const yycc_char8_t* ToUTF8(const char* src) {
 		return reinterpret_cast<const yycc_char8_t*>(src);
@@ -19,16 +19,16 @@ namespace YYCC::EncodingHelper {
 		return yycc_u8string_view(reinterpret_cast<const yycc_char8_t*>(src.data()), src.size());
 	}
 	
-	const char* ToNative(const yycc_char8_t* src) {
+	const char* ToOrdinary(const yycc_char8_t* src) {
 		return reinterpret_cast<const char*>(src);
 	}
-	char* ToNative(yycc_char8_t* src) {
+	char* ToOrdinary(yycc_char8_t* src) {
 		return reinterpret_cast<char*>(src);
 	}
-	std::string ToNative(const yycc_u8string_view& src) {
+	std::string ToOrdinary(const yycc_u8string_view& src) {
 		return std::string(reinterpret_cast<const char*>(src.data()), src.size());
 	}
-	std::string_view ToNativeView(const yycc_u8string_view& src) {
+	std::string_view ToOrdinaryView(const yycc_u8string_view& src) {
 		return std::string_view(reinterpret_cast<const char*>(src.data()), src.size());
 	}
 
@@ -176,7 +176,7 @@ return ret;
 #pragma region UTF8ToWchar
 	
 	bool UTF8ToWchar(const yycc_u8string_view& src, std::wstring& dst) {
-		std::string_view adapted_src(ToNativeView(src));
+		std::string_view adapted_src(ToOrdinaryView(src));
 		return CharToWchar(adapted_src, dst, CP_UTF8);
 	}
 	bool UTF8ToWchar(const yycc_char8_t* src, std::wstring& dst) {
@@ -191,6 +191,44 @@ return ret;
 
 #pragma endregion
 	
+#pragma region CharToUTF8
+
+	bool CharToUTF8(const std::string_view& src, yycc_u8string& dst, UINT code_page) {
+		std::string adapted_dst;
+		bool ret = CharToChar(src, adapted_dst, code_page, CP_UTF8);
+		if (ret) dst = ToUTF8(adapted_dst);
+		return ret;
+	}
+	bool CharToUTF8(const char* src, yycc_u8string& dst, UINT code_page) {
+		CONVFCT_TYPE2(CharToUTF8, char, yycc_char8_t, code_page);
+	}
+	yycc_u8string CharToUTF8(const std::string_view& src, UINT code_page) {
+		CONVFCT_TYPE3(CharToUTF8, char, yycc_char8_t, code_page);
+	}
+	yycc_u8string CharToUTF8(const char* src, UINT code_page) {
+		CONVFCT_TYPE4(CharToUTF8, char, yycc_char8_t, code_page);
+	}
+
+#pragma endregion
+
+#pragma region UTF8ToChar
+
+	bool UTF8ToChar(const yycc_u8string_view& src, std::string& dst, UINT code_page) {
+		std::string_view adapted_src(ToOrdinaryView(src));
+		return CharToChar(adapted_src, dst, CP_UTF8, code_page);
+	}
+	bool UTF8ToChar(const yycc_char8_t* src, std::string& dst, UINT code_page) {
+		CONVFCT_TYPE2(UTF8ToChar, yycc_char8_t, char, code_page);
+	}
+	std::string UTF8ToChar(const yycc_u8string_view& src, UINT code_page) {
+		CONVFCT_TYPE3(UTF8ToChar, yycc_char8_t, char, code_page);
+	}
+	std::string UTF8ToChar(const yycc_char8_t* src, UINT code_page) {
+		CONVFCT_TYPE4(UTF8ToChar, yycc_char8_t, char, code_page);
+	}
+
+#pragma endregion
+
 #endif
 
 	

src/EncodingHelper.hpp

@@ -10,57 +10,26 @@
 #endif
 
 /**
- * @brief The namespace handling encoding issues.
+ * @brief The helper for all encoding stuff.
  * @details
- * \par Windows Encoding Convertion
- * This namespace provides the convertion between wchar_t, UTF8 and code-page-based string:
- * The function name has following format: \c AAAToBBB.
- * AAA is the source string and BBB is target string.
- * AAA and BBB has following possible value:
- * \li \c Char: Code-page-based string. Usually it will add a code page parameter for function to get the code page of this string. For code page, please see Microsoft document.
- * \li \c UTF8: UTF8 string.
- * \li \c Wchar: wchar_t string.
- * \par
- * For example: \c WcharToUTF8 will perform the convertion from wchar_t to UTF8,
- * and \c CharToChar will perform the convertion between 2 code-page-based string and caller can specify individual code page for these 2 string.
- * \par
- * These functions are Windows specific and are unavailable on other platforms.
- * Becasue Windows use wchar_t string as its function arguments for globalization, and this library use UTF8 everywhere.
- * So it should have a bidirectional way to do convertion between wchar_t string and UTF8 string.
- *
- * \par UTF32, UTF16 and UTF8 Convertion
- * This namespace also provide the convertion among UTF32, UTF16 and UTF8.
- * These convertion functions are suit for all platforms, not Windows oriented.
- * \par
- * Due to implementation, this library assume all non-Windows system use UTF8 as their C locale.
- * Otherwise these functions will produce wrong result.
- *
- * \par Function Parameters
- * We provide these encoding convertion functions with following 2 types:
- * \li Function returns \c bool and its parameter order source string pointer and a corresponding \c std::basic_string container for receiving result.
- * \li Function returns corresponding \c std::basic_string result, and its parameter only order source string pointer.
- * \par
- * For these 2 declarations, both of them will not throw any exception and do not accept nullptr as source string.
- * The only difference is that the way to indicate convertion error.
- * \par
- * First declaration will return false to indicate there is an error when doing convertion. Please note that the content of string container passing in may still be changed!
- * Last declaration will return empty string to indicate error. Please note if you pass empty string in, they still will output empty string but it doesn't mean an error.
- * So last declaration is used in the scenario that we don't care whether the convertion success did. For example, output something to console.
- *
+ * For more infomations about how to use the functions provided by this namespace,
+ * please see \ref library_encoding and \ref encoding_helper.
 */
 namespace YYCC::EncodingHelper {
 
-#define YYCC_U8(strl) (reinterpret_cast<const yycc_char8_t*>(u8 ## strl))
+#define _YYCC_U8(strl) u8 ## strl ///< The assistant macro for YYCC_U8.
+#define YYCC_U8(strl) (reinterpret_cast<const ::YYCC::yycc_char8_t*>(_YYCC_U8(strl))) ///< The macro for creating UTF8 string literal. See \ref library_encoding.
+#define YYCC_U8_CHAR(chr) (static_cast<YYCC::yycc_char8_t>(chr)) ///< The macro for casting ordinary char type into YYCC UTF8 char type.
 
 	const yycc_char8_t* ToUTF8(const char* src);
 	yycc_char8_t* ToUTF8(char* src);
 	yycc_u8string ToUTF8(const std::string_view& src);
 	yycc_u8string_view ToUTF8View(const std::string_view& src);
 
-	const char* ToNative(const yycc_char8_t* src);
-	char* ToNative(yycc_char8_t* src);
-	std::string ToNative(const yycc_u8string_view& src);
-	std::string_view ToNativeView(const yycc_u8string_view& src);
+	const char* ToOrdinary(const yycc_char8_t* src);
+	char* ToOrdinary(yycc_char8_t* src);
+	std::string ToOrdinary(const yycc_u8string_view& src);
+	std::string_view ToOrdinaryView(const yycc_u8string_view& src);
 
 #if YYCC_OS == YYCC_OS_WINDOWS
 
@@ -89,6 +58,16 @@ namespace YYCC::EncodingHelper {
 	bool UTF8ToWchar(const yycc_char8_t* src, std::wstring& dst);
 	std::wstring UTF8ToWchar(const yycc_u8string_view& src);
 	std::wstring UTF8ToWchar(const yycc_char8_t* src);
+	
+	bool CharToUTF8(const std::string_view& src, yycc_u8string& dst, UINT code_page);
+	bool CharToUTF8(const char* src, yycc_u8string& dst, UINT code_page);
+	yycc_u8string CharToUTF8(const std::string_view& src, UINT code_page);
+	yycc_u8string CharToUTF8(const char* src, UINT code_page);
+
+	bool UTF8ToChar(const yycc_u8string_view& src, std::string& dst, UINT code_page);
+	bool UTF8ToChar(const yycc_char8_t* src, std::string& dst, UINT code_page);
+	std::string UTF8ToChar(const yycc_u8string_view& src, UINT code_page);
+	std::string UTF8ToChar(const yycc_char8_t* src, UINT code_page);
 
 #endif
 

src/ExceptionHelper.cpp

@@ -11,6 +11,7 @@
 #include <cstdarg>
 #include <cstdio>
 #include <cinttypes>
+#include <mutex>
 
 #include "WinImportPrefix.hpp"
 #include <Windows.h>
@@ -19,38 +20,153 @@
 
 namespace YYCC::ExceptionHelper {
 
-	/**
-	 * @brief True if the exception handler already registered, otherwise false.
-	 * @details
-	 * This variable is designed to prevent multiple register operation
-	 * because unhandled exception handler should only be registered once.
-	 * \n
-	 * Register function should check whether this variable is false before registering,
-	 * and set this variable to true after registing.
-	 * Unregister as well as should do the same check.
-	*/
-	static bool g_IsRegistered = false;
-	/**
-	 * @brief True if a exception handler is running, otherwise false.
-	 * @details
-	 * This variable is served for blocking possible infinity recursive exception handling.
-	 * \n
-	 * When entering unhandled exception handler, we must check whether this variable is true.
-	 * If it is true, it mean that there is another unhandled exception handler running.
-	 * Then we should exit immediately.
-	 * Otherwise, this variable should be set to true indicating we are processing unhandled exception.
-	 * After processing exception, at the end of unhandled exception handler,
-	 * we should restore this value to false.
-	 *
-	*/
-	static bool g_IsProcessing = false;
-	/**
-	 * @brief The backup of original exception handler.
-	 * @details
-	 * This variable was set when registering unhandled exception handler.
-	 * And will be used when unregistering for restoring.
-	*/
-	static LPTOP_LEVEL_EXCEPTION_FILTER g_ProcBackup;
+	static LONG WINAPI UExceptionImpl(LPEXCEPTION_POINTERS);
+	class ExceptionRegister {
+	public:
+		ExceptionRegister() :
+			m_CoreMutex(),
+			m_IsRegistered(false), m_IsProcessing(false), m_PrevProcHandler(nullptr),
+			m_SingletonMutex(NULL) {}
+		~ExceptionRegister() {
+			Unregister();
+		}
+
+	public:
+		/**
+		 * @brief Try to register unhandled exception handler.
+		*/
+		void Register() {
+			std::lock_guard<std::mutex> locker(m_CoreMutex);
+			// if we have registered, return
+			if (m_IsRegistered) return;
+
+			// check singleton
+			// build mutex string first
+			yycc_u8string mutex_name;
+			if (!StringHelper::Printf(mutex_name, YYCC_U8("Global\\%" PRIu32 ".{61634294-d23c-43f9-8490-b5e09837eede}"), GetCurrentProcessId()))
+				return;
+			std::wstring mutex_wname;
+			if (!EncodingHelper::UTF8ToWchar(mutex_name, mutex_wname))
+				return;
+			// create mutex
+			m_SingletonMutex = CreateMutexW(NULL, FALSE, mutex_wname.c_str());
+			DWORD errcode = GetLastError();
+			// check whether be created
+			if (m_SingletonMutex == NULL)
+				return;
+			if (errcode == ERROR_ALREADY_EXISTS) {
+				CloseHandle(m_SingletonMutex);
+				m_SingletonMutex = NULL;
+				return;
+			}
+
+			// okey, we can register it.
+			// backup old handler
+			m_PrevProcHandler = SetUnhandledExceptionFilter(UExceptionImpl);
+			// mark registered
+			m_IsRegistered = true;
+		}
+		/**
+		 * @brief Try to unregister unhandled exception handler.
+		*/
+		void Unregister() {
+			std::lock_guard<std::mutex> locker(m_CoreMutex);
+			// if we are not registered, skip
+			if (!m_IsRegistered) return;
+
+			// unregister handler
+			// restore old handler
+			SetUnhandledExceptionFilter(m_PrevProcHandler);
+			m_PrevProcHandler = nullptr;
+
+			// release singleton handler
+			if (m_SingletonMutex != NULL) {
+				CloseHandle(m_SingletonMutex);
+				m_SingletonMutex = NULL;
+			}
+
+			// mark unregistered
+			m_IsRegistered = false;
+		}
+
+
+	public:
+		/**
+		 * @brief Check whether handler is registered.
+		 * @return True if it is, otherwise false.
+		*/
+		bool IsRegistered() const {
+			std::lock_guard<std::mutex> locker(m_CoreMutex);
+			return m_IsRegistered;
+		}
+		/**
+		 * @brief Check whether we are processing unhandled exception.
+		 * @return True if it is, otherwise false.
+		*/
+		bool IsProcessing() const {
+			std::lock_guard<std::mutex> locker(m_CoreMutex);
+			return m_IsProcessing;
+		}
+		/**
+		 * @brief Get the old unhandled exception handler before registering.
+		 * @return The fucntion pointer to old unhandled exception handler. May be nullptr.
+		*/
+		LPTOP_LEVEL_EXCEPTION_FILTER GetPrevProcHandler() const {
+			std::lock_guard<std::mutex> locker(m_CoreMutex);
+			return m_PrevProcHandler;
+		}
+
+		/**
+		 * @brief Try to start process unhandled exception.
+		 * @return True if you can start to process.
+		 * False means there is already a process running. You should not process it now.
+		*/
+		bool StartProcessing() {
+			std::lock_guard<std::mutex> locker(m_CoreMutex);
+			if (m_IsProcessing) return false;
+			else {
+				m_IsProcessing = true;
+				return true;
+			}
+		}
+		/**
+		 * @brief Mark current process of unhandled exception has done.
+		 * @details This should only be called when StartProcessing() return true.
+		*/
+		void StopProcessing() {
+			std::lock_guard<std::mutex> locker(m_CoreMutex);
+			m_IsProcessing = false;
+		}
+
+	private:
+		/**
+		 * @brief The core mutex for keeping this class is in synchronized.
+		*/
+		mutable std::mutex m_CoreMutex;
+
+		/**
+		 * @brief Whether we have registered unhandled exception handler.
+		 * True if it is, otherwise false.
+		*/
+		bool m_IsRegistered;
+		/**
+		 * @brief Whether we are processing unhandled exception.
+		 * True if it is, otherwise false.
+		*/
+		bool m_IsProcessing;
+		/**
+		 * @brief The backup of old unhandled exception handler.
+		*/
+		LPTOP_LEVEL_EXCEPTION_FILTER m_PrevProcHandler;
+		/**
+		 * @brief The Windows mutex handle for singleton implementation.
+		 * Because we may have many DLLs using YYCC in the same process.
+		 * But the unhandled exception handler only need to be registered once.
+		*/
+		HANDLE m_SingletonMutex;
+	};
+
+	static ExceptionRegister g_ExceptionRegister;
 
 #pragma region Exception Handler Implementation
 
@@ -59,50 +175,50 @@ namespace YYCC::ExceptionHelper {
 	 * @param[in] code Exception code
 	 * @return The const string pointer to corresponding exception explanation string.
 	*/
-	static const char* UExceptionGetCodeName(DWORD code) {
+	static const yycc_char8_t* UExceptionGetCodeName(DWORD code) {
 		switch (code) {
 			case EXCEPTION_ACCESS_VIOLATION:
-				return "access violation";
+				return YYCC_U8("access violation");
 			case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-				return "array index out of bound";
+				return YYCC_U8("array index out of bound");
 			case EXCEPTION_BREAKPOINT:
-				return "breakpoint reached";
+				return YYCC_U8("breakpoint reached");
 			case EXCEPTION_DATATYPE_MISALIGNMENT:
-				return "misaligned data access";
+				return YYCC_U8("misaligned data access");
 			case EXCEPTION_FLT_DENORMAL_OPERAND:
-				return "operand had denormal value";
+				return YYCC_U8("operand had denormal value");
 			case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-				return "floating-point division by zero";
+				return YYCC_U8("floating-point division by zero");
 			case EXCEPTION_FLT_INEXACT_RESULT:
-				return "no decimal fraction representation for value";
+				return YYCC_U8("no decimal fraction representation for value");
 			case EXCEPTION_FLT_INVALID_OPERATION:
-				return "invalid floating-point operation";
+				return YYCC_U8("invalid floating-point operation");
 			case EXCEPTION_FLT_OVERFLOW:
-				return "floating-point overflow";
+				return YYCC_U8("floating-point overflow");
 			case EXCEPTION_FLT_STACK_CHECK:
-				return "floating-point stack corruption";
+				return YYCC_U8("floating-point stack corruption");
 			case EXCEPTION_FLT_UNDERFLOW:
-				return "floating-point underflow";
+				return YYCC_U8("floating-point underflow");
 			case EXCEPTION_ILLEGAL_INSTRUCTION:
-				return "illegal instruction";
+				return YYCC_U8("illegal instruction");
 			case EXCEPTION_IN_PAGE_ERROR:
-				return "inaccessible page";
+				return YYCC_U8("inaccessible page");
 			case EXCEPTION_INT_DIVIDE_BY_ZERO:
-				return "integer division by zero";
+				return YYCC_U8("integer division by zero");
 			case EXCEPTION_INT_OVERFLOW:
-				return "integer overflow";
+				return YYCC_U8("integer overflow");
 			case EXCEPTION_INVALID_DISPOSITION:
-				return "documentation says this should never happen";
+				return YYCC_U8("documentation says this should never happen");
 			case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-				return "can't continue after a noncontinuable exception";
+				return YYCC_U8("can't continue after a noncontinuable exception");
 			case EXCEPTION_PRIV_INSTRUCTION:
-				return "attempted to execute a privileged instruction";
+				return YYCC_U8("attempted to execute a privileged instruction");
 			case EXCEPTION_SINGLE_STEP:
-				return "one instruction has been executed";
+				return YYCC_U8("one instruction has been executed");
 			case EXCEPTION_STACK_OVERFLOW:
-				return "stack overflow";
+				return YYCC_U8("stack overflow");
 			default:
-				return "unknown exception";
+				return YYCC_U8("unknown exception");
 		}
 	}
 
@@ -117,12 +233,12 @@ namespace YYCC::ExceptionHelper {
 	 * @param[in] fmt The format string.
 	 * @param[in] ... The argument to be formatted.
 	*/
-	static void UExceptionErrLogFormatLine(std::FILE* fs, const char* fmt, ...) {
+	static void UExceptionErrLogFormatLine(std::FILE* fs, const yycc_char8_t* fmt, ...) {
 		// write to file
 		if (fs != nullptr) {
 			va_list arg1;
 			va_start(arg1, fmt);
-			std::vfprintf(fs, fmt, arg1);
+			std::vfprintf(fs, EncodingHelper::ToOrdinary(fmt), arg1);
 			std::fputs("\n", fs);
 			va_end(arg1);
 		}
@@ -142,10 +258,10 @@ namespace YYCC::ExceptionHelper {
 	 * If it is nullptr, function will skip writing for file stream.
 	 * @param[in] strl The string to be written.
 	*/
-	static void UExceptionErrLogWriteLine(std::FILE* fs, const char* strl) {
+	static void UExceptionErrLogWriteLine(std::FILE* fs, const yycc_char8_t* strl) {
 		// write to file
 		if (fs != nullptr) {
-			std::fputs(strl, fs);
+			std::fputs(EncodingHelper::ToOrdinary(strl), fs);
 			std::fputs("\n", fs);
 		}
 		// write to stderr
@@ -163,7 +279,7 @@ namespace YYCC::ExceptionHelper {
 		// init symbol
 		if (!SymInitialize(process, 0, TRUE)) {
 			// fail to init. return
-			UExceptionErrLogWriteLine(fs, "Fail to initialize symbol handle for process!");
+			UExceptionErrLogWriteLine(fs, YYCC_U8("Fail to initialize symbol handle for process!"));
 			return;
 		}
 
@@ -215,13 +331,13 @@ namespace YYCC::ExceptionHelper {
 			// depth breaker
 			--maxdepth;
 			if (maxdepth < 0) {
-				UExceptionErrLogWriteLine(fs, "...");		// indicate there are some frames not listed
+				UExceptionErrLogWriteLine(fs, YYCC_U8("..."));		// indicate there are some frames not listed
 				break;
 			}
 
 			// get module name
-			const char* module_name = "<unknown module>";
-			std::string module_name_raw;
+			const yycc_char8_t* module_name = YYCC_U8("<unknown module>");
+			yycc_u8string module_name_raw;
 			DWORD64 module_base;
 			if (module_base = SymGetModuleBase64(process, frame.AddrPC.Offset)) {
 				if (WinFctHelper::GetModuleFileName((HINSTANCE)module_base, module_name_raw)) {
@@ -230,18 +346,18 @@ namespace YYCC::ExceptionHelper {
 			}
 
 			// get source file and line
-			const char* source_file = "<unknown source>";
+			const yycc_char8_t* source_file = YYCC_U8("<unknown source>");
 			DWORD64 source_file_line = 0;
 			DWORD dwDisplacement;
 			IMAGEHLP_LINE64 winline;
 			winline.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
 			if (SymGetLineFromAddr64(process, frame.AddrPC.Offset, &dwDisplacement, &winline)) {
-				source_file = winline.FileName;
+				source_file = EncodingHelper::ToUTF8(winline.FileName); // TODO: check whether there is UNICODE file name.
 				source_file_line = winline.LineNumber;
 			}
 
 			// write to file
-			UExceptionErrLogFormatLine(fs, "0x%" PRI_XPTR_LEFT_PADDING PRIXPTR "[%s+0x%" PRI_XPTR_LEFT_PADDING PRIXPTR "]\t%s#L%" PRIu64,
+			UExceptionErrLogFormatLine(fs, YYCC_U8("0x%" PRI_XPTR_LEFT_PADDING PRIXPTR "[%s+0x%" PRI_XPTR_LEFT_PADDING PRIXPTR "]\t%s#L%" PRIu64),
 				frame.AddrPC.Offset, // memory adress
 				module_name, frame.AddrPC.Offset - module_base, // module name + relative address
 				source_file, source_file_line // source file + source line
@@ -255,16 +371,16 @@ namespace YYCC::ExceptionHelper {
 		SymCleanup(process);
 	}
 
-	static void UExceptionErrorLog(const std::string& u8_filename, LPEXCEPTION_POINTERS info) {
+	static void UExceptionErrorLog(const yycc_u8string& u8_filename, LPEXCEPTION_POINTERS info) {
 		// open file stream if we have file name
 		std::FILE* fs = nullptr;
 		if (!u8_filename.empty()) {
-			fs = IOHelper::UTF8FOpen(u8_filename.c_str(), "wb");
+			fs = IOHelper::UTF8FOpen(u8_filename.c_str(), YYCC_U8("wb"));
 		}
 
 		// record exception type first
 		PEXCEPTION_RECORD rec = info->ExceptionRecord;
-		UExceptionErrLogFormatLine(fs, "Unhandled exception occured at 0x%" PRI_XPTR_LEFT_PADDING PRIXPTR ": %s (%" PRIu32 ").",
+		UExceptionErrLogFormatLine(fs, YYCC_U8("Unhandled exception occured at 0x%" PRI_XPTR_LEFT_PADDING PRIXPTR ": %s (%" PRIu32 ")."),
 			rec->ExceptionAddress,
 			UExceptionGetCodeName(rec->ExceptionCode),
 			rec->ExceptionCode
@@ -273,10 +389,10 @@ namespace YYCC::ExceptionHelper {
 		// special proc for 2 exceptions
 		if (rec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION || rec->ExceptionCode == EXCEPTION_IN_PAGE_ERROR) {
 			if (rec->NumberParameters >= 2) {
-				const char* op =
-					rec->ExceptionInformation[0] == 0 ? "read" :
-					rec->ExceptionInformation[0] == 1 ? "written" : "executed";
-				UExceptionErrLogFormatLine(fs, "The data at memory address 0x%" PRI_XPTR_LEFT_PADDING PRIxPTR " could not be %s.",
+				const yycc_char8_t* op =
+					rec->ExceptionInformation[0] == 0 ? YYCC_U8("read") :
+					rec->ExceptionInformation[0] == 1 ? YYCC_U8("written") : YYCC_U8("executed");
+				UExceptionErrLogFormatLine(fs, YYCC_U8("The data at memory address 0x%" PRI_XPTR_LEFT_PADDING PRIxPTR " could not be %s."),
 					rec->ExceptionInformation[1], op);
 			}
 		}
@@ -290,12 +406,12 @@ namespace YYCC::ExceptionHelper {
 		}
 	}
 
-	static void UExceptionCoreDump(const std::string& u8_filename, LPEXCEPTION_POINTERS info) {
+	static void UExceptionCoreDump(const yycc_u8string& u8_filename, LPEXCEPTION_POINTERS info) {
 		// convert file encoding
 		std::wstring filename;
 		if (u8_filename.empty())
 			return; // if no given file name, return
-		if (!YYCC::EncodingHelper::UTF8ToWchar(u8_filename.c_str(), filename))
+		if (!YYCC::EncodingHelper::UTF8ToWchar(u8_filename, filename))
 			return; // if convertion failed, return
 
 		// open file and write
@@ -315,43 +431,39 @@ namespace YYCC::ExceptionHelper {
 		}
 	}
 
-	static bool UExceptionFetchRecordPath(std::string& log_path, std::string& coredump_path) {
-		// build two file names like: "module.dll.1234.log" and "module.dll.1234.dmp".
-		// "module.dll" is the name of current module. "1234" is current process id.
-		// get self module name
-		std::string u8_self_module_name;
+	static bool UExceptionFetchRecordPath(yycc_u8string& log_path, yycc_u8string& coredump_path) {
+		// build two file names like: "error.exe.1234.log" and "error.exe.1234.dmp".
+		// "error.exe" is the name of current process. "1234" is current process id.
+		// get process name
+		yycc_u8string u8_process_name;
 		{
-			// get module handle
-			HMODULE hSelfModule = YYCC::WinFctHelper::GetCurrentModule();
-			if (hSelfModule == nullptr)
-				return false;
-			// get full path of self module
-			std::string u8_self_module_path;
-			if (!YYCC::WinFctHelper::GetModuleFileName(hSelfModule, u8_self_module_path))
+			// get full path of process
+			yycc_u8string u8_process_path;
+			if (!YYCC::WinFctHelper::GetModuleFileName(NULL, u8_process_path))
 				return false;
 			// extract file name from full path by std::filesystem::path
-			std::filesystem::path self_module_path(FsPathPatch::FromUTF8Path(u8_self_module_path.c_str()));
-			u8_self_module_name = FsPathPatch::ToUTF8Path(self_module_path.filename());
+			std::filesystem::path process_path(FsPathPatch::FromUTF8Path(u8_process_path.c_str()));
+			u8_process_name = FsPathPatch::ToUTF8Path(process_path.filename());
 		}
 		// then get process id
 		DWORD process_id = GetCurrentProcessId();
 		// conbine them as a file name prefix
-		std::string u8_filename_prefix;
-		if (!YYCC::StringHelper::Printf(u8_filename_prefix, "%s.%" PRIu32, u8_self_module_name.c_str(), process_id))
+		yycc_u8string u8_filename_prefix;
+		if (!YYCC::StringHelper::Printf(u8_filename_prefix, YYCC_U8("%s.%" PRIu32), u8_process_name.c_str(), process_id))
 			return false;
 		// then get file name for log and minidump
-		std::string u8_log_filename = u8_filename_prefix + ".log";
-		std::string u8_coredump_filename = u8_filename_prefix + ".dmp";
+		yycc_u8string u8_log_filename = u8_filename_prefix + YYCC_U8(".log");
+		yycc_u8string u8_coredump_filename = u8_filename_prefix + YYCC_U8(".dmp");
 
 		// fetch crash report path
 		// get local appdata folder
-		std::string u8_localappdata_path;
+		yycc_u8string u8_localappdata_path;
 		if (!WinFctHelper::GetLocalAppData(u8_localappdata_path))
 			return false;
 		// convert to std::filesystem::path
 		std::filesystem::path crash_report_path(FsPathPatch::FromUTF8Path(u8_localappdata_path.c_str()));
 		// slash into crash report folder
-		crash_report_path /= FsPathPatch::FromUTF8Path("CrashDumps");
+		crash_report_path /= FsPathPatch::FromUTF8Path(YYCC_U8("CrashDumps"));
 		// use create function to make sure it is existing
 		std::filesystem::create_directories(crash_report_path);
 
@@ -367,26 +479,25 @@ namespace YYCC::ExceptionHelper {
 	}
 
 	static LONG WINAPI UExceptionImpl(LPEXCEPTION_POINTERS info) {
-		// detect loop calling
-		if (g_IsProcessing) goto end_proc;
-		// start process
-		g_IsProcessing = true;
+		// try to start process current unhandled exception
+		// to prevent any possible recursive calling.
+		if (!g_ExceptionRegister.StartProcessing()) goto end_proc;
 
 		// core implementation
 		{
 			// fetch error report path first
-			std::string log_path, coredump_path;
+			yycc_u8string log_path, coredump_path;
 			if (!UExceptionFetchRecordPath(log_path, coredump_path)) {
 				// fail to fetch path, clear them.
 				// we still can handle crash without them
 				log_path.clear();
 				coredump_path.clear();
 				// and tell user we can not output file
-				ConsoleHelper::ErrWriteLine("Crash occurs, but we can not create crash log and coredump!");
+				ConsoleHelper::ErrWriteLine(YYCC_U8("Crash occurs, but we can not create crash log and coredump!"));
 			} else {
 				// okey. output file path to tell user the path where you can find.
-				ConsoleHelper::ErrFormatLine("Crash Log: %s", log_path.c_str());
-				ConsoleHelper::ErrFormatLine("Crash Coredump: %s", coredump_path.c_str());
+				ConsoleHelper::ErrFormatLine(YYCC_U8("Crash Log: %s"), log_path.c_str());
+				ConsoleHelper::ErrFormatLine(YYCC_U8("Crash Coredump: %s"), coredump_path.c_str());
 			}
 
 			// write crash log
@@ -396,14 +507,15 @@ namespace YYCC::ExceptionHelper {
 
 		}
 
-		// end process
-	failed:
-		g_IsProcessing = false;
+		// stop process
+		g_ExceptionRegister.StartProcessing();
+
+	end_proc:
 		// if backup proc can be run, run it
 		// otherwise directly return.
-	end_proc:
-		if (g_ProcBackup != nullptr) {
-			return g_ProcBackup(info);
+		auto prev_proc = g_ExceptionRegister.GetPrevProcHandler();
+		if (prev_proc != nullptr) {
+			return prev_proc(info);
 		} else {
 			return EXCEPTION_CONTINUE_SEARCH;
 		}
@@ -412,15 +524,11 @@ namespace YYCC::ExceptionHelper {
 #pragma endregion
 
 	void Register() {
-		if (g_IsRegistered) return;
-		g_ProcBackup = SetUnhandledExceptionFilter(UExceptionImpl);
-		g_IsRegistered = true;
+		g_ExceptionRegister.Register();
 	}
 
 	void Unregister() {
-		if (!g_IsRegistered) return;
-		SetUnhandledExceptionFilter(g_ProcBackup);
-		g_IsRegistered = false;
+		g_ExceptionRegister.Unregister();
 	}
 
 }

src/ExceptionHelper.hpp

@@ -6,10 +6,7 @@
  * @brief Windows specific unhandled exception processor.
  * @details
  * This namespace is Windows specific. On other platforms, the whole namespace is unavailable.
- * 
- * This namespace allow user register unhandled exception handler on Windows
- * to output error log into \c stderr and log file, and generate coredump if possible.
- * This is useful for bug tracing on Windows, especially most Windows user are naive and don't know how to report bug.
+ * For how to utilize this namespace, please see \ref exception_helper.
  * 
 */
 namespace YYCC::ExceptionHelper {
@@ -20,9 +17,9 @@ namespace YYCC::ExceptionHelper {
 	 * This function will set an internal function as unhandled exception handler on Windows.
 	 * 
 	 * When unhandled exception raised, 
-	 * That internal function will output error stacktrace in standard output 
-	 * and log file (located in temp folder), and also generate a dump file 
-	 * in temp folder (for convenient debugging of developer when reporting bugs) if it can.
+	 * That internal function will output error stacktrace in standard output,
+	 * and generate log file and dump file in \c \%APPDATA\%/CrashDumps folder if it is possible.
+	 * (for convenient debugging of developer when reporting bugs.)
 	 * 
 	 * This function usually is called at the start of program.
 	*/
@@ -33,7 +30,7 @@ namespace YYCC::ExceptionHelper {
 	 * The reverse operation of Register().
 	 * 
 	 * This function and Register() should always be used as a pair.
-	 * You must call this function if you have called Register() before.
+	 * You must call this function to release reources if you have called Register().
 	 * 
 	 * This function usually is called at the end of program.
 	*/

src/FsPathPatch.cpp

@@ -6,7 +6,7 @@
 
 namespace YYCC::FsPathPatch {
 
-	std::filesystem::path FromUTF8Path(const char* u8_path) {
+	std::filesystem::path FromUTF8Path(const yycc_char8_t* u8_path) {
 #if YYCC_OS == YYCC_OS_WINDOWS
 
 		// convert path to wchar
@@ -14,19 +14,19 @@ namespace YYCC::FsPathPatch {
 		if (!YYCC::EncodingHelper::UTF8ToWchar(u8_path, wpath))
 			throw std::invalid_argument("Fail to convert given UTF8 string.");
 
-		// call microsoft specified fopen which support wchar as argument.
+		// return path with wchar_t ctor
 		return std::filesystem::path(wpath);
-
+		
 #else
-		return std::filesystem::path(u8_path);
+		return std::filesystem::path(EncodingHelper::ToOrdinary(u8_path));
 #endif
 	}
 
-	std::string ToUTF8Path(const std::filesystem::path& path) {
+	yycc_u8string ToUTF8Path(const std::filesystem::path& path) {
 #if YYCC_OS == YYCC_OS_WINDOWS
 
 		// get and convert to utf8
-		std::string u8_path;
+		yycc_u8string u8_path;
 		if (!YYCC::EncodingHelper::WcharToUTF8(path.c_str(), u8_path))
 			throw std::invalid_argument("Fail to convert to UTF8 string.");
 
@@ -34,7 +34,7 @@ namespace YYCC::FsPathPatch {
 		return u8_path;
 
 #else
-		return path.string();
+		return EncodingHelper::ToUTF8(path.string());
 #endif
 	}
 

src/FsPathPatch.hpp

@@ -4,38 +4,26 @@
 #include <filesystem>
 
 /**
- * @brief The patch namespace resolving \c std::filesystem::path encoding issue.
+ * @brief \c std::filesystem::path related patches for UTF8 compatibility
  * @details
- * This patch is Windows oriented.
- * If you are in Windows, this patch will perform extra operations to achieve goals,
- * and in other platforms, they just redirect request to corresponding vanilla C++ functions.
- * 
- * As you know, the underlying char type of \c std::filesystem::path is \c wchar_t on Windows,
- * and in other platforms, it is simple \c char.
- * Due to this, if you passing UTF8 char sequence to \c std::filesystem::path on Windows,
- * the library implementation will assume your input is based on current Windows code page, not UTF8.
- * And the final path stored in \c std::filesystem::path is not what you expcected.
- * 
- * This patch namespace always use UTF8 as its argument. There is no ambiguous issue.
- * You should use the functions provided by this namespace on any platforms 
- * instead of vanilla \c std::filesystem::path functions.
+ * See also \ref fs_path_patch.
 */
 namespace YYCC::FsPathPatch {
 	
 	/**
-	 * @brief Constructs the path from a UTF8 character sequence
-	 * @param[in] u8_path UTF8 path string for building this std::filesystem::path.
-	 * @return std::filesystem::path instance.
+	 * @brief Constructs \c std::filesystem::path from UTF8 path.
+	 * @param[in] u8_path UTF8 path string for building.
+	 * @return \c std::filesystem::path instance.
 	 * @exception std::invalid_argument Fail to parse given UTF8 string (maybe invalid?).
 	*/
-	std::filesystem::path FromUTF8Path(const char* u8_path);
+	std::filesystem::path FromUTF8Path(const yycc_char8_t* u8_path);
 
 	/**
-	 * @brief Returns the UTF8 representation of the pathname
-	 * @param path[in] The string to be output.
-	 * @return UTF8 encoded string representing given path.
-	 * @exception std::invalid_argument Fail to parse to UTF8 string.
+	 * @brief Returns the UTF8 representation of given \c std::filesystem::path.
+	 * @param[in] path The \c std::filesystem::path instance converting to UTF8 path.
+	 * @return The UTF8 representation of given \c std::filesystem::path.
+	 * @exception std::invalid_argument Fail to convert to UTF8 string.
 	*/
-	std::string ToUTF8Path(const std::filesystem::path& path);
+	yycc_u8string ToUTF8Path(const std::filesystem::path& path);
 
 }

src/IOHelper.cpp

@@ -14,7 +14,7 @@
 
 namespace YYCC::IOHelper {
 
-	FILE* UTF8FOpen(const char* u8_filepath, const char* u8_mode) {
+	FILE* UTF8FOpen(const yycc_char8_t* u8_filepath, const yycc_char8_t* u8_mode) {
 #if YYCC_OS == YYCC_OS_WINDOWS
 
 		// convert mode and file path to wchar
@@ -28,7 +28,7 @@ namespace YYCC::IOHelper {
 		return _wfopen(wpath.c_str(), wmode.c_str());
 
 #else
-		return std::fopen(u8_filepath, u8_mode);
+		return std::fopen(EncodingHelper::ToOrdinary(u8_filepath), EncodingHelper::ToOrdinary(u8_mode));
 #endif
 	}
 

src/IOHelper.hpp

@@ -4,6 +4,11 @@
 #include <cstdio>
 #include <filesystem>
 
+/**
+ * @brief Some IO related stuff
+ * @details
+ * See also \ref io_helper.
+*/
 namespace YYCC::IOHelper {
 	
 #if UINTPTR_MAX == UINT32_MAX
@@ -24,14 +29,14 @@ namespace YYCC::IOHelper {
 #endif
 
 	/**
-	 * @brief The UTF8 version of std::fopen.
+	 * @brief The UTF8 version of \c std::fopen.
 	 * @param[in] u8_filepath The UTF8 encoded path to the file to be opened.
 	 * @param[in] u8_mode UTF8 encoded mode string of the file to be opened.
 	 * @remarks
 	 * This function is suit for Windows because std::fopen do not support UTF8 on Windows.
 	 * On other platforms, this function will delegate request directly to std::fopen.
-	 * @return FILE* of the file to be opened, or nullptr if failed.
+	 * @return \c FILE* of the file to be opened, or nullptr if failed.
 	*/
-	FILE* UTF8FOpen(const char* u8_filepath, const char* u8_mode);
+	FILE* UTF8FOpen(const yycc_char8_t* u8_filepath, const yycc_char8_t* u8_mode);
 	
 }

src/ParserHelper.hpp

@@ -9,16 +9,34 @@
 #include <charconv>
 #include <array>
 
+/**
+ * @brief The helper involving convertion between arithmetic types (integral, floating point and bool) and string
+ * @details
+ * See also \ref parser_helper.
+*/
 namespace YYCC::ParserHelper {
 
 	// Reference: https://zh.cppreference.com/w/cpp/utility/from_chars
 
+	/**
+	 * @brief Try parsing given string to floating point types.
+	 * @tparam _Ty The type derived from floating point type.
+	 * @param[in] strl The string need to be parsed.
+	 * @param[out] num 
+	 * The variable receiving result.
+	 * There is no guarantee that the content is not modified when parsing failed.
+	 * @return True if success, otherwise false.
+	*/
 	template<typename _Ty, std::enable_if_t<std::is_floating_point_v<_Ty>, int> = 0>
-	bool TryParse(const std::string& strl, _Ty& num) {
-		auto [ptr, ec] = std::from_chars(strl.c_str(), strl.c_str() + strl.size(), num, std::chars_format::general);
+	bool TryParse(const yycc_u8string_view& strl, _Ty& num) {
+		auto [ptr, ec] = std::from_chars(
+			EncodingHelper::ToOrdinary(strl.data()), 
+			EncodingHelper::ToOrdinary(strl.data() + strl.size()), 
+			num, std::chars_format::general
+		);
 		if (ec == std::errc()) {
 			// check whether the full string is matched
-			return ptr == strl.c_str() + strl.size();
+			return ptr == EncodingHelper::ToOrdinary(strl.data() + strl.size());
 		} else if (ec == std::errc::invalid_argument) {
 			// given string is invalid
 			return false;
@@ -30,12 +48,26 @@ namespace YYCC::ParserHelper {
 			throw std::runtime_error("unreachable code.");
 		}
 	}
+	/**
+	 * @brief Try parsing given string to integral types.
+	 * @tparam _Ty The type derived from integral type.
+	 * @param[in] strl The string need to be parsed.
+	 * @param[out] num 
+	 * The variable receiving result.
+	 * There is no guarantee that the content is not modified when parsing failed.
+	 * @param[in] base integer base to use: a value between 2 and 36 (inclusive).
+	 * @return True if success, otherwise false.
+	*/
 	template<typename _Ty, std::enable_if_t<std::is_integral_v<_Ty> && !std::is_same_v<_Ty, bool>, int> = 0>
-	bool TryParse(const std::string& strl, _Ty& num, int base = 10) {
-		auto [ptr, ec] = std::from_chars(strl.c_str(), strl.c_str() + strl.size(), num, base);
+	bool TryParse(const yycc_u8string_view& strl, _Ty& num, int base = 10) {
+		auto [ptr, ec] = std::from_chars(
+			EncodingHelper::ToOrdinary(strl.data()), 
+			EncodingHelper::ToOrdinary(strl.data() + strl.size()), 
+			num, base
+		);
 		if (ec == std::errc()) {
 			// check whether the full string is matched
-			return ptr == strl.c_str() + strl.size();
+			return ptr == EncodingHelper::ToOrdinary(strl.data() + strl.size());
 		} else if (ec == std::errc::invalid_argument) {
 			// given string is invalid
 			return false;
@@ -47,16 +79,34 @@ namespace YYCC::ParserHelper {
 			throw std::runtime_error("unreachable code.");
 		}
 	}
+	/**
+	 * @brief Try parsing given string to bool types.
+	 * @tparam _Ty The type derived from bool type.
+	 * @param[in] strl The string need to be parsed ("true" or "false").
+	 * @param[out] num 
+	 * The variable receiving result.
+	 * There is no guarantee that the content is not modified when parsing failed.
+	 * @return True if success, otherwise false.
+	*/
 	template<typename _Ty, std::enable_if_t<std::is_same_v<_Ty, bool>, int> = 0>
-	bool TryParse(const std::string& strl, _Ty& num) {
-		if (strl == "true") num = true;
-		else if (strl == "false") num = false;
+	bool TryParse(const yycc_u8string_view& strl, _Ty& num) {
+		if (strl == YYCC_U8("true")) num = true;
+		else if (strl == YYCC_U8("false")) num = false;
 		else return false;
 		return true;
 	}
 
+	/**
+	 * @brief Parse given string to arithmetic types.
+	 * @tparam _Ty The type derived from arithmetic type.
+	 * @param[in] strl The string need to be parsed.
+	 * @return
+	 * The parsing result.
+	 * There is no guarantee about the content of this return value when parsing failed.
+	 * It may be any possible value but usually is its default value.
+	*/
 	template<typename _Ty, std::enable_if_t<std::is_arithmetic_v<_Ty>, int> = 0>
-	_Ty Parse(const std::string& strl) {
+	_Ty Parse(const yycc_u8string_view& strl) {
 		_Ty ret;
 		TryParse(strl, ret);
 		return ret;
@@ -64,25 +114,41 @@ namespace YYCC::ParserHelper {
 
 	// Reference: https://en.cppreference.com/w/cpp/utility/to_chars
 
+	/**
+	 * @brief Return a string version of given arithmetic value.
+	 * @tparam _Ty The type derived from arithmetic type.
+	 * @param[in] num The value getting string version.
+	 * @return The string version of given value.
+	*/
 	template<typename _Ty, std::enable_if_t<std::is_arithmetic_v<_Ty> && !std::is_same_v<_Ty, bool>, int> = 0>
-	std::string ToString(_Ty num) {
-		std::array<char, 64> buffer;
-		auto [ptr, ec] = std::to_chars(buffer.data(), buffer.data() + buffer.size(), num);
+	yycc_u8string ToString(_Ty num) {
+		std::array<yycc_char8_t, 64> buffer;
+		auto [ptr, ec] = std::to_chars(
+			EncodingHelper::ToOrdinary(buffer.data()), 
+			EncodingHelper::ToOrdinary(buffer.data() + buffer.size()), 
+			num
+		);
 		if (ec == std::errc()) {
-			return std::string(buffer.data(), ptr - buffer.data());
+			return yycc_u8string(buffer.data(), EncodingHelper::ToUTF8(ptr) - buffer.data());
 		} else if (ec == std::errc::value_too_large) {
 			// too short buffer
-			// this should not happend
+			// this should not happened
 			throw std::out_of_range("ToString() buffer is not sufficient.");
 		} else {
 			// unreachable
 			throw std::runtime_error("unreachable code.");
 		}
 	}
+	/**
+	 * @brief Return a string version of given bool value.
+	 * @tparam _Ty The type derived from bool type.
+	 * @param[in] num The value getting string version.
+	 * @return The string version of given value ("true" or "false").
+	*/
 	template<typename _Ty, std::enable_if_t<std::is_same_v<_Ty, bool>, int> = 0>
-	std::string ToString(_Ty num) {
-		if (num) return std::string("true");
-		else return std::string("false");
+	yycc_u8string ToString(_Ty num) {
+		if (num) return yycc_u8string(YYCC_U8("true"));
+		else return yycc_u8string(YYCC_U8("false"));
 	}
 
 }

src/StringHelper.cpp

@@ -1,9 +1,12 @@
 #include "StringHelper.hpp"
+#include "EncodingHelper.hpp"
 #include <algorithm>
 
 namespace YYCC::StringHelper {
 
-	bool Printf(std::string& strl, const char* format, ...) {
+#pragma region Printf VPrintf
+
+	bool Printf(yycc_u8string& strl, const yycc_char8_t* format, ...) {
 		va_list argptr;
 		va_start(argptr, format);
 		bool ret = VPrintf(strl, format, argptr);
@@ -11,7 +14,7 @@ namespace YYCC::StringHelper {
 		return ret;
 	}
 
-	bool VPrintf(std::string& strl, const char* format, va_list argptr) {
+	bool VPrintf(yycc_u8string& strl, const yycc_char8_t* format, va_list argptr) {
 		va_list args1;
 		va_copy(args1, argptr);
 		va_list args2;
@@ -19,7 +22,12 @@ namespace YYCC::StringHelper {
 
 		// the return value is desired char count without NULL terminal.
 		// minus number means error
-		int count = std::vsnprintf(nullptr, 0, format, args1);
+		int count = std::vsnprintf(
+			nullptr, 
+			0, 
+			EncodingHelper::ToOrdinary(format), 
+			args1
+		);
 		if (count < 0) {
 			// invalid length returned by vsnprintf.
 			return false;
@@ -31,7 +39,12 @@ namespace YYCC::StringHelper {
 		// because std::vsnprintf only can write "buf_size - 1" chars with a trailing NULL.
 		// however std::vsnprintf already have a trailing NULL, so we plus 1 for it.
 		strl.resize(count);
-		int write_result = std::vsnprintf(strl.data(), strl.size() + 1, format, args2);
+		int write_result = std::vsnprintf(
+			EncodingHelper::ToOrdinary(strl.data()),
+			strl.size() + 1, 
+			EncodingHelper::ToOrdinary(format), 
+			args2
+		);
 		va_end(args2);
 
 		if (write_result < 0 || write_result > count) {
@@ -42,9 +55,8 @@ namespace YYCC::StringHelper {
 		return true;
 	}
 
-
-	std::string Printf(const char* format, ...) {
-		std::string ret;
+	yycc_u8string Printf(const yycc_char8_t* format, ...) {
+		yycc_u8string ret;
 
 		va_list argptr;
 		va_start(argptr, format);
@@ -54,8 +66,8 @@ namespace YYCC::StringHelper {
 		return ret;
 	}
 
-	std::string VPrintf(const char* format, va_list argptr) {
-		std::string ret;
+	yycc_u8string VPrintf(const yycc_char8_t* format, va_list argptr) {
+		yycc_u8string ret;
 
 		va_list argcpy;
 		va_copy(argcpy, argptr);
@@ -65,28 +77,32 @@ namespace YYCC::StringHelper {
 		return ret;
 	}
 
-	void Replace(std::string& strl, const char* _from_strl, const char* _to_strl)  {
+#pragma endregion
+
+#pragma region Replace
+
+	void Replace(yycc_u8string& strl, const yycc_char8_t* _from_strl, const yycc_char8_t* _to_strl)  {
 		// Reference: https://stackoverflow.com/questions/3418231/replace-part-of-a-string-with-another-string
 		
 		// check requirements
 		// from string and to string should not be nullptr.
 		if (_from_strl == nullptr || _to_strl == nullptr) return;
 		// from string should not be empty
-		std::string from_strl(_from_strl);
-		std::string to_strl(_to_strl);
+		yycc_u8string from_strl(_from_strl);
+		yycc_u8string to_strl(_to_strl);
 		if (from_strl.empty()) return;
 
 		// start replace one by one
 		size_t start_pos = 0;
-		while ((start_pos = strl.find(from_strl, start_pos)) != std::string::npos) {
+		while ((start_pos = strl.find(from_strl, start_pos)) != yycc_u8string::npos) {
 			strl.replace(start_pos, from_strl.size(), to_strl);
 			start_pos += to_strl.size(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
 		}
 	}
 
-	std::string Replace(const char* _strl, const char* _from_strl, const char* _to_strl) {
+	yycc_u8string Replace(const yycc_char8_t* _strl, const yycc_char8_t* _from_strl, const yycc_char8_t* _to_strl) {
 		// prepare result
-		std::string strl;
+		yycc_u8string strl;
 		// if given string is not nullptr, assign it and process it.
 		if (_strl != nullptr) {
 			strl = _strl;
@@ -96,13 +112,17 @@ namespace YYCC::StringHelper {
 		return strl;
 	}
 
-	std::string Join(JoinDataProvider fct_data, const char* decilmer) {
-		std::string ret;
+#pragma endregion
+
+#pragma region Join
+
+	yycc_u8string Join(JoinDataProvider fct_data, const yycc_char8_t* decilmer) {
+		yycc_u8string ret;
 		bool is_first = true;
-		const char* element;
+		yycc_u8string_view element;
 
 		// fetch element
-		while ((element = fct_data()) != nullptr) {
+		while (fct_data(element)) {
 			// insert decilmer
 			if (is_first) is_first = false;
 			else {
@@ -111,42 +131,46 @@ namespace YYCC::StringHelper {
 					ret.append(decilmer);
 			}
 
-			// insert element
-			ret.append(element);
+			// insert element if it is not empty
+			if (!element.empty())
+				ret.append(element);
 		}
 
 		return ret;
 	}
 
-	std::string Join(const std::vector<std::string>& data, const char* decilmer, bool reversed) {
+	yycc_u8string Join(const std::vector<yycc_u8string>& data, const yycc_char8_t* decilmer, bool reversed) {
 		if (reversed) {
 			auto iter = data.crbegin();
 			auto stop = data.crend();
-			return Join([&iter, &stop]() -> const char* {
-				// if we reach tail, return nullptr
-				if (iter == stop) return nullptr;
+			return Join([&iter, &stop](yycc_u8string_view& view) -> bool {
+				// if we reach tail, return false
+				if (iter == stop) return false;
 				// otherwise fetch data, inc iterator and return.
-				const char* ret = iter->c_str();
+				view = *iter;
 				++iter;
-				return ret;
+				return true;
 				}, decilmer);
 		} else {
 			auto iter = data.cbegin();
 			auto stop = data.cend();
-			return Join([&iter, &stop]() -> const char* {
+			return Join([&iter, &stop](yycc_u8string_view& view) -> bool {
 				// if we reach tail, return nullptr
-				if (iter == stop) return nullptr;
+				if (iter == stop) return false;
 				// otherwise fetch data, inc iterator and return.
-				const char* ret = iter->c_str();
+				view = *iter;
 				++iter;
-				return ret;
+				return true;
 				}, decilmer);
 		}
 	}
 
+#pragma endregion
+
+#pragma region Upper Lower
 
 	template<bool bIsToLower>
-	void GeneralStringLowerUpper(std::string& strl) {
+	static void GeneralStringLowerUpper(yycc_u8string& strl) {
 		// References:
 		// https://en.cppreference.com/w/cpp/algorithm/transform
 		// https://en.cppreference.com/w/cpp/string/byte/tolower
@@ -159,59 +183,77 @@ namespace YYCC::StringHelper {
 		);
 	}
 
-	std::string Lower(const char* strl) {
-		std::string ret;
+	yycc_u8string Lower(const yycc_char8_t* strl) {
+		yycc_u8string ret;
 		if (strl == nullptr) return ret;
 		else ret = strl;
 		Lower(ret);
 		return ret;
 	}
 
-	void Lower(std::string& strl) {
+	void Lower(yycc_u8string& strl) {
 		GeneralStringLowerUpper<true>(strl);
 	}
 
-	std::string Upper(const char* strl) {
+	yycc_u8string Upper(const yycc_char8_t* strl) {
 		// same as Lower, just replace char transform function.
-		std::string ret;
+		yycc_u8string ret;
 		if (strl == nullptr) return ret;
 		else ret = strl;
 		Upper(ret);
 		return ret;
 	}
 
-	void Upper(std::string& strl) {
+	void Upper(yycc_u8string& strl) {
 		GeneralStringLowerUpper<false>(strl);
 	}
 
-	std::vector<std::string> Split(const char* _strl, const char* _decilmer) {
+#pragma endregion
+
+#pragma region Split
+
+	std::vector<yycc_u8string> Split(const yycc_u8string_view& strl, const yycc_char8_t* _decilmer) {
+		// call split view
+		auto view_result = SplitView(strl, _decilmer);
+
+		// copy string view result to string
+		std::vector<yycc_u8string> elems;
+		for (const auto& strl_view : view_result) {
+			elems.emplace_back(yycc_u8string(strl_view));
+		}
+		// return copied result
+		return elems;
+	}
+
+	std::vector<yycc_u8string_view> SplitView(const yycc_u8string_view& strl, const yycc_char8_t* _decilmer) {
 		// Reference: 
 		// https://stackoverflow.com/questions/14265581/parse-split-a-string-in-c-using-string-delimiter-standard-c
 		
 		// prepare return value
-		std::vector<std::string> elems;
+		std::vector<yycc_u8string_view> elems;
 
-		// if the string need to be splitted is nullptr, return empty result.
-		if (_strl == nullptr) return elems;
-		std::string strl(_strl);
-		// if decilmer is nullptr, or decilmer is zero length, return original string
-		std::string decilmer;
-		if (_decilmer == nullptr || (decilmer = _decilmer, decilmer.empty())) {
-			elems.push_back(strl);
+		// if string need to be splitted is empty, return original string (empty item).
+		// if decilmer is nullptr, or decilmer is zero length, return original string.
+		yycc_u8string decilmer;
+		if (strl.empty() || _decilmer == nullptr || (decilmer = _decilmer, decilmer.empty())) {
+			elems.emplace_back(strl);
 			return elems;
 		}
 
 		// start spliting
 		std::size_t previous = 0, current;
-		while ((current = strl.find(decilmer.c_str(), previous)) != std::string::npos) {
-			elems.push_back(strl.substr(previous, current - previous));
+		while ((current = strl.find(decilmer.c_str(), previous)) != yycc_u8string::npos) {
+			elems.emplace_back(strl.substr(previous, current - previous));
 			previous = current + decilmer.size();
 		}
 		// try insert last part but prevent possible out of range exception
 		if (previous <= strl.size()) {
-			elems.push_back(strl.substr(previous));
+			elems.emplace_back(strl.substr(previous));
 		}
 		return elems;
 	}
 
+#pragma endregion
+
+
 }

src/StringHelper.hpp

@@ -6,66 +6,141 @@
 #include <functional>
 #include <vector>
 
+/**
+ * @brief The helper containing string operations
+ * @details
+ * See also \ref string_helper.
+*/
 namespace YYCC::StringHelper {
 
-	bool Printf(std::string& strl, const char* format, ...);
-	bool VPrintf(std::string& strl, const char* format, va_list argptr);
-
-	std::string Printf(const char* format, ...);
-	std::string VPrintf(const char* format, va_list argptr);
-
-	void Replace(std::string& strl, const char* _from_strl, const char* _to_strl);
-	std::string Replace(const char* _strl, const char* _from_strl, const char* _to_strl);
+	/**
+	 * @brief Perform a string formatting operation.
+	 * @param[out] strl 
+	 * The string container receiving the result.
+	 * There is no guarantee that the content is not modified when function failed.
+	 * @param[in] format The format string.
+	 * @param[in] ... Argument list of format string.
+	 * @return True if success, otherwise false.
+	*/
+	bool Printf(yycc_u8string& strl, const yycc_char8_t* format, ...);
+	/**
+	 * @brief Perform a string formatting operation.
+	 * @param[out] strl 
+	 * The string container receiving the result.
+	 * There is no guarantee that the content is not modified when function failed.
+	 * @param[in] format The format string.
+	 * @param[in] argptr Argument list of format string.
+	 * @return True if success, otherwise false.
+	*/
+	bool VPrintf(yycc_u8string& strl, const yycc_char8_t* format, va_list argptr);
+	/**
+	 * @brief Perform a string formatting operation.
+	 * @param[in] format The format string.
+	 * @param[in] ... Argument list of format string.
+	 * @return The formatting result. Empty string if error happened.
+	*/
+	yycc_u8string Printf(const yycc_char8_t* format, ...);
+	/**
+	 * @brief Perform a string formatting operation.
+	 * @param[in] format The format string.
+	 * @param[in] argptr Argument list of format string.
+	 * @return The formatting result. Empty string if error happened.
+	*/
+	yycc_u8string VPrintf(const yycc_char8_t* format, va_list argptr);
 
 	/**
-	 * @brief The data provider of general Join function.
-	 * This function pointer return non-null string pointer to represent a element of joined series.
-	 * otherwise return nullptr to terminate the joining process.
+	 * @brief Modify given string with all occurrences of substring \e old replaced by \e new.
+	 * @param[in,out] strl The string for replacing
+	 * @param[in] _from_strl The \e old string.
+	 * @param[in] _to_strl The \e new string.
 	*/
-	using JoinDataProvider = std::function<const char* ()>;
+	void Replace(yycc_u8string& strl, const yycc_char8_t* _from_strl, const yycc_char8_t* _to_strl);
 	/**
-	 * @brief General Join function.
-	 * @details This function use function pointer as a general data provider interface,
-	 * so this function suit for all types container, the user only need write a little bit adaption code.
-	 * @param fct_data[in] The function pointer to data provider.
-	 * @param decilmer[in] The decilmer.
-	 * @return A std::string instance which containing the join result.
+	 * @brief Return a copy with all occurrences of substring \e old replaced by \e new.
+	 * @param[in] _strl The string for replacing
+	 * @param[in] _from_strl The \e old string.
+	 * @param[in] _to_strl The \e new string.
+	 * @return The result of replacement.
 	*/
-	std::string Join(JoinDataProvider fct_data, const char* decilmer);
-	/**
-	 * @brief Specialized Join function for common used container.
-	 * @param data
-	 * @param decilmer
-	 * @param reversed
-	 * @return
-	*/
-	std::string Join(const std::vector<std::string>& data, const char* decilmer, bool reversed = false);
+	yycc_u8string Replace(const yycc_char8_t* _strl, const yycc_char8_t* _from_strl, const yycc_char8_t* _to_strl);
 
 	/**
-	 * @brief Transform string to lower.
-	 * @param strl
-	 * @return
+	 * @brief The data provider of general join function.
+	 * @details
+	 * For programmer using lambda to implement this function pointer:
+	 * \li During calling, implementation should assign the reference of string view passed in argument
+	 * to the string which need to be joined.
+	 * \li Function return true to continue joining. otherwise return false to stop joining. 
+	 * The argument content assigned in the calling returning false is not included in join process.
 	*/
-	std::string Lower(const char* strl);
-	void Lower(std::string& strl);
+	using JoinDataProvider = std::function<bool(yycc_u8string_view&)>;
 	/**
-	 * @brief Transform string to upper.
-	 * @param strl
-	 * @return
+	 * @brief Universal join function.
+	 * @details
+	 * This function use function pointer as a general data provider interface,
+	 * so this function suit for all types container.
+	 * You can use this universal join function for any custom container by
+	 * using C++ lambda syntax to create a code block adapted to this function pointer.
+	 * @param[in] fct_data The function pointer in JoinDataProvider type prividing the data to be joined.
+	 * @param[in] decilmer The decilmer used for joining.
+	 * @return The result string of joining.
 	*/
-	std::string Upper(const char* strl);
-	void Upper(std::string& strl);
+	yycc_u8string Join(JoinDataProvider fct_data, const yycc_char8_t* decilmer);
+	/**
+	 * @brief Specialized join function for \c std::vector.
+	 * @param[in] data The list to be joined.
+	 * @param[in] decilmer The decilmer used for joining.
+	 * @param[in] reversed True if this list should be joined in reversed order.
+	 * @return The result string of joining.
+	*/
+	yycc_u8string Join(const std::vector<yycc_u8string>& data, const yycc_char8_t* decilmer, bool reversed = false);
 
 	/**
-	 * @brief General Split function.
-	 * @param _strl[in] The string need to be splitting.
-	 * If this is nullptr, the result will be empty.
-	 * @param _decilmer[in] The decilmer for splitting.
-	 * If decilmer is nullptr or zero length, the result will only have 1 element which is original string.
-	 * @return
-	 * @remarks This function may be low performance because it just a homebrew Split functon.
-	 * It can works in most toy cases but not suit for high performance scenario.
-	 * Also, this function will produce a copy of original string because it is not zero copy.
+	 * @brief Return a copy of the string converted to lowercase.
+	 * @param[in] strl The string to be lowercase.
+	 * @return The copy of the string converted to lowercase.
 	*/
-	std::vector<std::string> Split(const char* _strl, const char* _decilmer);
+	yycc_u8string Lower(const yycc_char8_t* strl);
+	/**
+	 * @brief Convert given string to lowercase.
+	 * @param[in,out] strl The string to be lowercase.
+	*/
+	void Lower(yycc_u8string& strl);
+	/**
+	 * @brief Return a copy of the string converted to uppercase.
+	 * @param[in] strl The string to be uppercase.
+	 * @return The copy of the string converted to uppercase.
+	*/
+	yycc_u8string Upper(const yycc_char8_t* strl);
+	/**
+	 * @brief Convert given string to uppercase.
+	 * @param[in,out] strl The string to be uppercase.
+	*/
+	void Upper(yycc_u8string& strl);
+
+	/**
+	 * @brief Split given string with specified decilmer.
+	 * @param[in] strl The string need to be splitting.
+	 * @param[in] _decilmer The decilmer for splitting.
+	 * @return 
+	 * The split result.
+	 * \par
+	 * If given string is empty, or decilmer is nullptr or empty,
+	 * the result container will only contain 1 entry which is equal to given string.
+	*/
+	std::vector<yycc_u8string> Split(const yycc_u8string_view& strl, const yycc_char8_t* _decilmer);
+	/**
+	 * @brief Split given string with specified decilmer as string view.
+	 * @param[in] strl The string need to be splitting.
+	 * @param[in] _decilmer The decilmer for splitting.
+	 * @return 
+	 * The split result with string view format.
+	 * This will not produce any copy of original string.
+	 * \par
+	 * If given string is empty, or decilmer is nullptr or empty,
+	 * the result container will only contain 1 entry which is equal to given string.
+	 * @see Split(const yycc_u8string_view&, const yycc_char8_t*)
+	*/
+	std::vector<yycc_u8string_view> SplitView(const yycc_u8string_view& strl, const yycc_char8_t* _decilmer);
+
 }

src/WinFctHelper.cpp

@@ -17,7 +17,7 @@ namespace YYCC::WinFctHelper {
 		return hModule;
 	}
 
-	bool GetTempDirectory(std::string& ret) {
+	bool GetTempDirectory(yycc_u8string& ret) {
 		// create wchar buffer for receiving the temp path.
 		std::wstring wpath(MAX_PATH + 1u, L'\0');
 		DWORD expected_size;
@@ -41,10 +41,10 @@ namespace YYCC::WinFctHelper {
 		// resize result
 		wpath.resize(expected_size);
 		// convert to utf8 and return
-		return YYCC::EncodingHelper::WcharToUTF8(wpath.c_str(), ret);
+		return YYCC::EncodingHelper::WcharToUTF8(wpath, ret);
 	}
 
-	bool GetModuleFileName(HINSTANCE hModule, std::string& ret) {
+	bool GetModuleFileName(HINSTANCE hModule, yycc_u8string& ret) {
 		// create wchar buffer for receiving the temp path.
 		std::wstring wpath(MAX_PATH + 1u, L'\0');
 		DWORD copied_size;
@@ -68,10 +68,13 @@ namespace YYCC::WinFctHelper {
 		// resize result
 		wpath.resize(copied_size);
 		// convert to utf8 and return
-		return YYCC::EncodingHelper::WcharToUTF8(wpath.c_str(), ret);
+		return YYCC::EncodingHelper::WcharToUTF8(wpath, ret);
 	}
 
-	bool GetLocalAppData(std::string& ret) {
+	bool GetLocalAppData(yycc_u8string& ret) {
+		// check whether com initialized
+		if (!COMHelper::IsInitialized()) return false;
+
 		// fetch path
 		LPWSTR _known_path;
 		HRESULT hr = SHGetKnownFolderPath(FOLDERID_LocalAppData, KF_FLAG_CREATE, NULL, &_known_path);

src/WinFctHelper.hpp

@@ -9,10 +9,11 @@
 #include "WinImportSuffix.hpp"
 
 /**
- * @brief The helper providing assistance to Win32 functions.
+ * @brief The helper providing assistance of Win32 functions.
  * @details
  * This helper is Windows specific.
  * If current environment is not Windows, the whole namespace will be unavailable.
+ * See also \ref win_fct_helper
 */
 namespace YYCC::WinFctHelper {
 	
@@ -24,39 +25,37 @@ namespace YYCC::WinFctHelper {
 	 * 
 	 * This function is frequently used by DLL.
 	 * Because some design need the HANDLE of current module, not the host EXE loading your DLL.
-	 * For example, you may want to get the name of your built DLL at runtime, then you should pass current module HANDLE, not the HANDLE of EXE.
-	 * Or, if you want to get the path to your DLL, you also should pass current module HANDLE.
+	 * For example, you may want to get the path of your built DLL, or fetch resources from your DLL at runtime,
+	 * then you should pass current module HANDLE, not NULL or the HANDLE of EXE.
 	 * @return A Windows HANDLE pointing to current module, NULL if failed.
 	*/
 	HMODULE GetCurrentModule();
 
 	/**
-	 * @brief Get path to Windows temp folder.
-	 * @param[out] ret 
-	 * The variable receiving UTF8 encoded path to Windows temp folder.
+	 * @brief Get path to Windows temporary folder.
+	 * @details Windows temporary folder usually is the target of \%TEMP\%.
+	 * @param[out] ret The variable receiving UTF8 encoded path to Windows temp folder.
 	 * @return True if success, otherwise false.
 	*/
-	bool GetTempDirectory(std::string& ret);
+	bool GetTempDirectory(yycc_u8string& ret);
 
 	/**
 	 * @brief Get the file name of given module HANDLE
 	 * @param[in] hModule 
-	 * The HANDLE to the module where we want get file name.
-	 * It is same as the HANDLE parameter of \c GetModuleFileName.
-	 * @param[out] ret 
-	 * The variable receiving UTF8 encoded file name of given module.
+	 * The HANDLE to the module where you want to get file name.
+	 * It is same as the HANDLE parameter of Win32 \c GetModuleFileName.
+	 * @param[out] ret The variable receiving UTF8 encoded file name of given module.
 	 * @return True if success, otherwise false.
 	*/
-	bool GetModuleFileName(HINSTANCE hModule, std::string& ret);
+	bool GetModuleFileName(HINSTANCE hModule, yycc_u8string& ret);
 
 	/**
-	 * @brief Get the path to LOCALAPPDATA.
-	 * @details LOCALAPPDATA usually was used as putting local app data files
-	 * @param[out] ret 
-	 * The variable receiving UTF8 encoded path to LOCALAPPDATA.
-	 * @return 
+	 * @brief Get the path to \%LOCALAPPDATA\%.
+	 * @details \%LOCALAPPDATA\% usually was used as putting local app data files
+	 * @param[out] ret The variable receiving UTF8 encoded path to LOCALAPPDATA.
+	 * @return True if success, otherwise false.
 	*/
-	bool GetLocalAppData(std::string& ret);
+	bool GetLocalAppData(yycc_u8string& ret);
 
 }
 

src/YYCC.natvis

@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+Copyright (c) Microsoft Corporation, yyc12345.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+
+    <!-- Following XML are copied from Visual Studio embedded Natvis files. -->
+    <!-- <Microsoft Visual Studio Install Directory>\Common7\Packages\Debugger\Visualizers\stl.natvis -->
+
+    <!-- VC 2013 -->
+    <Type Name="std::basic_string&lt;YYCC::yycc_char8_t,*&gt;" Priority="MediumLow">
+        <AlternativeType Name="std::basic_string&lt;char8_t,*&gt;" />
+        <AlternativeType Name="std::basic_string&lt;unsigned char,*&gt;" />
+        <DisplayString Condition="_Myres &lt; _BUF_SIZE">{_Bx._Buf,s8}</DisplayString>
+        <DisplayString Condition="_Myres &gt;= _BUF_SIZE">{_Bx._Ptr,s8}</DisplayString>
+        <StringView Condition="_Myres &lt; _BUF_SIZE">_Bx._Buf,s8</StringView>
+        <StringView Condition="_Myres &gt;= _BUF_SIZE">_Bx._Ptr,s8</StringView>
+        <Expand>
+            <Item Name="[size]" ExcludeView="simple">_Mysize</Item>
+            <Item Name="[capacity]" ExcludeView="simple">_Myres</Item>
+            <ArrayItems>
+                <Size>_Mysize</Size>
+                <ValuePointer Condition="_Myres &lt; _BUF_SIZE">_Bx._Buf</ValuePointer>
+                <ValuePointer Condition="_Myres &gt;= _BUF_SIZE">_Bx._Ptr</ValuePointer>
+            </ArrayItems>
+        </Expand>
+    </Type>
+
+    <!-- VC 2015+ ABI basic_string -->
+    <Type Name="std::basic_string&lt;YYCC::yycc_char8_t,*&gt;">
+        <AlternativeType Name="std::basic_string&lt;char8_t,*&gt;" />
+        <AlternativeType Name="std::basic_string&lt;unsigned char,*&gt;" />
+        <Intrinsic Name="size" Expression="_Mypair._Myval2._Mysize" />
+        <Intrinsic Name="capacity" Expression="_Mypair._Myval2._Myres" />
+        <!-- _BUF_SIZE = 16 / sizeof(char) &lt; 1 ? 1 : 16 / sizeof(char) == 16 -->
+        <Intrinsic Name="bufSize" Expression="16" />
+        <Intrinsic Name="isShortString" Expression="capacity() &lt; bufSize()" />
+        <Intrinsic Name="isLongString" Expression="capacity() &gt;= bufSize()" />
+        <DisplayString Condition="isShortString()">{_Mypair._Myval2._Bx._Buf,s8}</DisplayString>
+        <DisplayString Condition="isLongString()">{_Mypair._Myval2._Bx._Ptr,s8}</DisplayString>
+        <StringView Condition="isShortString()">_Mypair._Myval2._Bx._Buf,s8</StringView>
+        <StringView Condition="isLongString()">_Mypair._Myval2._Bx._Ptr,s8</StringView>
+        <Expand>
+            <Item Name="[size]" ExcludeView="simple">size()</Item>
+            <Item Name="[capacity]" ExcludeView="simple">capacity()</Item>
+            <Item Name="[allocator]" ExcludeView="simple">_Mypair</Item>
+            <ArrayItems>
+                <Size>_Mypair._Myval2._Mysize</Size>
+                <ValuePointer Condition="isShortString()">_Mypair._Myval2._Bx._Buf</ValuePointer>
+                <ValuePointer Condition="isLongString()">_Mypair._Myval2._Bx._Ptr</ValuePointer>
+            </ArrayItems>
+        </Expand>
+    </Type>
+
+    <Type Name="std::basic_string_view&lt;YYCC::yycc_char8_t,*&gt;">
+        <AlternativeType Name="std::basic_string_view&lt;char8_t,*&gt;" />
+        <AlternativeType Name="std::basic_string_view&lt;unsigned char,*&gt;" />
+        <Intrinsic Name="size" Expression="_Mysize" />
+        <Intrinsic Name="data" Expression="_Mydata" />
+        <DisplayString>{_Mydata,[_Mysize],s8}</DisplayString>
+        <StringView>_Mydata,[_Mysize],s8</StringView>
+        <Expand>
+            <Item Name="[size]" ExcludeView="simple">size()</Item>
+            <ArrayItems>
+                <Size>size()</Size>
+                <ValuePointer>data()</ValuePointer>
+            </ArrayItems>
+        </Expand>
+    </Type>
+
+</AutoVisualizer>

src/YYCCInternal.hpp

@@ -26,8 +26,14 @@
 
 // Define the UTF8 char type we used.
 // And do a polyfill if no embedded char8_t type.
+
 #include <string>
 #include <string_view>
+
+/**
+ * @brief Library core namespace
+ * @details Almost library functions are located in this namespace.
+*/
 namespace YYCC {
 #if defined(__cpp_char8_t)
 	using yycc_char8_t = char8_t;
@@ -38,6 +44,27 @@ namespace YYCC {
 	using yycc_u8string = std::basic_string<yycc_char8_t>;
 	using yycc_u8string_view = std::basic_string_view<yycc_char8_t>;
 #endif
-	
 }
+/**
+	\typedef yycc_char8_t
+	\brief YYCC UTF8 char type.
+	\details
+	This char type is an alias to \c std::char8_t if your current C++ standard support it.
+	Otherwise it is defined as <TT>unsigned char</TT> as C++ 20 stdandard does.
+*/
+/**
+	\typedef yycc_u8string
+	\brief YYCC UTF8 string container type.
+	\details
+	This type is defined as \c std::basic_string<yycc_char8_t>.
+	It is equal to \c std::u8string if your current C++ standard support it.
+*/
+/**
+	\typedef yycc_u8string_view
+	\brief YYCC UTF8 string view type.
+	\details
+	This type is defined as \c std::basic_string_view<yycc_char8_t>.
+	It is equal to \c std::u8string_view if your current C++ standard support it.
+*/
+
 

src/YYCCommonplace.hpp

@@ -2,13 +2,15 @@
 
 #include "YYCCInternal.hpp"
 
-#include "StringHelper.hpp"
 #include "EncodingHelper.hpp"
+#include "StringHelper.hpp"
 #include "ConsoleHelper.hpp"
 #include "COMHelper.hpp"
 #include "DialogHelper.hpp"
 #include "ParserHelper.hpp"
-#include "ExceptionHelper.hpp"
 #include "IOHelper.hpp"
 #include "WinFctHelper.hpp"
 #include "FsPathPatch.hpp"
+#include "ExceptionHelper.hpp"
+
+#include "ConfigManager.hpp"

testbench/CMakeLists.txt

@@ -35,7 +35,6 @@ PRIVATE
 
 # Install testbench only on Release mode
 install(TARGETS YYCCTestbench
-    EXPORT YYCCTestbenchTargets
     CONFIGURATIONS Release
-    RUNTIME DESTINATION ${YYCC_INSTALL_PATH_BIN}
+    RUNTIME DESTINATION ${YYCC_INSTALL_BIN_PATH}
 )

testbench/main.cpp

@@ -23,12 +23,12 @@ namespace YYCCTestbench {
 #define TEST_UNICODE_STR_EMOJI "\U0001F363 \u2716 \U0001F37A" // sushi x beer mug
 
 #define CONCAT(prefix, strl) prefix ## strl
-#define CPP_U8_LITERAL(strl) reinterpret_cast<const char*>(CONCAT(u8, strl))
+#define CPP_U8_LITERAL(strl) YYCC_U8(strl)
 #define CPP_U16_LITERAL(strl) CONCAT(u, strl)
 #define CPP_U32_LITERAL(strl) CONCAT(U, strl)
 #define CPP_WSTR_LITERAL(strl) CONCAT(L, strl)
 
-	static std::vector<std::string> c_UTF8TestStrTable {
+	static std::vector<YYCC::yycc_u8string> c_UTF8TestStrTable {
 		CPP_U8_LITERAL(TEST_UNICODE_STR_JAPAN),
 		CPP_U8_LITERAL(TEST_UNICODE_STR_CHINA),
 		CPP_U8_LITERAL(TEST_UNICODE_STR_KOREA),
@@ -93,11 +93,11 @@ namespace YYCCTestbench {
 
 #pragma endregion
 
-	static void Assert(bool condition, const char* description) {
+	static void Assert(bool condition, const YYCC::yycc_char8_t* description) {
 		if (condition) {
-			Console::FormatLine(YYCC_COLOR_LIGHT_GREEN("OK: %s"), description);
+			Console::FormatLine(YYCC_U8(YYCC_COLOR_LIGHT_GREEN("OK: %s")), description);
 		} else {
-			Console::FormatLine(YYCC_COLOR_LIGHT_RED("Failed: %s\n"), description);
+			Console::FormatLine(YYCC_U8(YYCC_COLOR_LIGHT_RED("Failed: %s\n")), description);
 			std::abort();
 		}
 	}
@@ -105,9 +105,9 @@ namespace YYCCTestbench {
 	static void ConsoleTestbench() {
 		// Color Test
 		Console::EnableColorfulConsole();
-		Console::WriteLine("Color Test:");
+		Console::WriteLine(YYCC_U8("Color Test:"));
 
-#define TEST_MACRO(col) Console::WriteLine("\t" YYCC_COLOR_ ## col ("\u2588\u2588") YYCC_COLOR_LIGHT_ ## col("\u2588\u2588") " " #col " / LIGHT " #col );
+#define TEST_MACRO(col) Console::WriteLine(YYCC_U8("\t" YYCC_COLOR_ ## col ("\u2588\u2588") YYCC_COLOR_LIGHT_ ## col("\u2588\u2588") " " #col " / LIGHT " #col ));
 		// U+2588 is full block
 
 		TEST_MACRO(BLACK);
@@ -122,19 +122,20 @@ namespace YYCCTestbench {
 #undef TEST_MACRO
 
 		// UTF8 Output Test
-		Console::WriteLine("UTF8 Output Test:");
+		Console::WriteLine(YYCC_U8("UTF8 Output Test:"));
 		for (const auto& strl : c_UTF8TestStrTable) {
-			Console::FormatLine("\t%s", strl.c_str());
+			Console::FormatLine(YYCC_U8("\t%s"), strl.c_str());
 		}
 
 		// UTF8 Input Test
-		Console::WriteLine("UTF8 Input Test:");
+		Console::WriteLine(YYCC_U8("UTF8 Input Test:"));
 		for (const auto& strl : c_UTF8TestStrTable) {
-			Console::FormatLine("\tPlease type: %s", strl.c_str());
-			Console::Write("\t> ");
+			Console::FormatLine(YYCC_U8("\tPlease type: %s"), strl.c_str());
+			Console::Write(YYCC_U8("\t> "));
 
-			std::string gotten(Console::ReadLine());
-			Assert(gotten == strl, YYCC::StringHelper::Printf("Got: %s", gotten.c_str()).c_str());
+			YYCC::yycc_u8string gotten(Console::ReadLine());
+			if (gotten == strl) Console::FormatLine(YYCC_U8(YYCC_COLOR_LIGHT_GREEN("\tMatched! Got: %s")), gotten.c_str());
+			else Console::FormatLine(YYCC_U8(YYCC_COLOR_LIGHT_RED("\tNOT Matched! Got: %s")), gotten.c_str());
 		}
 
 	}
@@ -151,16 +152,16 @@ namespace YYCCTestbench {
 			const auto& u32str = c_UTF32TestStrTable[i];
 
 			// create cache variables
-			std::string u8cache;
+			YYCC::yycc_u8string u8cache;
 			std::u16string u16cache;
 			std::u32string u32cache;
 
 			// do convertion check
-			Assert(YYCC::EncodingHelper::UTF8ToUTF16(u8str.c_str(), u16cache) && u16cache == u16str, "YYCC::EncodingHelper::UTF8ToUTF16");
-			Assert(YYCC::EncodingHelper::UTF8ToUTF32(u8str.c_str(), u32cache) && u32cache == u32str, "YYCC::EncodingHelper::UTF8ToUTF32");
+			Assert(YYCC::EncodingHelper::UTF8ToUTF16(u8str, u16cache) && u16cache == u16str, YYCC_U8("YYCC::EncodingHelper::UTF8ToUTF16"));
+			Assert(YYCC::EncodingHelper::UTF8ToUTF32(u8str, u32cache) && u32cache == u32str, YYCC_U8("YYCC::EncodingHelper::UTF8ToUTF32"));
 
-			Assert(YYCC::EncodingHelper::UTF16ToUTF8(u16str.c_str(), u8cache) && u8cache == u8str, "YYCC::EncodingHelper::UTF16ToUTF8");
-			Assert(YYCC::EncodingHelper::UTF32ToUTF8(u32str.c_str(), u8cache) && u8cache == u8str, "YYCC::EncodingHelper::UTF32ToUTF8");
+			Assert(YYCC::EncodingHelper::UTF16ToUTF8(u16str, u8cache) && u8cache == u8str, YYCC_U8("YYCC::EncodingHelper::UTF16ToUTF8"));
+			Assert(YYCC::EncodingHelper::UTF32ToUTF8(u32str, u8cache) && u8cache == u8str, YYCC_U8("YYCC::EncodingHelper::UTF32ToUTF8"));
 		}
 
 		// check wstring convertion on windows
@@ -171,12 +172,12 @@ namespace YYCCTestbench {
 			const auto& wstr = c_WStrTestStrTable[i];
 
 			// create cache variables
-			std::string u8cache;
+			YYCC::yycc_u8string u8cache;
 			std::wstring wcache;
 
 			// do convertion check
-			Assert(YYCC::EncodingHelper::UTF8ToWchar(u8str.c_str(), wcache) && wcache == wstr, "YYCC::EncodingHelper::UTF8ToWchar");
-			Assert(YYCC::EncodingHelper::WcharToUTF8(wstr.c_str(), u8cache) && u8cache == u8str, "YYCC::EncodingHelper::WcharToUTF8");
+			Assert(YYCC::EncodingHelper::UTF8ToWchar(u8str.c_str(), wcache) && wcache == wstr, YYCC_U8("YYCC::EncodingHelper::UTF8ToWchar"));
+			Assert(YYCC::EncodingHelper::WcharToUTF8(wstr.c_str(), u8cache) && u8cache == u8str, YYCC_U8("YYCC::EncodingHelper::WcharToUTF8"));
 		}
 #endif
 
@@ -184,55 +185,58 @@ namespace YYCCTestbench {
 
 	static void StringTestbench() {
 		// Test Printf
-		auto test_printf = YYCC::StringHelper::Printf("%s == %s", "Hello World", "Hello, world");
-		Assert(test_printf == "Hello World == Hello, world", "YYCC::StringHelper::Printf");
+		auto test_printf = YYCC::StringHelper::Printf(YYCC_U8("%s == %s"), YYCC_U8("Hello World"), YYCC_U8("Hello, world"));
+		Assert(test_printf == YYCC_U8("Hello World == Hello, world"), YYCC_U8("YYCC::StringHelper::Printf"));
 
 		// Test Replace
-		auto test_replace = YYCC::StringHelper::Replace("aabbcc", "bb", "dd"); // normal case
-		Assert(test_replace == "aaddcc", "YYCC::StringHelper::Replace");
-		test_replace = YYCC::StringHelper::Replace("aabbcc", "zz", "yy"); // no replace
-		Assert(test_replace == "aabbcc", "YYCC::StringHelper::Replace");
-		test_replace = YYCC::StringHelper::Replace("aabbcc", "", "zz"); // empty finding
-		Assert(test_replace == "aabbcc", "YYCC::StringHelper::Replace");
-		test_replace = YYCC::StringHelper::Replace("aabbcc", nullptr, "zz"); // nullptr finding
-		Assert(test_replace == "aabbcc", "YYCC::StringHelper::Replace");
-		test_replace = YYCC::StringHelper::Replace("aaaabbaa", "aa", ""); // no replaced string
-		Assert(test_replace == "bb", "YYCC::StringHelper::Replace");
-		test_replace = YYCC::StringHelper::Replace("aaxcc", "x", "yx"); // nested replacing
-		Assert(test_replace == "aayxcc", "YYCC::StringHelper::Replace");
-		test_replace = YYCC::StringHelper::Replace("", "", "xy"); // empty source string
-		Assert(test_replace == "", "YYCC::StringHelper::Replace");
-		test_replace = YYCC::StringHelper::Replace(nullptr, "", "xy"); // nullptr source string
-		Assert(test_replace == "", "YYCC::StringHelper::Replace");
+		auto test_replace = YYCC::StringHelper::Replace(YYCC_U8("aabbcc"), YYCC_U8("bb"), YYCC_U8("dd")); // normal case
+		Assert(test_replace == YYCC_U8("aaddcc"), YYCC_U8("YYCC::StringHelper::Replace"));
+		test_replace = YYCC::StringHelper::Replace(YYCC_U8("aabbcc"), YYCC_U8("zz"), YYCC_U8("yy")); // no replace
+		Assert(test_replace == YYCC_U8("aabbcc"), YYCC_U8("YYCC::StringHelper::Replace"));
+		test_replace = YYCC::StringHelper::Replace(YYCC_U8("aabbcc"), YYCC_U8(""), YYCC_U8("zz")); // empty finding
+		Assert(test_replace == YYCC_U8("aabbcc"), YYCC_U8("YYCC::StringHelper::Replace"));
+		test_replace = YYCC::StringHelper::Replace(YYCC_U8("aabbcc"), nullptr, YYCC_U8("zz")); // nullptr finding
+		Assert(test_replace == YYCC_U8("aabbcc"), YYCC_U8("YYCC::StringHelper::Replace"));
+		test_replace = YYCC::StringHelper::Replace(YYCC_U8("aaaabbaa"), YYCC_U8("aa"), YYCC_U8("")); // no replaced string
+		Assert(test_replace == YYCC_U8("bb"), YYCC_U8("YYCC::StringHelper::Replace"));
+		test_replace = YYCC::StringHelper::Replace(YYCC_U8("aaxcc"), YYCC_U8("x"), YYCC_U8("yx")); // nested replacing
+		Assert(test_replace == YYCC_U8("aayxcc"), YYCC_U8("YYCC::StringHelper::Replace"));
+		test_replace = YYCC::StringHelper::Replace(YYCC_U8(""), YYCC_U8(""), YYCC_U8("xy")); // empty source string
+		Assert(test_replace == YYCC_U8(""), YYCC_U8("YYCC::StringHelper::Replace"));
+		test_replace = YYCC::StringHelper::Replace(nullptr, YYCC_U8(""), YYCC_U8("xy")); // nullptr source string
+		Assert(test_replace == YYCC_U8(""), YYCC_U8("YYCC::StringHelper::Replace"));
 
 		// Test Upper / Lower
-		auto test_lower = YYCC::StringHelper::Lower("LOWER");
-		Assert(test_lower == "lower", "YYCC::StringHelper::Lower");
-		auto test_upper = YYCC::StringHelper::Upper("upper");
-		Assert(test_upper == "UPPER", "YYCC::StringHelper::Upper");
+		auto test_lower = YYCC::StringHelper::Lower(YYCC_U8("LOWER"));
+		Assert(test_lower == YYCC_U8("lower"), YYCC_U8("YYCC::StringHelper::Lower"));
+		auto test_upper = YYCC::StringHelper::Upper(YYCC_U8("upper"));
+		Assert(test_upper == YYCC_U8("UPPER"), YYCC_U8("YYCC::StringHelper::Upper"));
 
 		// Test Join
-		std::vector<std::string> test_join_container {
-			"", "1", "2", ""
+		std::vector<YYCC::yycc_u8string> test_join_container {
+			YYCC_U8(""), YYCC_U8("1"), YYCC_U8("2"), YYCC_U8("")
 		};
-		auto test_join = YYCC::StringHelper::Join(test_join_container, ", ");
-		Assert(test_join == ", 1, 2, ", "YYCC::StringHelper::Join");
-		test_join = YYCC::StringHelper::Join(test_join_container, ", ", true);
-		Assert(test_join == ", 2, 1, ", "YYCC::StringHelper::Join");
+		auto test_join = YYCC::StringHelper::Join(test_join_container, YYCC_U8(", "));
+		Assert(test_join == YYCC_U8(", 1, 2, "), YYCC_U8("YYCC::StringHelper::Join"));
+		test_join = YYCC::StringHelper::Join(test_join_container, YYCC_U8(", "), true);
+		Assert(test_join == YYCC_U8(", 2, 1, "), YYCC_U8("YYCC::StringHelper::Join"));
 
 		// Test Split
-		auto test_split = YYCC::StringHelper::Split(", 1, 2, ", ", ");
-		Assert(test_split.size() == 4u, "YYCC::StringHelper::Split");
-		Assert(test_split[0] == "", "YYCC::StringHelper::Split");
-		Assert(test_split[1] == "1", "YYCC::StringHelper::Split");
-		Assert(test_split[2] == "2", "YYCC::StringHelper::Split");
-		Assert(test_split[3] == "", "YYCC::StringHelper::Split");
-		test_split = YYCC::StringHelper::Split("test", "-");
-		Assert(test_split.size() == 1u, "YYCC::StringHelper::Split");
-		Assert(test_split[0] == "test", "YYCC::StringHelper::Split");
-		test_split = YYCC::StringHelper::Split("test", "");
-		Assert(test_split.size() == 1u, "YYCC::StringHelper::Split");
-		Assert(test_split[0] == "test", "YYCC::StringHelper::Split");
+		auto test_split = YYCC::StringHelper::Split(YYCC_U8(", 1, 2, "), YYCC_U8(", ")); // normal
+		Assert(test_split.size() == 4u, YYCC_U8("YYCC::StringHelper::Split"));
+		Assert(test_split[0] == YYCC_U8(""), YYCC_U8("YYCC::StringHelper::Split"));
+		Assert(test_split[1] == YYCC_U8("1"), YYCC_U8("YYCC::StringHelper::Split"));
+		Assert(test_split[2] == YYCC_U8("2"), YYCC_U8("YYCC::StringHelper::Split"));
+		Assert(test_split[3] == YYCC_U8(""), YYCC_U8("YYCC::StringHelper::Split"));
+		test_split = YYCC::StringHelper::Split(YYCC_U8("test"), YYCC_U8("-")); // no matched decilmer
+		Assert(test_split.size() == 1u, YYCC_U8("YYCC::StringHelper::Split"));
+		Assert(test_split[0] == YYCC_U8("test"), YYCC_U8("YYCC::StringHelper::Split"));
+		test_split = YYCC::StringHelper::Split(YYCC_U8("test"), YYCC_U8("")); // empty decilmer
+		Assert(test_split.size() == 1u, YYCC_U8("YYCC::StringHelper::Split"));
+		Assert(test_split[0] == YYCC_U8("test"), YYCC_U8("YYCC::StringHelper::Split"));
+		test_split = YYCC::StringHelper::Split(YYCC::yycc_u8string_view(), YYCC_U8("")); // empty source string
+		Assert(test_split.size() == 1u, YYCC_U8("YYCC::StringHelper::Split"));
+		Assert(test_split[0].empty(), YYCC_U8("YYCC::StringHelper::Split"));
 
 	}
 
@@ -240,9 +244,9 @@ namespace YYCCTestbench {
 
 		// Test success TryParse
 #define TEST_MACRO(type_t, value, string_value) { \
-	std::string cache_string(string_value); \
+	YYCC::yycc_u8string cache_string(YYCC_U8(string_value)); \
 	type_t cache; \
-	Assert(YYCC::ParserHelper::TryParse<type_t>(cache_string, cache) && cache == value, "YYCC::StringHelper::TryParse<" #type_t ">"); \
+	Assert(YYCC::ParserHelper::TryParse<type_t>(cache_string, cache) && cache == value, YYCC_U8("YYCC::StringHelper::TryParse<" #type_t ">")); \
 }
 
 		TEST_MACRO(int8_t, INT8_C(-61), "-61");
@@ -259,9 +263,9 @@ namespace YYCCTestbench {
 
 		// Test failed TryParse
 #define TEST_MACRO(type_t, value, string_value) { \
-	std::string cache_string(string_value); \
+	YYCC::yycc_u8string cache_string(YYCC_U8(string_value)); \
 	type_t cache; \
-	Assert(!YYCC::ParserHelper::TryParse<type_t>(cache_string, cache), "YYCC::StringHelper::TryParse<" #type_t ">"); \
+	Assert(!YYCC::ParserHelper::TryParse<type_t>(cache_string, cache), YYCC_U8("YYCC::StringHelper::TryParse<" #type_t ">")); \
 }
 
 		TEST_MACRO(int8_t, INT8_C(-61), "6161");
@@ -279,8 +283,8 @@ namespace YYCCTestbench {
 		// Test ToString
 #define TEST_MACRO(type_t, value, string_value) { \
 	type_t cache = value; \
-	std::string ret(YYCC::ParserHelper::ToString<type_t>(cache)); \
-	Assert(ret == string_value, "YYCC::StringHelper::ToString<" #type_t ">"); \
+	YYCC::yycc_u8string ret(YYCC::ParserHelper::ToString<type_t>(cache)); \
+	Assert(ret == YYCC_U8(string_value), YYCC_U8("YYCC::StringHelper::ToString<" #type_t ">")); \
 }
 
 		TEST_MACRO(int8_t, INT8_C(-61), "-61");
@@ -292,11 +296,7 @@ namespace YYCCTestbench {
 		TEST_MACRO(int64_t, INT64_C(616161616161), "616161616161");
 		TEST_MACRO(uint64_t, UINT64_C(9223372036854775807), "9223372036854775807");
 		TEST_MACRO(bool, true, "true");
-		//{
-		//	bool cache = true;
-		//	std::string ret(YYCC::ParserHelper::ToString<bool>(cache));
-		//	Assert(ret == "true", "YYCC::StringHelper::ToString<bool>");
-		//}
+
 
 #undef TEST_MACRO
 	}
@@ -304,32 +304,32 @@ namespace YYCCTestbench {
 	static void DialogTestbench() {
 #if YYCC_OS == YYCC_OS_WINDOWS
 
-		std::string ret;
-		std::vector<std::string> rets;
+		YYCC::yycc_u8string ret;
+		std::vector<YYCC::yycc_u8string> rets;
 
 		YYCC::DialogHelper::FileDialog params;
 		auto& filters = params.ConfigreFileTypes();
-		filters.Add("Microsoft Word (*.docx; *.doc)", { "*.docx", "*.doc" });
-		filters.Add("Microsoft Excel (*.xlsx; *.xls)", { "*.xlsx", "*.xls" });
-		filters.Add("Microsoft PowerPoint (*.pptx; *.ppt)", { "*.pptx", "*.ppt" });
-		filters.Add("Text File (*.txt)", { "*.txt" });
-		filters.Add("All Files (*.*)", { "*.*" });
+		filters.Add(YYCC_U8("Microsoft Word (*.docx; *.doc)"), { YYCC_U8("*.docx"), YYCC_U8("*.doc") });
+		filters.Add(YYCC_U8("Microsoft Excel (*.xlsx; *.xls)"), { YYCC_U8("*.xlsx"), YYCC_U8("*.xls") });
+		filters.Add(YYCC_U8("Microsoft PowerPoint (*.pptx; *.ppt)"), { YYCC_U8("*.pptx"), YYCC_U8("*.ppt") });
+		filters.Add(YYCC_U8("Text File (*.txt)"), { YYCC_U8("*.txt") });
+		filters.Add(YYCC_U8("All Files (*.*)"), { YYCC_U8("*.*") });
 		params.SetDefaultFileTypeIndex(0u);
 		if (YYCC::DialogHelper::OpenFileDialog(params, ret)) {
-			Console::FormatLine("Open File: %s", ret.c_str());
+			Console::FormatLine(YYCC_U8("Open File: %s"), ret.c_str());
 		}
 		if (YYCC::DialogHelper::OpenMultipleFileDialog(params, rets)) {
-			Console::WriteLine("Open Multiple Files:");
+			Console::WriteLine(YYCC_U8("Open Multiple Files:"));
 			for (const auto& item : rets) {
-				Console::FormatLine("\t%s", item.c_str());
+				Console::FormatLine(YYCC_U8("\t%s"), item.c_str());
 			}
 		}
 		if (YYCC::DialogHelper::SaveFileDialog(params, ret)) {
-			Console::FormatLine("Save File: %s", ret.c_str());
+			Console::FormatLine(YYCC_U8("Save File: %s"), ret.c_str());
 		}
 		params.Clear();
 		if (YYCC::DialogHelper::OpenFolderDialog(params, ret)) {
-			Console::FormatLine("Open Folder: %s", ret.c_str());
+			Console::FormatLine(YYCC_U8("Open Folder: %s"), ret.c_str());
 		}
 
 #endif
@@ -353,20 +353,20 @@ namespace YYCCTestbench {
 #if YYCC_OS == YYCC_OS_WINDOWS
 
 		HMODULE test_current_module;
-		Assert((test_current_module = YYCC::WinFctHelper::GetCurrentModule()) != nullptr, "YYCC::WinFctHelper::GetCurrentModule");
-		Console::FormatLine("Current Module HANDLE: 0x%" PRI_XPTR_LEFT_PADDING PRIXPTR, test_current_module);
+		Assert((test_current_module = YYCC::WinFctHelper::GetCurrentModule()) != nullptr, YYCC_U8("YYCC::WinFctHelper::GetCurrentModule"));
+		Console::FormatLine(YYCC_U8("Current Module HANDLE: 0x%" PRI_XPTR_LEFT_PADDING PRIXPTR), test_current_module);
 
-		std::string test_temp;
-		Assert(YYCC::WinFctHelper::GetTempDirectory(test_temp), "YYCC::WinFctHelper::GetTempDirectory");
-		Console::FormatLine("Temp Directory: %s", test_temp.c_str());
+		YYCC::yycc_u8string test_temp;
+		Assert(YYCC::WinFctHelper::GetTempDirectory(test_temp), YYCC_U8("YYCC::WinFctHelper::GetTempDirectory"));
+		Console::FormatLine(YYCC_U8("Temp Directory: %s"), test_temp.c_str());
 
-		std::string test_module_name;
-		Assert(YYCC::WinFctHelper::GetModuleFileName(YYCC::WinFctHelper::GetCurrentModule(), test_module_name), "YYCC::WinFctHelper::GetModuleFileName");
-		Console::FormatLine("Current Module File Name: %s", test_module_name.c_str());
+		YYCC::yycc_u8string test_module_name;
+		Assert(YYCC::WinFctHelper::GetModuleFileName(YYCC::WinFctHelper::GetCurrentModule(), test_module_name), YYCC_U8("YYCC::WinFctHelper::GetModuleFileName"));
+		Console::FormatLine(YYCC_U8("Current Module File Name: %s"), test_module_name.c_str());
 
-		std::string test_localappdata_path;
-		Assert(YYCC::WinFctHelper::GetLocalAppData(test_localappdata_path), "YYCC::WinFctHelper::GetLocalAppData");
-		Console::FormatLine("Local AppData: %s", test_localappdata_path.c_str());
+		YYCC::yycc_u8string test_localappdata_path;
+		Assert(YYCC::WinFctHelper::GetLocalAppData(test_localappdata_path), YYCC_U8("YYCC::WinFctHelper::GetLocalAppData"));
+		Console::FormatLine(YYCC_U8("Local AppData: %s"), test_localappdata_path.c_str());
 
 #endif
 	}
@@ -377,29 +377,126 @@ namespace YYCCTestbench {
 		for (const auto& strl : c_UTF8TestStrTable) {
 			test_path /= YYCC::FsPathPatch::FromUTF8Path(strl.c_str());
 		}
-		std::string test_slashed_path(YYCC::FsPathPatch::ToUTF8Path(test_path));
+		YYCC::yycc_u8string test_slashed_path(YYCC::FsPathPatch::ToUTF8Path(test_path));
 
 #if YYCC_OS == YYCC_OS_WINDOWS
 		std::wstring wdecilmer(1u, std::filesystem::path::preferred_separator);
-		std::string decilmer(YYCC::EncodingHelper::WcharToUTF8(wdecilmer.c_str()));
+		YYCC::yycc_u8string decilmer(YYCC::EncodingHelper::WcharToUTF8(wdecilmer.c_str()));
 #else
-		std::string decilmer(1u, std::filesystem::path::preferred_separator);
+		YYCC::yycc_u8string decilmer(1u, std::filesystem::path::preferred_separator);
 #endif
-		std::string test_joined_path(YYCC::StringHelper::Join(c_UTF8TestStrTable, decilmer.c_str()));
+		YYCC::yycc_u8string test_joined_path(YYCC::StringHelper::Join(c_UTF8TestStrTable, decilmer.c_str()));
 
-		Assert(test_slashed_path == test_joined_path, "YYCC::FsPathPatch");
+		Assert(test_slashed_path == test_joined_path, YYCC_U8("YYCC::FsPathPatch"));
 
 	}
 
+	class TestConfigManager {
+	public:
+		enum class TestEnum : int8_t {
+			Test1, Test2, Test3
+		};
+
+		TestConfigManager() :
+			m_IntSetting(YYCC_U8("int-setting"), INT32_C(0)),
+			m_FloatSetting(YYCC_U8("float-setting"), 0.0f),
+			m_StringSetting(YYCC_U8("string-setting"), YYCC_U8("")),
+			m_BoolSetting(YYCC_U8("bool-setting"), false),
+			m_ClampedFloatSetting(YYCC_U8("clamped-float-setting"), 0.0f, YYCC::ConfigManager::ConstraintPresets::GetNumberRangeConstraint<float>(-1.0f, 1.0f)),
+			m_EnumSetting(YYCC_U8("enum-setting"), TestEnum::Test1),
+			m_CoreManager(YYCC_U8("test.cfg"), UINT64_C(0), {
+				&m_IntSetting, &m_FloatSetting, &m_StringSetting, &m_BoolSetting, &m_ClampedFloatSetting, &m_EnumSetting
+			})
+		{}
+		~TestConfigManager() {}
+
+		void PrintSettings() {
+			Console::WriteLine(YYCC_U8("Config Manager Settings:"));
+
+			Console::FormatLine(YYCC_U8("\tint-setting: %" PRIi32), m_IntSetting.Get());
+			Console::FormatLine(YYCC_U8("\tfloat-setting: %f"), m_FloatSetting.Get());
+			Console::FormatLine(YYCC_U8("\tstring-setting: %s"), m_StringSetting.Get().c_str());
+
+			Console::FormatLine(YYCC_U8("\tbool-setting: %s"), m_BoolSetting.Get() ? YYCC_U8("true") : YYCC_U8("false"));
+			Console::FormatLine(YYCC_U8("\tfloat-setting: %f"), m_ClampedFloatSetting.Get());
+			Console::FormatLine(YYCC_U8("\tenum-setting: %" PRIi8), static_cast<std::underlying_type_t<TestEnum>>(m_EnumSetting.Get()));
+		}
+
+		YYCC::ConfigManager::NumberSetting<int32_t> m_IntSetting;
+		YYCC::ConfigManager::NumberSetting<float> m_FloatSetting;
+		YYCC::ConfigManager::StringSetting m_StringSetting;
+
+		YYCC::ConfigManager::NumberSetting<bool> m_BoolSetting;
+		YYCC::ConfigManager::NumberSetting<float> m_ClampedFloatSetting;
+		YYCC::ConfigManager::NumberSetting<TestEnum> m_EnumSetting;
+
+		YYCC::ConfigManager::CoreManager m_CoreManager;
+	};
+
+	static void ConfigManagerTestbench() {
+		// init cfg manager
+		TestConfigManager test;
+
+		// test constraint works
+		Assert(!test.m_ClampedFloatSetting.Set(2.0f), YYCC_U8("YYCC::ConfigManager::Constraint"));
+		Assert(test.m_ClampedFloatSetting.Get() == 0.0f, YYCC_U8("YYCC::ConfigManager::Constraint"));
+
+		// test modify settings
+#define TEST_MACRO(member_name, set_val) { \
+	Assert(test.member_name.Set(set_val), YYCC_U8("YYCC::ConfigManager::AbstractSetting::Set")); \
+	Assert(test.member_name.Get() == set_val, YYCC_U8("YYCC::ConfigManager::AbstractSetting::Set")); \
+}
+
+		TEST_MACRO(m_IntSetting, INT32_C(114));
+		TEST_MACRO(m_FloatSetting, 2.0f);
+		TEST_MACRO(m_StringSetting, YYCC_U8("fuck"));
+		TEST_MACRO(m_BoolSetting, true);
+		TEST_MACRO(m_ClampedFloatSetting, 0.5f);
+		TEST_MACRO(m_EnumSetting, TestConfigManager::TestEnum::Test2);
+
+#undef TEST_MACRO
+		
+		// test save
+		test.PrintSettings();
+		Assert(test.m_CoreManager.Save(), YYCC_U8("YYCC::ConfigManager::CoreManager::Save"));
+
+		// test reset
+		test.m_CoreManager.Reset();
+		test.PrintSettings();
+		Assert(test.m_IntSetting.Get() == INT32_C(0), YYCC_U8("YYCC::ConfigManager::CoreManager::Reset"));
+		Assert(test.m_FloatSetting.Get() == 0.0f, YYCC_U8("YYCC::ConfigManager::CoreManager::Reset"));
+		Assert(test.m_StringSetting.Get() == YYCC_U8(""), YYCC_U8("YYCC::ConfigManager::CoreManager::Reset"));
+		Assert(test.m_BoolSetting.Get() == false, YYCC_U8("YYCC::ConfigManager::CoreManager::Reset"));
+		Assert(test.m_ClampedFloatSetting.Get() == 0.0f, YYCC_U8("YYCC::ConfigManager::CoreManager::Reset"));
+		Assert(test.m_EnumSetting.Get() == TestConfigManager::TestEnum::Test1, YYCC_U8("YYCC::ConfigManager::CoreManager::Reset"));
+
+		// test load
+		Assert(test.m_CoreManager.Load(), YYCC_U8("YYCC::ConfigManager::CoreManager::Load"));
+		test.PrintSettings();
+		Assert(test.m_IntSetting.Get() == INT32_C(114), YYCC_U8("YYCC::ConfigManager::CoreManager::Load"));
+		Assert(test.m_FloatSetting.Get() == 2.0f, YYCC_U8("YYCC::ConfigManager::CoreManager::Load"));
+		Assert(test.m_StringSetting.Get() == YYCC_U8("fuck"), YYCC_U8("YYCC::ConfigManager::CoreManager::Load"));
+		Assert(test.m_BoolSetting.Get() == true, YYCC_U8("YYCC::ConfigManager::CoreManager::Load"));
+		Assert(test.m_ClampedFloatSetting.Get() == 0.5f, YYCC_U8("YYCC::ConfigManager::CoreManager::Load"));
+		Assert(test.m_EnumSetting.Get() == TestConfigManager::TestEnum::Test2, YYCC_U8("YYCC::ConfigManager::CoreManager::Load"));
+		
+	}
+
 }
 
 int main(int argc, char** args) {
-	//YYCCTestbench::ConsoleTestbench();
+	// common testbench
+	// normal
 	YYCCTestbench::EncodingTestbench();
 	YYCCTestbench::StringTestbench();
 	YYCCTestbench::ParserTestbench();
-	YYCCTestbench::DialogTestbench();
-	YYCCTestbench::ExceptionTestbench();
 	YYCCTestbench::WinFctTestbench();
 	YYCCTestbench::FsPathPatch();
+	// advanced
+	YYCCTestbench::ConfigManagerTestbench();
+
+	// testbench which may terminal app or ordering input
+	YYCCTestbench::ConsoleTestbench();
+	YYCCTestbench::DialogTestbench();
+	YYCCTestbench::ExceptionTestbench();
 }