memory.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once

 
#include "shambase/aliases_int.hpp"
#include "shambase/exception.hpp"
#include "sham/format/format.hpp"
#include <array>
#include <memory>
#include <optional>
#include <utility>
#include <vector>
 
namespace shambase {

    template<class T, class AccU8>
    inline void store_u8(AccU8 &acc, u64 idx_write, T a) {
        constexpr u64 szT = sizeof(T);
        u8 *bytes         = (u8 *) &a;
#pragma unroll
        for (u64 i = 0; i < szT; i++) {
            acc[idx_write + i] = bytes[i];
        }
    }

    template<class T, class AccU8>
    inline T load_u8(AccU8 &acc, u64 ptr_load) {
        constexpr u64 szT = sizeof(T);
        T ret;
        u8 *bytes = (u8 *) &ret;
#pragma unroll
        for (u64 i = 0; i < szT; i++) {
            bytes[i] = acc[ptr_load + i];
        }
        return ret;
    }

    template<class T, class TAcc>
    inline void store_conv(TAcc *acc, T a) {
        T *ptr = (T *) acc;
        *ptr   = a;
    }

    template<class T, class TAcc>
    inline T load_conv(TAcc *acc) {
        T *ptr = (T *) acc;
        return *ptr;
    }

    template<class T>
    inline T &get_check_ref(const std::unique_ptr<T> &ptr, SourceLocation loc = SourceLocation()) {
        // Check if the std::unique_ptr holds anything
        if (!bool(ptr)) {
            // Throw a std::runtime_error with a descriptive message
            throw make_except_with_loc<std::runtime_error>("the ptr does not hold anything", loc);
        }
        // Return a reference to the object held by the std::unique_ptr
        return *ptr;
    }

    template<class T>
    inline T &get_check_ref(const std::shared_ptr<T> &ptr, SourceLocation loc = SourceLocation()) {
        // Check if the std::shared_ptr holds anything
        if (!bool(ptr)) {
            // Throw a std::runtime_error with a descriptive message
            throw make_except_with_loc<std::runtime_error>("the ptr does not hold anything", loc);
        }
        // Return a reference to the object held by the std::shared_ptr
        return *ptr;
    }

    template<class T>
    inline const T &get_check_ref(
        const std::optional<T> &ptr, SourceLocation loc = SourceLocation()) {
        if (!bool(ptr)) {
            throw make_except_with_loc<std::runtime_error>("the ptr does not hold anything", loc);
        }
        return *ptr;
    }

    template<class T>
    inline T &get_check_ref(std::optional<T> &ptr, SourceLocation loc = SourceLocation()) {
        if (!bool(ptr)) {
            throw make_except_with_loc<std::runtime_error>("the ptr does not hold anything", loc);
        }
        return *ptr;
    }

    template<class T>
    inline T &get_check_ref(T *ptr, SourceLocation loc = SourceLocation()) {
        if (!ptr) {
            throw make_except_with_loc<std::runtime_error>(
                "Can not get reference to null pointer", loc);
        }
        return *ptr;
    }

    template<class T>
    inline const T &get_check_ref(const T *ptr, SourceLocation loc = SourceLocation()) {
        if (!ptr) {
            throw make_except_with_loc<std::runtime_error>(
                "Can not get reference to null pointer", loc);
        }
        return *ptr;
    }

    template<typename T>
    auto extract_value(std::optional<T> &o, SourceLocation loc = SourceLocation()) -> T {
        if (!bool(o)) {
            throw make_except_with_loc<std::runtime_error>(
                "the value cannot be extracted, as the optional is empty", loc);
        }
        return std::exchange(o, std::nullopt).value();
    }

    template<typename T>
    auto extract_pointer(std::unique_ptr<T> &o, SourceLocation loc = SourceLocation()) -> T {
        if (!bool(o)) {
            throw make_except_with_loc<std::runtime_error>(
                "the value cannot be extracted, as the unique_ptr is empty", loc);
        }
        std::unique_ptr<T> tmp = std::exchange(o, {});
        return T(std::move(*tmp));
    }

    template<int n, class T>
    inline std::array<T, n> convert_to_array(std::vector<T> &in) {
        if (in.size() != n) {
            throw shambase::make_except_with_loc<std::invalid_argument>(sham::format(
                "you've input values with the wrong size, input size = {}, wanted = {}",
                in.size(),
                n));
        }
 
        std::array<T, n> tmp;
 
        for (u32 i = 0; i < n; i++) {
            tmp[i] = in[i];
        }
 
        return tmp;
    }
 
} // namespace shambase