Atmosphere/libraries/libvapours/include/vapours/util/util_parent_of_member.hpp

178 lines
7.8 KiB
C++
Raw Normal View History

/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
2020-02-23 07:05:14 +00:00
#include <vapours/common.hpp>
#include <vapours/assert.hpp>
#include <vapours/util/util_typed_storage.hpp>
namespace ams::util {
namespace impl {
#define AMS_UTIL_OFFSET_OF_STANDARD_COMPLIANT 1
#if AMS_UTIL_OFFSET_OF_STANDARD_COMPLIANT
template<std::ptrdiff_t Offset, typename P, typename M, auto Ptr>
consteval std::strong_ordering TestOffsetForOffsetOfImpl() {
#pragma pack(push, 1)
const union Union {
char c;
struct {
char padding[Offset];
M members[1 + (sizeof(P) / std::max<size_t>(sizeof(M), 1))];
};
P p;
constexpr Union() : c() { /* ... */ }
constexpr ~Union() { /* ... */ }
} U;
#pragma pack(pop)
const M *target = std::addressof(U.p.*Ptr);
const M *guess = std::addressof(U.members[0]);
/* NOTE: target == guess is definitely legal, target < guess is probably legal, definitely legal if Offset <= true offsetof. */
/* <=> may or may not be legal, but it definitely seems to work. Evaluate again, if it breaks. */
return guess <=> target;
//if (guess == target) {
// return std::strong_ordering::equal;
//} else if (guess < target) {
// return std::strong_ordering::less;
//} else {
// return std::strong_ordering::greater;
//}
}
template<std::ptrdiff_t Low, std::ptrdiff_t High, typename P, typename M, auto Ptr>
consteval std::ptrdiff_t OffsetOfImpl() {
static_assert(Low <= High);
constexpr std::ptrdiff_t Guess = (Low + High) / 2;
constexpr auto Order = TestOffsetForOffsetOfImpl<Guess, P, M, Ptr>();
if constexpr (Order == std::strong_ordering::equal) {
return Guess;
} else if constexpr (Order == std::strong_ordering::less) {
return OffsetOfImpl<Guess + 1, High, P, M, Ptr>();
} else {
static_assert(Order == std::strong_ordering::greater);
return OffsetOfImpl<Low, Guess - 1, P, M, Ptr>();
}
}
template<typename P, typename M, auto Ptr>
struct OffsetOfCalculator {
static constexpr const std::ptrdiff_t Value = OffsetOfImpl<0, sizeof(P), P, M, Ptr>();
};
#else
template<typename ParentType, typename MemberType, auto Ptr>
struct OffsetOfCalculator {
private:
static consteval std::ptrdiff_t Calculate() {
const union Union {
ParentType p;
char c;
constexpr Union() : c() { /* ... */ }
constexpr ~Union() { /* ... */ }
} U;
const auto *parent = std::addressof(U.p);
const auto *target = std::addressof(parent->*Ptr);
return static_cast<const uint8_t *>(static_cast<const void *>(target)) - static_cast<const uint8_t *>(static_cast<const void *>(parent));
}
public:
static constexpr const std::ptrdiff_t Value = Calculate();
};
#endif
template<typename T>
struct GetMemberPointerTraits;
template<typename P, typename M>
struct GetMemberPointerTraits<M P::*> {
using Parent = P;
using Member = M;
};
template<auto MemberPtr>
using GetParentType = typename GetMemberPointerTraits<decltype(MemberPtr)>::Parent;
template<auto MemberPtr>
using GetMemberType = typename GetMemberPointerTraits<decltype(MemberPtr)>::Member;
template<auto MemberPtr, typename RealParentType = GetParentType<MemberPtr>> requires (std::derived_from<RealParentType, GetParentType<MemberPtr>> || std::same_as<RealParentType, GetParentType<MemberPtr>>)
struct OffsetOf : public std::integral_constant<std::ptrdiff_t, OffsetOfCalculator<RealParentType, GetMemberType<MemberPtr>, MemberPtr>::Value> {};
}
template<auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
ALWAYS_INLINE RealParentType &GetParentReference(impl::GetMemberType<MemberPtr> *member) {
constexpr std::ptrdiff_t Offset = impl::OffsetOf<MemberPtr, RealParentType>::value;
2020-01-16 07:47:14 +00:00
return *static_cast<RealParentType *>(static_cast<void *>(static_cast<uint8_t *>(static_cast<void *>(member)) - Offset));
}
template<auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
ALWAYS_INLINE RealParentType const &GetParentReference(impl::GetMemberType<MemberPtr> const *member) {
constexpr std::ptrdiff_t Offset = impl::OffsetOf<MemberPtr, RealParentType>::value;
2020-01-16 07:47:14 +00:00
return *static_cast<const RealParentType *>(static_cast<const void *>(static_cast<const uint8_t *>(static_cast<const void *>(member)) - Offset));
}
template<auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
ALWAYS_INLINE RealParentType *GetParentPointer(impl::GetMemberType<MemberPtr> *member) {
return std::addressof(GetParentReference<MemberPtr, RealParentType>(member));
}
template<auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
ALWAYS_INLINE RealParentType const *GetParentPointer(impl::GetMemberType<MemberPtr> const *member) {
return std::addressof(GetParentReference<MemberPtr, RealParentType>(member));
}
2020-01-16 07:47:14 +00:00
template<auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
ALWAYS_INLINE RealParentType &GetParentReference(impl::GetMemberType<MemberPtr> &member) {
2020-01-16 07:47:14 +00:00
return GetParentReference<MemberPtr, RealParentType>(std::addressof(member));
}
template<auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
ALWAYS_INLINE RealParentType const &GetParentReference(impl::GetMemberType<MemberPtr> const &member) {
2020-01-16 07:47:14 +00:00
return GetParentReference<MemberPtr, RealParentType>(std::addressof(member));
}
template<auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
ALWAYS_INLINE RealParentType *GetParentPointer(impl::GetMemberType<MemberPtr> &member) {
2020-01-16 07:47:14 +00:00
return std::addressof(GetParentReference<MemberPtr, RealParentType>(member));
}
template<auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
ALWAYS_INLINE RealParentType const *GetParentPointer(impl::GetMemberType<MemberPtr> const &member) {
2020-01-16 07:47:14 +00:00
return std::addressof(GetParentReference<MemberPtr, RealParentType>(member));
}
/* Defines, for use by other code. */
#define AMS_OFFSETOF(parent, member) (__builtin_offsetof(parent, member))
#define AMS_GET_PARENT_PTR(parent, member, _arg) (::ams::util::GetParentPointer<&parent::member, parent>(_arg))
#define AMS_GET_PARENT_REF(parent, member, _arg) (::ams::util::GetParentReference<&parent::member, parent>(_arg))
}