RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-29 12:17:36 +00:00
Code Issues Activity Actions

AK: Rename GenericTraits to DefaultTraits

Browse source 
This feels like a more fitting name for something that provides the
default values for Traits.
This commit is contained in:
Tim Schumacher 2023-11-08 20:29:12 +01:00 • committed by Tim Flynn
parent ac23ab42b3
commit a2f60911fe
101 changed files with 154 additions and 154 deletions
Download patch file Download diff file Expand all files Collapse all files

2
AK/ByteBuffer.h
View file

@ -341,7 +341,7 @@ private:
}
template<>
struct Traits<ByteBuffer> : public GenericTraits<ByteBuffer> {
struct Traits<ByteBuffer> : public DefaultTraits<ByteBuffer> {
static unsigned hash(ByteBuffer const& byte_buffer)
{
return Traits<ReadonlyBytes>::hash(byte_buffer.span());

2
AK/DeprecatedFlyString.h
View file

@ -95,7 +95,7 @@ private:
};
template<>
struct Traits<DeprecatedFlyString> : public GenericTraits<DeprecatedFlyString> {
struct Traits<DeprecatedFlyString> : public DefaultTraits<DeprecatedFlyString> {
static unsigned hash(DeprecatedFlyString const& s) { return s.hash(); }
};

2
AK/DeprecatedString.h
View file

@ -308,7 +308,7 @@ private:
};
template<>
struct Traits<DeprecatedString> : public GenericTraits<DeprecatedString> {
struct Traits<DeprecatedString> : public DefaultTraits<DeprecatedString> {
static unsigned hash(DeprecatedString const& s) { return s.impl() ? s.impl()->hash() : 0; }
};

2
AK/DisjointChunks.h
View file

@ -449,7 +449,7 @@ private:
};
template<typename T>
struct Traits<DisjointSpans<T>> : public GenericTraits<DisjointSpans<T>> {
struct Traits<DisjointSpans<T>> : public DefaultTraits<DisjointSpans<T>> {
static unsigned hash(DisjointSpans<T> const& span)
{
unsigned hash = 0;

2
AK/DistinctNumeric.h
View file

@ -326,7 +326,7 @@ struct Formatter<DistinctNumeric<T, X, Opts...>> : Formatter<T> {
constexpr bool operator==(DN n, E e) { return n.value() == to_underlying(e); }
template<typename T, typename X, typename... Opts>
struct Traits<AK::DistinctNumeric<T, X, Opts...>> : public GenericTraits<AK::DistinctNumeric<T, X, Opts...>> {
struct Traits<AK::DistinctNumeric<T, X, Opts...>> : public DefaultTraits<AK::DistinctNumeric<T, X, Opts...>> {
static constexpr bool is_trivial() { return true; }
static constexpr auto hash(DistinctNumeric<T, X, Opts...> const& d) { return Traits<T>::hash(d.value()); }
};

8
AK/Endian.h
View file

@ -121,22 +121,22 @@ requires(HasFormatter<T>) struct Formatter<BigEndian<T>> : Formatter<T> {
};
template<typename T>
struct Traits<LittleEndian<T>> : public GenericTraits<LittleEndian<T>> {
struct Traits<LittleEndian<T>> : public DefaultTraits<LittleEndian<T>> {
static constexpr bool is_trivially_serializable() { return Traits<T>::is_trivially_serializable(); }
};
template<typename T>
struct Traits<LittleEndian<T> const> : public GenericTraits<LittleEndian<T> const> {
struct Traits<LittleEndian<T> const> : public DefaultTraits<LittleEndian<T> const> {
static constexpr bool is_trivially_serializable() { return Traits<T>::is_trivially_serializable(); }
};
template<typename T>
struct Traits<BigEndian<T>> : public GenericTraits<BigEndian<T>> {
struct Traits<BigEndian<T>> : public DefaultTraits<BigEndian<T>> {
static constexpr bool is_trivially_serializable() { return Traits<T>::is_trivially_serializable(); }
};
template<typename T>
struct Traits<BigEndian<T> const> : public GenericTraits<BigEndian<T> const> {
struct Traits<BigEndian<T> const> : public DefaultTraits<BigEndian<T> const> {
static constexpr bool is_trivially_serializable() { return Traits<T>::is_trivially_serializable(); }
};

2
AK/FlyString.h
View file

@ -86,7 +86,7 @@ private:
};
template<>
struct Traits<FlyString> : public GenericTraits<FlyString> {
struct Traits<FlyString> : public DefaultTraits<FlyString> {
static unsigned hash(FlyString const&);
};

2
AK/IPv4Address.h
View file

@ -162,7 +162,7 @@ private:
static_assert(sizeof(IPv4Address) == 4);
template<>
struct Traits<IPv4Address> : public GenericTraits<IPv4Address> {
struct Traits<IPv4Address> : public DefaultTraits<IPv4Address> {
static unsigned hash(IPv4Address const& address) { return secure_sip_hash(static_cast<u64>(address.to_u32())); }
};

2
AK/IPv6Address.h
View file

@ -269,7 +269,7 @@ private:
static_assert(sizeof(IPv6Address) == 16);
template<>
struct Traits<IPv6Address> : public GenericTraits<IPv6Address> {
struct Traits<IPv6Address> : public DefaultTraits<IPv6Address> {
// SipHash-4-8 is considered conservatively secure, even if not cryptographically secure.
static unsigned hash(IPv6Address const& address) { return sip_hash_bytes<4, 8>({ &address.to_in6_addr_t(), sizeof(address.to_in6_addr_t()) }); }
};

2
AK/MACAddress.h
View file

@ -111,7 +111,7 @@ static_assert(sizeof(MACAddress) == 6u);
namespace AK {
template<>
struct Traits<MACAddress> : public GenericTraits<MACAddress> {
struct Traits<MACAddress> : public DefaultTraits<MACAddress> {
static unsigned hash(MACAddress const& address) { return string_hash((char const*)&address, sizeof(address)); }
};

2
AK/NonnullOwnPtr.h
View file

@ -183,7 +183,7 @@ inline ErrorOr<NonnullOwnPtr<T>> try_make(Args&&... args)
}
template<typename T>
struct Traits<NonnullOwnPtr<T>> : public GenericTraits<NonnullOwnPtr<T>> {
struct Traits<NonnullOwnPtr<T>> : public DefaultTraits<NonnullOwnPtr<T>> {
using PeekType = T*;
using ConstPeekType = T const*;
static unsigned hash(NonnullOwnPtr<T> const& p) { return ptr_hash(p.ptr()); }

2
AK/NonnullRefPtr.h
View file

@ -285,7 +285,7 @@ inline NonnullRefPtr<T> make_ref_counted(Args&&... args)
}
template<typename T>
struct Traits<NonnullRefPtr<T>> : public GenericTraits<NonnullRefPtr<T>> {
struct Traits<NonnullRefPtr<T>> : public DefaultTraits<NonnullRefPtr<T>> {
using PeekType = T*;
using ConstPeekType = T const*;
static unsigned hash(NonnullRefPtr<T> const& p) { return ptr_hash(p.ptr()); }

2
AK/OwnPtr.h
View file

@ -193,7 +193,7 @@ inline OwnPtr<T> adopt_own_if_nonnull(T* object)
}
template<typename T>
struct Traits<OwnPtr<T>> : public GenericTraits<OwnPtr<T>> {
struct Traits<OwnPtr<T>> : public DefaultTraits<OwnPtr<T>> {
using PeekType = T*;
using ConstPeekType = T const*;
static unsigned hash(OwnPtr<T> const& p) { return ptr_hash(p.ptr()); }

2
AK/RefPtr.h
View file

@ -293,7 +293,7 @@ struct Formatter<RefPtr<T>> : Formatter<T const*> {
};
template<typename T>
struct Traits<RefPtr<T>> : public GenericTraits<RefPtr<T>> {
struct Traits<RefPtr<T>> : public DefaultTraits<RefPtr<T>> {
using PeekType = T*;
using ConstPeekType = T const*;
static unsigned hash(RefPtr<T> const& p) { return ptr_hash(p.ptr()); }

2
AK/Span.h
View file

@ -296,7 +296,7 @@ public:
};
template<typename T>
struct Traits<Span<T>> : public GenericTraits<Span<T>> {
struct Traits<Span<T>> : public DefaultTraits<Span<T>> {
static unsigned hash(Span<T> const& span)
{
unsigned hash = 0;

2
AK/String.h
View file

@ -257,7 +257,7 @@ private:
};
template<>
struct Traits<String> : public GenericTraits<String> {
struct Traits<String> : public DefaultTraits<String> {
static unsigned hash(String const&);
};

2
AK/StringView.h
View file

@ -360,7 +360,7 @@ private:
};
template<>
struct Traits<StringView> : public GenericTraits<StringView> {
struct Traits<StringView> : public DefaultTraits<StringView> {
static unsigned hash(StringView s) { return s.hash(); }
};

16
AK/Traits.h
View file

@ -16,7 +16,7 @@
namespace AK {
template<typename T>
struct GenericTraits {
struct DefaultTraits {
using PeekType = T&;
using ConstPeekType = T const&;
static constexpr bool is_trivial() { return false; }
@ -27,11 +27,11 @@ struct GenericTraits {
};
template<typename T>
struct Traits : public GenericTraits<T> {
struct Traits : public DefaultTraits<T> {
};
template<Integral T>
struct Traits<T> : public GenericTraits<T> {
struct Traits<T> : public DefaultTraits<T> {
static constexpr bool is_trivial() { return true; }
static constexpr bool is_trivially_serializable() { return true; }
static unsigned hash(T value)
@ -42,7 +42,7 @@ struct Traits<T> : public GenericTraits<T> {
#ifndef KERNEL
template<FloatingPoint T>
struct Traits<T> : public GenericTraits<T> {
struct Traits<T> : public DefaultTraits<T> {
static constexpr bool is_trivial() { return true; }
static constexpr bool is_trivially_serializable() { return true; }
static unsigned hash(T value)
@ -53,20 +53,20 @@ struct Traits<T> : public GenericTraits<T> {
#endif
template<typename T>
requires(IsPointer<T> && !Detail::IsPointerOfType<char, T>) struct Traits<T> : public GenericTraits<T> {
requires(IsPointer<T> && !Detail::IsPointerOfType<char, T>) struct Traits<T> : public DefaultTraits<T> {
static unsigned hash(T p) { return standard_sip_hash(bit_cast<FlatPtr>(p)); }
static constexpr bool is_trivial() { return true; }
};
template<Enum T>
struct Traits<T> : public GenericTraits<T> {
struct Traits<T> : public DefaultTraits<T> {
static unsigned hash(T value) { return Traits<UnderlyingType<T>>::hash(to_underlying(value)); }
static constexpr bool is_trivial() { return Traits<UnderlyingType<T>>::is_trivial(); }
static constexpr bool is_trivially_serializable() { return Traits<UnderlyingType<T>>::is_trivially_serializable(); }
};
template<typename T>
requires(Detail::IsPointerOfType<char, T>) struct Traits<T> : public GenericTraits<T> {
requires(Detail::IsPointerOfType<char, T>) struct Traits<T> : public DefaultTraits<T> {
static unsigned hash(T const value) { return string_hash(value, strlen(value)); }
static constexpr bool equals(T const a, T const b) { return strcmp(a, b); }
static constexpr bool is_trivial() { return true; }
@ -75,6 +75,6 @@ requires(Detail::IsPointerOfType<char, T>) struct Traits<T> : public GenericTrai
}
#if USING_AK_GLOBALLY
using AK::GenericTraits;
using AK::DefaultTraits;
using AK::Traits;
#endif

2
AK/UFixedBigInt.h
View file

@ -581,7 +581,7 @@ private:
};
template<size_t M>
struct Traits<UFixedBigInt<M>> : public GenericTraits<UFixedBigInt<M>> {
struct Traits<UFixedBigInt<M>> : public DefaultTraits<UFixedBigInt<M>> {
static constexpr bool is_trivially_serializable() { return true; }
static constexpr bool is_trivial() { return true; }
};

2
AK/URL.h
View file

@ -197,7 +197,7 @@ struct Formatter<URL> : Formatter<StringView> {
};
template<>
struct Traits<URL> : public GenericTraits<URL> {
struct Traits<URL> : public DefaultTraits<URL> {
static unsigned hash(URL const& url) { return url.to_deprecated_string().hash(); }
};