Modarnization and Windows multi user fix

.github/workflows/build_and_test.yml

@@ -0,0 +1,143 @@
+name: Build and Test
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        build_type: [Release]
+        include:
+          - os: ubuntu-latest
+            cc: gcc
+            cxx: g++
+          - os: windows-latest
+            cc: cl
+            cxx: cl
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup CMake
+        uses: jwlawson/actions-setup-cmake@master
+
+      - name: Configure CMake
+        run: cmake -B build
+
+      - name: Build
+        run: cmake --build build --config Release
+
+      - name: Test
+        run: cmake --build build --config Release --target run_test
+
+  release:
+    runs-on: ubuntu-latest
+    needs: build
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Determine library version
+        id: version
+        run: |
+          python - <<'PY'
+          import os
+          import re
+          from pathlib import Path
+
+          header = Path('include/libsharedmemory/libsharedmemory.hpp').read_text(encoding='utf-8')
+
+          def macro(name: str) -> str:
+              match = re.search(rf'#define\s+{name}\s+(\d+)', header)
+              if not match:
+                  raise SystemExit(f'Macro {name} not found in header')
+              return match.group(1)
+
+          major = macro('LIBSHAREDMEMORY_VERSION_MAJOR')
+          minor = macro('LIBSHAREDMEMORY_VERSION_MINOR')
+          patch = macro('LIBSHAREDMEMORY_VERSION_PATCH')
+          version = f'v{major}.{minor}.{patch}'
+
+          with open(os.environ['GITHUB_OUTPUT'], 'a', encoding='utf-8') as output:
+              output.write(f'version={version}\n')
+          PY
+
+      - name: Check if tag already exists
+        id: tag_check
+        run: |
+          git fetch --tags --force
+          if git rev-parse "${{ steps.version.outputs.version }}" >/dev/null 2>&1; then
+            echo "exists=true" >>"$GITHUB_OUTPUT"
+            exit 1
+          else
+            echo "exists=false" >>"$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+      - name: Generate release notes
+        if: steps.tag_check.outputs.exists == 'false'
+        id: notes
+        run: |
+          python - <<'PY'
+          import os
+          import subprocess
+
+          def git_output(args):
+              result = subprocess.run(args, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+              return result.stdout.strip()
+
+          last_tag = ""
+          try:
+              last_tag = git_output(["git", "describe", "--tags", "--abbrev=0"])
+          except subprocess.CalledProcessError:
+              last_tag = ""
+
+          if last_tag:
+              log_range = f"{last_tag}..HEAD"
+          else:
+              log_range = "HEAD"
+
+          try:
+              notes = git_output(["git", "log", log_range, "--pretty=format:- %s (%h)"])
+          except subprocess.CalledProcessError:
+              notes = ""
+
+          notes = notes.strip()
+          if not notes:
+              notes = "No commits since previous release."
+
+          if last_tag:
+              header = f"Changes since {last_tag}:"
+          else:
+              header = "Changes since repository start:"
+
+          body = f"{header}\n\n{notes}"
+
+          with open(os.environ["GITHUB_OUTPUT"], "a", encoding="utf-8") as fh:
+              fh.write("body<<EOF\n")
+              fh.write(body)
+              fh.write("\nEOF\n")
+          PY
+
+      - name: Create GitHub release
+        if: steps.tag_check.outputs.exists == 'false'
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ steps.version.outputs.version }}
+          release_name: ${{ steps.version.outputs.version }}
+          commitish: ${{ github.sha }}
+          body: ${{ steps.notes.outputs.body }}
+          draft: false
+          prerelease: false

.gitignore

@@ -1,3 +1,7 @@
 .cache
 .vscode
-build
+build
+.idea
+cmake-build-*
+_codeql_build_dir
+_codeql_detected_source_root

CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.9.0] - 2026-02-13
+
+### Added:
+
+- **Linux**: Default permissions set to 0777.
+
+
+## [1.8.0] - 2026-02-06
+
+### Added:
+
+- **Windows**: ACL inheritance for shared file, clean close/reopen when applying settings.
+
+## [1.7.0] - 2026-02-06
+
+### Added
+- **SharedMemoryQueue**: New FIFO message queue functionality for inter-process communication
+  - Thread-safe enqueue/dequeue operations using atomic counters
+  - Configurable capacity and maximum message size
+  - `peek()` method to inspect messages without removing them
+  - Status methods: `isEmpty()`, `isFull()`, `size()`, `capacity()`
+  - Supports single producer/single consumer and single producer/multiple consumers patterns
+- Windows persistency support for shared memory segments
+  - Persistent file-backed shared memory on Windows using `%PROGRAMDATA%/shared_memory/` directory
+  - Automatic directory creation and permission management on Windows
+  - Configurable persistence with `persist` parameter in constructor
+
+### Changed
+- Updated C++20 requirements with `std::atomic` support for queue operations
+- Improved memory layout with atomic operations for queue counters
+- Enhanced Windows implementation with better file handle management
+
+### Fixed
+- Memory leak prevention in queue implementation
+- Proper cleanup of shared memory on all platforms
+
+## Previous Versions
+
+Prior to version 1.7.0, the library supported:
+- Basic shared memory creation and access on Windows, Linux, and macOS
+- Stream-based data transfer with `SharedMemoryWriteStream` and `SharedMemoryReadStream`
+- Support for `std::string`, `float*`, and `double*` array types
+- Change detection with flag bit flipping
+- Single value access via `.data()[index]` API
+

CMakeLists.txt

@@ -1,6 +1,7 @@
 cmake_minimum_required(VERSION 3.12)
 cmake_policy(SET CMP0042 NEW)
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 project(LSM)
@@ -13,10 +14,10 @@ target_sources(lsm INTERFACE "$<BUILD_INTERFACE:${header_files}>")
 target_include_directories(lsm INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include/>)
 target_include_directories(lsm SYSTEM INTERFACE $<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>)
 
