with_sl.h

 
 
#pragma once
 
#include <concepts>
#include "source_location.h"
#include "hashes.h"
 
#if !defined(__cpp_concepts)
#error "This library requires concepts"
#endif
 
#ifdef __INTELLISENSE__
#define EQ_SOURCE_LOCATION = source_location{}
#else
#define EQ_SOURCE_LOCATION = source_location::current()
#endif
 
namespace ghassanpl
{
 
    
    template <typename T>
    struct with_sl
    {
        T Object;
        source_location Location;
 
        template <typename U>
        requires (!std::same_as<std::remove_cvref_t<U>, with_sl<T>>)
        with_sl(U&& u, source_location loc EQ_SOURCE_LOCATION)
            : Object(std::forward<U>(u)), Location(std::move(loc))
        {
        }
 
        with_sl(with_sl const& other) noexcept = default;
        with_sl(with_sl&& other) noexcept = default;
        with_sl& operator=(with_sl const& other) noexcept = default;
        with_sl& operator=(with_sl&& other) noexcept = default;
    };
 
    template <typename T, typename HASH_FUNC = crc64_hasher>
    struct with_slh
    {
        using hash_func = HASH_FUNC;
        using hash_type = decltype(HASH_FUNC{}(source_location{}));
        
        T Object;
        hash_type LocationHash;
 
        template <typename U>
        requires (!std::same_as<std::remove_cvref_t<U>, with_slh<T>>)
#ifdef __INTELLISENSE__
        with_slh(U&& t, hash_type loc = {})
#else
        with_slh(U&& t, hash_type loc = HASH_FUNC{}(source_location::current()))
#endif
            : Object(std::forward<U>(t)), LocationHash(loc)
        {
        }
 
        with_slh(with_slh const& other) noexcept = default;
        with_slh(with_slh&& other) noexcept = default;
        with_slh& operator=(with_slh const& other) noexcept = default;
        with_slh& operator=(with_slh&& other) noexcept = default;
    };
 
}