Storage.hpp

Див. документацію.

// SPDX-License-Identifier: Proprietary
// Copyright © 2025 Oleksandr Dreval. All rights reserved.
 
#ifndef STORAGE_HPP
#define STORAGE_HPP
 
#include <algorithm>
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
#include "Book.hpp"
#include "SearchUtility.hpp"
 
class Storage {
private:
    // clang-format off
    std::vector<std::unique_ptr<Book>> m_books;  
    struct StringHash {
        using is_transparent = void;
        size_t operator()(std::string_view str) const {
            return std::hash<std::string_view> {}(str);
        }
    };
    std::unordered_map<std::string, size_t, StringHash, std::equal_to<>>
        m_bookIndex;  
    // clang-format on
 
    void updateBookIds() noexcept;
 
    bool processBookJson(const nlohmann::json& bookJson);
 
public:
    Storage() noexcept;
 
    ~Storage();
 
    bool addBook(std::unique_ptr<Book> book);
 
    void removeBook(std::string_view title);
 
    Book* findBook(std::string_view title) const;
 
    const Book* findBookIndexed(std::string_view title) const;
 
    bool saveToFile(const std::string& filename) const;
 
    bool loadFromFile(const std::string& filename);
 
    const std::vector<std::unique_ptr<Book>>& getBooks() const noexcept { return m_books; }
 
    bool loadBooksFromJson(const std::string& filename);
 
    void setBestBookForAuthor(const std::string& authorName, const std::string& bookTitle) const;
 
    template<typename Comparator>
    void mergeSortBooks(Comparator comp) {
        if(m_books.empty()) {
            return;
        }
 
        size_t n = m_books.size();
        std::vector<std::unique_ptr<Book>> workArray(n);
 
        for(size_t size = 1; size < n; size *= 2) {
            for(size_t leftStart = 0; leftStart < n; leftStart += 2 * size) {
                mergeSubarrays(leftStart, size, n, workArray, comp);
            }
            m_books.swap(workArray);
        }
 
        updateBookIds();
    }
 
    void sortByTitle();
 
    void sortByNumPages();
 
    void sortByYearPublished();
 
private:
    template<typename Comparator>
    void mergeSortHelper(
        std::vector<std::unique_ptr<Book>>& books,
        size_t left,
        size_t right,
        Comparator comp);
 
    template<typename Comparator>
    void merge(
        std::vector<std::unique_ptr<Book>>& books,
        size_t left,
        size_t mid,
        size_t right,
        Comparator comp) const;
 
    template<typename Comparator>
    void mergeSubarrays(
        size_t leftStart,
        size_t size,
        size_t n,
        std::vector<std::unique_ptr<Book>>& workArray,
        Comparator comp);
};
 
template<typename Comparator>
void Storage::mergeSortHelper(
    std::vector<std::unique_ptr<Book>>& books,
    size_t left,
    size_t right,
    Comparator comp) {
    if(left >= right) {
        return;
    }
 
    size_t mid = std::midpoint(left, right);
    mergeSortHelper(books, left, mid, comp);
    mergeSortHelper(books, mid + 1, right, comp);
    merge(books, left, mid, right, comp);
}
 
template<typename Comparator>
void Storage::merge(
    std::vector<std::unique_ptr<Book>>& books,
    size_t left,
    size_t mid,
    size_t right,
    Comparator comp) const {
    size_t n1 = mid - left + 1;
    size_t n2 = right - mid;
 
    std::vector<std::unique_ptr<Book>> L(n1);
    std::vector<std::unique_ptr<Book>> R(n2);
 
    for(size_t i = 0; i < n1; i++) {
        L[i] = std::move(books[left + i]);
    }
    for(size_t j = 0; j < n2; j++) {
        R[j] = std::move(books[mid + 1 + j]);
    }
 
    size_t i = 0;
    size_t j = 0;
    size_t k = left;
 
    while(i < n1 && j < n2) {
        if(comp(*L[i], *R[j])) {
            books[k] = std::move(L[i]);
            i++;
        } else {
            books[k] = std::move(R[j]);
            j++;
        }
        k++;
    }
 
    while(i < n1) {
        books[k] = std::move(L[i]);
        i++;
        k++;
    }
 
    while(j < n2) {
        books[k] = std::move(R[j]);
        j++;
        k++;
    }
}
 
template<typename Comparator>
void Storage::mergeSubarrays(
    size_t leftStart,
    size_t size,
    size_t n,
    std::vector<std::unique_ptr<Book>>& workArray,
    Comparator comp) {
    size_t mid = std::min(leftStart + size, n);
    size_t rightEnd = std::min(leftStart + 2 * size, n);
 
    size_t i = leftStart;
    size_t j = mid;
    size_t k = leftStart;
 
    while(i < mid && j < rightEnd) {
        if(comp(m_books[i], m_books[j])) {
            workArray[k] = std::move(m_books[i]);
            k++;
            i++;
        } else {
            workArray[k] = std::move(m_books[j]);
            k++;
            j++;
        }
    }
 
    while(i < mid) {
        workArray[k] = std::move(m_books[i]);
        k++;
        i++;
    }
 
    while(j < rightEnd) {
        workArray[k] = std::move(m_books[j]);
        k++;
        j++;
    }
}
 
#endif  // STORAGE_HPP