-if (${CMAKE_GENERATOR} MATCHES "Visual")
-    target_compile_options(lsm INTERFACE -W3 -EHsc)
+if (MSVC)
+    target_compile_options(lsm INTERFACE /W3 /EHsc /std:c++20)
 else()
-    target_compile_options(lsm INTERFACE -Wall -Wno-missing-braces -std=c++11 -fPIC)
+    target_compile_options(lsm INTERFACE -Wall -Wno-missing-braces -std=c++20 -fPIC)
 endif()
 
 option(LSM_BUILD_TEST "build test" ON)

README.md

@@ -1,6 +1,10 @@
 # `libsharedmemory`
 
-`libsharedmemory` is a small C++11 header-only library for using shared memory on Windows, Linux and macOS. `libsharedmemory` makes it easy to transfer data between isolated host OS processes. It also helps inter-connecting modules of applications that are implemented in different programming languages. It allows for simple read/write data transfer using single, indexed memory address access and also using array-types like `std::string`, `float*`, `double*`.
+`libsharedmemory` is a small C++20 header-only library for using shared memory on Windows, Linux and macOS. `libsharedmemory` makes it easy to transfer data between isolated host OS processes. It also helps inter-connecting modules of applications that are implemented in different programming languages. It supports:
+
+- Simple read/write data transfer using single, indexed memory address access
+- Array-types like `std::string`, `float*`, `double*`
+- Message queue functionality with `SharedMemoryQueue` for FIFO communication
 
 <img src="screenshot.png" width="350px" />
 
@@ -28,6 +32,34 @@ std::string dataString = read$.readString();
 std::cout << "UTF8 string written and read" << dataString << std::endl;
 ```
 
+### Message Queue Example
+
+```cpp
+// Create a message queue with capacity for 10 messages, max 256 bytes each
+SharedMemoryQueue writer{"messageQueue", /*capacity*/ 10, /*maxMessageSize*/ 256, /*persistent*/ true, /*isWriter*/ true};
+SharedMemoryQueue reader{"messageQueue", /*capacity*/ 10, /*maxMessageSize*/ 256, /*persistent*/ true, /*isWriter*/ false};
+
+// Enqueue messages from writer
+writer.enqueue("First message");
+writer.enqueue("Second message");
+
+// Dequeue messages from reader
+std::string msg;
+if (reader.dequeue(msg)) {
+    std::cout << "Received: " << msg << std::endl;
+}
+
+// Peek at next message without removing it
+if (reader.peek(msg)) {
+    std::cout << "Next message: " << msg << std::endl;
+}
+
+// Check queue status
+std::cout << "Queue size: " << reader.size() << std::endl;
+std::cout << "Is empty: " << reader.isEmpty() << std::endl;
+std::cout << "Is full: " << reader.isFull() << std::endl;
+```
+
 ## Source code package management via `npm`
 
 In case you want to use this library in your codebase,
@@ -45,27 +77,38 @@ reports that are announced when running `npm audit`. Finally, it's also much
 easier for you to install all project dependencies by just running `npm install`
 in your projects root directory. Managing third party code becomes obsolete at all. 
 
-## Limits
+## Features
 
-`libsharedmemory` does only support the following datatypes (array-like):
-- `std::string`
-- `float*`
-- `double*`
+### Stream-based Transfer
+`libsharedmemory` supports the following datatypes for stream-based transfer:
+- `std::string` (UTF-8 compatible)
+- `float*` (arrays of floats)
+- `double*` (arrays of doubles)
 
 Single value access via `.data()[index]` API:
 - all scalar datatypes supported in C/C++
 
-- This library doesn't care for endinanness. This should be naturally fine
+### Message Queue
+`SharedMemoryQueue` provides FIFO message queue functionality:
+- Thread-safe enqueue/dequeue operations
+- Configurable capacity and maximum message size
+- Peek functionality to inspect messages without removing them
+- Suitable for single producer, single consumer or single producer, multiple consumers patterns
+
+## Limits
+
+- This library doesn't care for endianness. This should be naturally fine
 because shared memory shouldn't be shared between different machine 
 architectures. However, if you plan to copy the shared buffer onto a 
-network layer prototcol, make sure to add an endianess indication bit.
+network layer protocol, make sure to add an endianness indication bit.
 
 - Although the binary memory layout should give you no headache
 when compiling/linking using different compilers, 
 the behavior is undefined.
 
-- At the time of writing, there is no support for shared memory persistency
-on Windows. Shared memory is lost after the writing process is killed.
+- **SharedMemoryQueue** currently works best for single producer, single consumer 
+or single producer, multiple consumers scenarios. Multiple concurrent producers 
+require additional external synchronization.
 
 ## Memory layout
 
@@ -92,29 +135,11 @@ enum DataType {
 to indicate data change. Continuous data reader will thus be able 
 to catch every data change. 
 
-## Build
-
-This project is meant to be built with `cmake` and `clang`.
-However, it _should_ also build with MSVC and GCC.
-
-```sh
-./build.sh
-```
-
-## Test
-
-Test executables are built automatically and can be executed
-to verify the correct function of the implementation on your machine:
-
-```sh
-./test.sh
-```
-
 ## License
 
 `libsharedmemory` is released under the MIT license, see the `LICENSE` file.
 
 ## Roadmap
 
-1) Windows shared memory persistency support
-2) Multi-threaded non-blocking `onChange( lambda fn )` data change handler on the read stream
+1) Multi-threaded non-blocking `onChange( lambda fn )` data change handler on the read stream
+2) Support for multiple concurrent producers in SharedMemoryQueue with lock-free atomic operations