Move sharedmemory/ to core/

2026-06-15 23:51:21 +05:30
parent f3e42a8b17
commit 329fc6e23f
9 changed files with 33 additions and 33 deletions
@@ -0,0 +1,17 @@
+/*
+File: FileHeader.h
+Description: Defines the FileHeader structure used to store
+             metadata for binary record files, including
+             record count and capacity.
+Author: Trenser
+Created: 10-June-2026
+*/
+
+#pragma once
+#include <cstddef>
+
+struct FileHeader
+{
+    size_t recordCount;
+    size_t capacity;
+};
@@ -0,0 +1,29 @@
+/*
+File: MappingInfo.h
+Description: Defines the MappingInfo structure used for
+             managing Windows file mapping operations.
+             Stores handles, mapped view pointer,
+             file metadata, and capacity information.
+Author: Trenser
+Created: 10-June-2026
+*/
+
+#pragma once
+#include <windows.h>
+#include <string>
+
+struct MappingInfo
+{
+    HANDLE fileHandle;
+    HANDLE mappingHandle;
+    void* mappedView;
+    std::string fileName;
+    size_t recordSize;
+    size_t mappedCapacity;
+    MappingInfo()
+        : fileHandle(NULL),
+        mappingHandle(NULL),
+        mappedView(nullptr),
+        recordSize(0),
+        mappedCapacity(0) {}
+};
@@ -0,0 +1,17 @@
+/*
+File: RecordState.h
+Description: Defines the RecordState enumeration used to
+             represent the state of a record in storage.
+             States include CLEAN, NEW_RECORD, and MODIFIED.
+Author: Trenser
+Created: 10-June-2026
+*/
+
+#pragma once
+
+enum class RecordState : int
+{
+    CLEAN,
+    NEW_RECORD,
+    MODIFIED
+};
@@ -0,0 +1,109 @@
+/*
+File: SerializedRecords.h
+Description: Defines serialized structures for persistent storage
+             and retrieval of system entities including User,
+             Notification, Service, ComboPackage, InventoryItem,
+             ServiceBooking, JobCard, Invoice, and Observer.
+             These structures use fixed-size character arrays
+             and primitive types for binary serialization.
+Author: Trenser
+Created: 10-June-2026
+*/
+
+#pragma once
+#include "Utility.h"
+#include "Enums.h"
+#include "Timestamp.h"
+
+struct SerializedUser
+{
+    char id[64];
+    char username[64];
+    char password[64];
+    char name[128];
+    char phone[32];
+    char email[128];
+    util::UserType userType;
+    util::State status;
+};
+
+struct SerializedNotification
+{
+    char id[64];
+    char recipientUserId[64];
+    char title[128];
+    char message[1024];
+    util::Timestamp createdAt;
+    util::State state;
+};
+
+struct SerializedService
+{
+    char id[64];
+    char name[128];
+    char inventoryItemIDs[1024];
+    double laborCost;
+    util::State status;
+};
+
+struct SerializedComboPackage
+{
+    char id[64];
+    char packageName[128];
+    double discountPercentage;
+    char serviceIDs[1024];
+    util::State status;
+};
+
+struct SerializedInventoryItem
+{
+    char id[64];
+    char partName[128];
+    int quantity;
+    double price;
+    util::State status;
+};
+
+struct SerializedServiceBooking
+{
+    char id[64];
+    util::ServiceJobStatus status;
+    char serviceIDs[1024];
+    char customerId[64];
+    char vehicleNumber[64];
+    char vehicleBrand[64];
+    char vehicleModel[64];
+    char assignedTechnicianId[64];
+    double discountPercentage;
+};
+
+struct SerializedJobCard
+{
+    char id[64];
+    char bookingId[64];
+    char serviceId[64];
+    char technicianId[64];
+    util::Timestamp assignedDate;
+    util::ServiceJobStatus status;
+    util::Timestamp completionDate;
+};
+
+struct SerializedInvoice
+{
+    char id[64];
+    char bookingId[64];
+    util::Timestamp invoiceDate;
+    char partIDs[1024];
+    double laborCost;
+    double partsCost;
+    double discountPercentage;
+    double totalAmount;
+    util::Timestamp paymentDate;
+    util::PaymentMode paymentMethod;
+    util::PaymentStatus status;
+};
+
+struct SerializedObserver
+{
+    char id[64];
+};
@@ -0,0 +1,386 @@
+/*
+File: SharedMemory.cpp
+Description: Implements shared memory utilities for managing
+             Windows file mapping operations. Provides functions
+             to create, open, resize, and close mappings, as well
+             as access headers, records, and ensure synchronization
+             across processes.
+Author: Trenser
+Created: 11-June-2026
+*/
+
+#include "SharedMemory.h"
+#include "Windows.h"
+#include "Config.h"
+
+/*
+Function: invalidateMapping
+Description: Releases all mapping resources and resets the mapping to an invalid state.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - None
+*/
+static void invalidateMapping(MappingInfo& mapping)
+{
+    if (mapping.mappedView != nullptr)
+    {
+        UnmapViewOfFile(mapping.mappedView);
+        mapping.mappedView = nullptr;
+    }
+    if (mapping.mappingHandle != NULL)
+    {
+        CloseHandle(mapping.mappingHandle);
+        mapping.mappingHandle = NULL;
+    }
+    if (mapping.fileHandle != INVALID_HANDLE_VALUE)
+    {
+        CloseHandle(mapping.fileHandle);
+        mapping.fileHandle = INVALID_HANDLE_VALUE;
+    }
+    mapping.mappedCapacity = 0;
+}
+
+/*
+Function: createOrOpenMapping
+Description: Creates or opens a file mapping and maps it into the process address space.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - bool: True if the mapping was successfully created/opened, otherwise false
+*/
+bool SharedMemory::createOrOpenMapping(MappingInfo& mapping)
+{
+    if (mapping.recordSize == 0)
+    {
+        return false;
+    }
+    mapping.fileHandle =
+        CreateFileA(
+            mapping.fileName.c_str(),
+            GENERIC_READ | GENERIC_WRITE,
+            FILE_SHARE_READ | FILE_SHARE_WRITE,
+            NULL,
+            OPEN_ALWAYS,
+            FILE_ATTRIBUTE_NORMAL,
+            NULL);
+    if (mapping.fileHandle == INVALID_HANDLE_VALUE)
+    {
+        return false;
+    }
+    LARGE_INTEGER fileSize;
+    if (!GetFileSizeEx(mapping.fileHandle, &fileSize))
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    bool isNewFile = (fileSize.QuadPart == 0);
+    const size_t initialCapacity = config::file::INITIAL_CAPACITY;
+    if (isNewFile)
+    {
+        LARGE_INTEGER newSize;
+        newSize.QuadPart = sizeof(FileHeader) + initialCapacity * mapping.recordSize;
+        if (!SetFilePointerEx(mapping.fileHandle, newSize, NULL, FILE_BEGIN))
+        {
+            invalidateMapping(mapping);
+            return false;
+        }
+        if (!SetEndOfFile(mapping.fileHandle))
+        {
+            invalidateMapping(mapping);
+            return false;
+        }
+    }
+    mapping.mappingHandle =
+        CreateFileMappingA(
+            mapping.fileHandle,
+            NULL,
+            PAGE_READWRITE,
+            0,
+            0,
+            NULL);
+    if (mapping.mappingHandle == NULL)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappedView =
+        MapViewOfFile(
+            mapping.mappingHandle,
+            FILE_MAP_ALL_ACCESS,
+            0,
+            0,
+            0);
+    if (mapping.mappedView == nullptr)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    FileHeader* header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    if (isNewFile)
+    {
+        header->recordCount = 0;
+        header->capacity = initialCapacity;
+    }
+    mapping.mappedCapacity = header->capacity;
+    return true;
+}
+
+/*
+Function: closeMapping
+Description: Unmaps and closes all resources associated with a file mapping.
+Parameters:
+    - mapping: MappingInfo&, mapping to close
+Returns:
+    - None
+*/
+void SharedMemory::closeMapping(MappingInfo& mapping)
+{
+    invalidateMapping(mapping);
+}
+
+/*
+Function: getHeader
+Description: Returns the file header stored at the beginning of the mapped memory region.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - FileHeader*: Pointer to the file header, or nullptr if the mapping is not valid
+*/
+FileHeader* SharedMemory::getHeader(MappingInfo& mapping)
+{
+    if (mapping.mappedView == nullptr)
+    {
+        return nullptr;
+    }
+    return reinterpret_cast<FileHeader*>(mapping.mappedView);
+}
+
+/*
+Function: getRecordAddress
+Description: Returns the address of a record at the specified index within the mapped memory region.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+    - index: size_t, record index
+Returns:
+    - void*: Pointer to the record, or nullptr if the mapping is not valid
+*/
+void* SharedMemory::getRecordAddress(MappingInfo& mapping, size_t index)
+{
+    if (mapping.mappedView == nullptr)
+    {
+        return nullptr;
+    }
+    return reinterpret_cast<char*>(mapping.mappedView) + sizeof(FileHeader) + index * mapping.recordSize;
+}
+
+/*
+Function: getRecordCount
+Description: Returns the number of records currently stored in the mapping.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - size_t: Number of records in the mapping
+*/
+size_t SharedMemory::getRecordCount(MappingInfo& mapping)
+{
+    FileHeader* header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        return 0;
+    }
+    return header->recordCount;
+}
+
+/*
+Function: setRecordCount
+Description: Updates the number of records stored in the mapping.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+    - count: size_t, new record count
+Returns:
+    - None
+*/
+void SharedMemory::setRecordCount(MappingInfo& mapping, size_t count)
+{
+    FileHeader* header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        return;
+    }
+    header->recordCount = count;
+}
+
+/*
+Function: getCapacity
+Description: Returns the current capacity of the mapping.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - size_t: Maximum number of records that can be stored in the mapping
+*/
+size_t SharedMemory::getCapacity(MappingInfo& mapping)
+{
+    FileHeader* header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        return 0;
+    }
+    return header->capacity;
+}
+
+/*
+Function: resizeMapping
+Description: Resizes the file mapping to the specified capacity.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+    - newCapacity: size_t, new mapping capacity
+Returns:
+    - bool: True if the resize succeeded, otherwise false
+*/
+bool SharedMemory::resizeMapping(MappingInfo& mapping, size_t newCapacity)
+{
+    FileHeader* header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    header->capacity = newCapacity;
+    if (!FlushViewOfFile(mapping.mappedView, sizeof(FileHeader)))
+    {
+        return false;
+    }
+    if (!UnmapViewOfFile(mapping.mappedView))
+    {
+        return false;
+    }
+    mapping.mappedView = nullptr;
+    CloseHandle(mapping.mappingHandle);
+    mapping.mappingHandle = NULL;
+    LARGE_INTEGER newSize;
+    newSize.QuadPart = sizeof(FileHeader) + newCapacity * mapping.recordSize;
+    if (!SetFilePointerEx(mapping.fileHandle, newSize, NULL, FILE_BEGIN))
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    if (!SetEndOfFile(mapping.fileHandle))
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappingHandle =
+        CreateFileMappingA(
+            mapping.fileHandle,
+            NULL,
+            PAGE_READWRITE,
+            0,
+            0,
+            NULL);
+    if (mapping.mappingHandle == NULL)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappedView =
+        MapViewOfFile(
+            mapping.mappingHandle,
+            FILE_MAP_ALL_ACCESS,
+            0,
+            0,
+            0);
+    if (mapping.mappedView == nullptr)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappedCapacity = newCapacity;
+    return true;
+}
+
+/*
+Function: ensureCapacityForInsert
+Description: Ensures that the mapping has space for at least one additional record, growing it if necessary.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - bool: True if capacity is available, otherwise false
+*/
+bool SharedMemory::ensureCapacityForInsert(MappingInfo& mapping)
+{
+    size_t recordCount = getRecordCount(mapping);
+    size_t capacity = getCapacity(mapping);
+    if (recordCount < capacity)
+    {
+        return true;
+    }
+    return resizeMapping(mapping, capacity * config::file::GROWTH_FACTOR);
+}
+
+/*
+Function: ensureLatestMapping
+Description: Remaps the file if another process has resized it.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - bool: True if the mapping is valid and up to date, otherwise false
+*/
+bool SharedMemory::ensureLatestMapping(MappingInfo& mapping)
+{
+    FileHeader* header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        return false;
+    }
+    if (header->capacity == mapping.mappedCapacity)
+    {
+        return true;
+    }
+    if (!UnmapViewOfFile(mapping.mappedView))
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappedView = nullptr;
+    CloseHandle(mapping.mappingHandle);
+    mapping.mappingHandle = NULL;
+    mapping.mappingHandle =
+        CreateFileMappingA(
+            mapping.fileHandle,
+            NULL,
+            PAGE_READWRITE,
+            0,
+            0,
+            NULL);
+    if (mapping.mappingHandle == NULL)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappedView =
+        MapViewOfFile(
+            mapping.mappingHandle,
+            FILE_MAP_ALL_ACCESS,
+            0,
+            0,
+            0);
+    if (mapping.mappedView == nullptr)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappedCapacity = header->capacity;
+    return true;
+}
@@ -0,0 +1,29 @@
+/*
+File: SharedMemory.h
+Description: Declares functions for managing Windows file
+             mapping and shared memory operations. Provides
+             utilities for creating, resizing, and closing
+             mappings, as well as accessing headers and
+             record data.
+Author: Trenser
+Created: 10-June-2026
+*/
+
+#pragma once
+#include <cstddef>
+#include "MappingInfo.h"
+#include "FileHeader.h"
+
+namespace SharedMemory
+{
+    bool createOrOpenMapping(MappingInfo& mapping);
+    void closeMapping(MappingInfo& mapping);
+    bool ensureLatestMapping(MappingInfo& mapping);
+    bool resizeMapping(MappingInfo& mapping, size_t newCapacity);
+    FileHeader* getHeader(MappingInfo& mapping);
+    void* getRecordAddress(MappingInfo& mapping, size_t index);
+    size_t getRecordCount(MappingInfo& mapping);
+    void setRecordCount(MappingInfo& mapping, size_t count);
+    size_t getCapacity(MappingInfo& mapping);
+    bool ensureCapacityForInsert(MappingInfo& mapping);
+};
@@ -0,0 +1,33 @@
+/*
+File: TrackedRecord.h
+Description: Defines the TrackedRecord template structure used
+             to manage objects with associated record state and
+             slot index. Supports tracking of CLEAN, NEW_RECORD,
+             and MODIFIED states for persistence and synchronization.
+Author: Trenser
+Created: 10-June-2026
+*/
+
+#pragma once
+#include "RecordState.h"
+
+static const size_t INVALID_SLOT = static_cast<size_t>(-1);
+
+template<typename T>
+struct TrackedRecord
+{
+    T* data;
+    RecordState state;
+    size_t slotIndex;
+    TrackedRecord()
+        : data(nullptr),
+        state(RecordState::CLEAN),
+        slotIndex(INVALID_SLOT) {}
+    TrackedRecord(
+        T* object,
+        RecordState recordState,
+        size_t slot)
+        : data(object),
+        state(recordState),
+        slotIndex(slot) {}
+};