clang-format: re-format for clang-18
clang-format-18 isn't compatible with the clang-format-17 output, so we
need to reformat the code with the latest version. The way clang-18
handles lambda formatting also changed, so we have made changes to the
organization default style format to better handle lambda formatting.
See I5e08687e696dd240402a2780158664b7113def0e for updated style.
See Iea0776aaa7edd483fa395e23de25ebf5a6288f71 for clang-18 enablement.
Change-Id: I4635e7b93b66ada3ab5390a21cf465919059fbc1
Signed-off-by: Patrick Williams <patrick@stwcx.xyz>
diff --git a/.clang-format b/.clang-format
index d43e884..28e3328 100644
--- a/.clang-format
+++ b/.clang-format
@@ -87,7 +87,7 @@
IndentWrappedFunctionNames: true
InsertNewlineAtEOF: true
KeepEmptyLinesAtTheStartOfBlocks: false
-LambdaBodyIndentation: OuterScope
+LambdaBodyIndentation: Signature
LineEnding: LF
MacroBlockBegin: ''
MacroBlockEnd: ''
@@ -98,13 +98,14 @@
ObjCSpaceBeforeProtocolList: true
PackConstructorInitializers: BinPack
PenaltyBreakAssignment: 25
-PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakBeforeFirstCallParameter: 50
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
-PenaltyIndentedWhitespace: 0
+PenaltyIndentedWhitespace: 1
PointerAlignment: Left
QualifierAlignment: Left
ReferenceAlignment: Left
diff --git a/include-fd/stdplus/fd/intf.hpp b/include-fd/stdplus/fd/intf.hpp
index 293e514..70ff828 100644
--- a/include-fd/stdplus/fd/intf.hpp
+++ b/include-fd/stdplus/fd/intf.hpp
@@ -148,9 +148,9 @@
virtual FileFlags fcntlGetfl() const = 0;
protected:
- virtual std::span<std::byte> mmap(std::span<std::byte> window,
- ProtFlags prot, MMapFlags flags,
- off_t offset) = 0;
+ virtual std::span<std::byte>
+ mmap(std::span<std::byte> window, ProtFlags prot, MMapFlags flags,
+ off_t offset) = 0;
virtual void munmap(std::span<std::byte> window) = 0;
friend class MMap;
};
diff --git a/include-fd/stdplus/fd/mmap.hpp b/include-fd/stdplus/fd/mmap.hpp
index 2250ac0..f41f562 100644
--- a/include-fd/stdplus/fd/mmap.hpp
+++ b/include-fd/stdplus/fd/mmap.hpp
@@ -16,10 +16,10 @@
public:
inline MMap(Fd& fd, size_t window_size, ProtFlags prot, MMapFlags flags,
off_t offset) :
- MMap(
- fd,
- std::span<std::byte>{static_cast<std::byte*>(nullptr), window_size},
- prot, flags, offset)
+ MMap(fd,
+ std::span<std::byte>{static_cast<std::byte*>(nullptr),
+ window_size},
+ prot, flags, offset)
{}
MMap(Fd& fd, std::span<std::byte> window, ProtFlags prot, MMapFlags flags,
off_t offset);
diff --git a/include-fd/stdplus/fd/ops.hpp b/include-fd/stdplus/fd/ops.hpp
index 20395ab..aa89217 100644
--- a/include-fd/stdplus/fd/ops.hpp
+++ b/include-fd/stdplus/fd/ops.hpp
@@ -32,9 +32,8 @@
RecvFlags flags);
std::span<const std::byte> writeAligned(Fd& fd, size_t align,
std::span<const std::byte> data);
-std::span<const std::byte> sendAligned(Fd& fd, size_t align,
- std::span<const std::byte> data,
- SendFlags flags);
+std::span<const std::byte> sendAligned(
+ Fd& fd, size_t align, std::span<const std::byte> data, SendFlags flags);
void verifyExact(size_t expected, size_t actual);
diff --git a/include/stdplus/concepts.hpp b/include/stdplus/concepts.hpp
index 374880c..a649dde 100644
--- a/include/stdplus/concepts.hpp
+++ b/include/stdplus/concepts.hpp
@@ -6,21 +6,14 @@
{
template <typename T, typename U>
-concept WeaklyEqualityComparableWith = requires(
- const std::remove_reference_t<T>& t, const std::remove_reference_t<U>& u) {
- {
- t == u
- } -> std::convertible_to<bool>;
- {
- t != u
- } -> std::convertible_to<bool>;
- {
- u == t
- } -> std::convertible_to<bool>;
- {
- u != t
- } -> std::convertible_to<bool>;
- };
+concept WeaklyEqualityComparableWith =
+ requires(const std::remove_reference_t<T>& t,
+ const std::remove_reference_t<U>& u) {
+ { t == u } -> std::convertible_to<bool>;
+ { t != u } -> std::convertible_to<bool>;
+ { u == t } -> std::convertible_to<bool>;
+ { u != t } -> std::convertible_to<bool>;
+ };
template <typename T>
concept TriviallyCopyable = std::is_trivially_copyable_v<T>;
diff --git a/include/stdplus/exception.hpp b/include/stdplus/exception.hpp
index f2d40f2..f41c8f5 100644
--- a/include/stdplus/exception.hpp
+++ b/include/stdplus/exception.hpp
@@ -33,26 +33,26 @@
{
return
[f = std::move(f), file, line, func](auto&&... args) mutable noexcept {
- try
- {
- return f(std::forward<decltype(args)>(args)...);
- }
- catch (const std::exception& e)
- {
- stdplus::print(stderr, "Ignoring({}:{} {}): {}\n", file, line, func,
- e.what());
- }
- catch (...)
- {
- stdplus::print(stderr, "Ignoring({}:{} {}): Invalid Error\n", file,
- line, func);
- }
- using Ret = std::invoke_result_t<decltype(f), decltype(args)...>;
- if constexpr (!std::is_same_v<void, Ret>)
- {
- return Ret();
- }
- };
+ try
+ {
+ return f(std::forward<decltype(args)>(args)...);
+ }
+ catch (const std::exception& e)
+ {
+ stdplus::print(stderr, "Ignoring({}:{} {}): {}\n", file, line,
+ func, e.what());
+ }
+ catch (...)
+ {
+ stdplus::print(stderr, "Ignoring({}:{} {}): Invalid Error\n",
+ file, line, func);
+ }
+ using Ret = std::invoke_result_t<decltype(f), decltype(args)...>;
+ if constexpr (!std::is_same_v<void, Ret>)
+ {
+ return Ret();
+ }
+ };
}
template <typename F>
diff --git a/include/stdplus/function_view.hpp b/include/stdplus/function_view.hpp
index 21d0c81..ab988a4 100644
--- a/include/stdplus/function_view.hpp
+++ b/include/stdplus/function_view.hpp
@@ -62,8 +62,8 @@
static_assert(sizeof(fun) == sizeof(memfun));
void* obj;
- inline function_view_base() : fun(nullptr), obj(nullptr){};
- inline function_view_base(std::nullptr_t) : function_view_base(){};
+ inline function_view_base() : fun(nullptr), obj(nullptr) {};
+ inline function_view_base(std::nullptr_t) : function_view_base() {};
template <bool Nx2>
constexpr function_view_base(R (*f)(Args...) noexcept(Nx2)) noexcept :
@@ -74,8 +74,8 @@
requires(!C && std::same_as<std::invoke_result_t<F, Args...>, R>)
inline function_view_base(F& f) noexcept :
memfun([](void* v, Args... args) {
- return (*reinterpret_cast<F*>(v))(std::forward<Args>(args)...);
- }),
+ return (*reinterpret_cast<F*>(v))(std::forward<Args>(args)...);
+ }),
obj(std::addressof(f))
{}
@@ -83,8 +83,9 @@
requires std::same_as<std::invoke_result_t<F, Args...>, R>
inline function_view_base(const F& f) noexcept :
memfun([](void* v, Args... args) {
- return (*reinterpret_cast<const F*>(v))(std::forward<Args>(args)...);
- }),
+ return (*reinterpret_cast<const F*>(v))(
+ std::forward<Args>(args)...);
+ }),
obj(const_cast<F*>(std::addressof(f)))
{}
@@ -184,7 +185,8 @@
-> function_view<R(Args...) const noexcept(Nx)>;
template <typename F>
-function_view(F) -> function_view<
- typename detail::FViewGuide<decltype(&F::operator())>::type>;
+function_view(F)
+ -> function_view<
+ typename detail::FViewGuide<decltype(&F::operator())>::type>;
} // namespace stdplus
diff --git a/include/stdplus/handle/copyable.hpp b/include/stdplus/handle/copyable.hpp
index 3efa90b..14befd7 100644
--- a/include/stdplus/handle/copyable.hpp
+++ b/include/stdplus/handle/copyable.hpp
@@ -29,18 +29,21 @@
* @param[in] maybeV - Optional object being managed
*/
template <typename... Vs>
- constexpr explicit HandleF(const std::optional<T>& maybeV, Vs&&... vs) noexcept(
- noexcept(MHandleF(std::nullopt, std::declval<Vs>()...)) && noexcept(
- std::declval<HandleF>().reset(
- std::declval<const std::optional<T>&>()))) :
+ constexpr explicit HandleF(
+ const std::optional<T>& maybeV,
+ Vs&&... vs) noexcept(noexcept(MHandleF(std::nullopt,
+ std::declval<Vs>()...)) &&
+ noexcept(std::declval<HandleF>().reset(
+ std::declval<
+ const std::optional<T>&>()))) :
MHandleF(std::nullopt, std::forward<Vs>(vs)...)
{
reset(maybeV);
}
template <typename... Vs>
constexpr explicit HandleF(const T& maybeV, Vs&&... vs) noexcept(
- noexcept(MHandleF(std::nullopt, std::declval<Vs>()...)) && noexcept(
- std::declval<HandleF>().reset(std::declval<const T&>()))) :
+ noexcept(MHandleF(std::nullopt, std::declval<Vs>()...)) &&
+ noexcept(std::declval<HandleF>().reset(std::declval<const T&>()))) :
MHandleF(std::nullopt, std::forward<Vs>(vs)...)
{
reset(maybeV);
@@ -65,13 +68,11 @@
MHandleF(std::move(maybeV), std::forward<Vs>(vs)...)
{}
- constexpr HandleF(const HandleF& other) noexcept(noexcept(MHandleF(
- std::nullopt,
- std::declval<const std::tuple<
- As...>&>())) && noexcept(std::declval<HandleF>()
- .reset(std::declval<
- const std::optional<
- T>&>()))) :
+ constexpr HandleF(const HandleF& other) noexcept(
+ noexcept(MHandleF(std::nullopt,
+ std::declval<const std::tuple<As...>&>())) &&
+ noexcept(std::declval<HandleF>().reset(
+ std::declval<const std::optional<T>&>()))) :
MHandleF(std::nullopt, other.as)
{
reset(other.maybe_value());
@@ -84,9 +85,9 @@
constexpr HandleF& operator=(const HandleF& other) noexcept(
noexcept(std::declval<HandleF>().reset()) &&
- std::is_nothrow_copy_constructible_v<std::tuple<As...>>&& noexcept(
- std::declval<HandleF>().reset(
- std::declval<const std::optional<T>&>())))
+ std::is_nothrow_copy_constructible_v<std::tuple<As...>> &&
+ noexcept(std::declval<HandleF>().reset(
+ std::declval<const std::optional<T>&>())))
{
if (this != &other)
{
@@ -106,9 +107,9 @@
using MHandleF::reset;
constexpr void reset(const std::optional<T>& maybeV) noexcept(
- ref_noexcept&& noexcept(std::declval<HandleF>().reset(
- std::declval<T>())) && noexcept(std::declval<HandleF>()
- .reset()))
+ ref_noexcept &&
+ noexcept(std::declval<HandleF>().reset(std::declval<T>())) &&
+ noexcept(std::declval<HandleF>().reset()))
{
if (maybeV)
{
@@ -119,8 +120,9 @@
reset();
}
}
- constexpr void reset(const T& maybeV) noexcept(ref_noexcept&& noexcept(
- std::declval<HandleF>().reset(std::declval<T>())))
+ constexpr void reset(const T& maybeV) noexcept(
+ ref_noexcept &&
+ noexcept(std::declval<HandleF>().reset(std::declval<T>())))
{
reset(doRef(maybeV, std::index_sequence_for<As...>()));
}
diff --git a/include/stdplus/handle/managed.hpp b/include/stdplus/handle/managed.hpp
index d0a0ee5..04e0deb 100644
--- a/include/stdplus/handle/managed.hpp
+++ b/include/stdplus/handle/managed.hpp
@@ -44,18 +44,20 @@
* @param[in] maybeV - Maybe the object being managed
*/
template <typename... Vs>
- constexpr explicit HandleF(std::optional<T>&& maybeV, Vs&&... vs) noexcept(
- std::is_nothrow_move_constructible_v<std::optional<T>>&& noexcept(
- std::tuple<As...>(std::declval<Vs>()...))) :
- as(std::forward<Vs>(vs)...),
- maybeT(std::move(maybeV))
+ constexpr explicit HandleF(
+ std::optional<T>&& maybeV,
+ Vs&&... vs) noexcept(std::
+ is_nothrow_move_constructible_v<
+ std::optional<T>> &&
+ noexcept(std::tuple<As...>(
+ std::declval<Vs>()...))) :
+ as(std::forward<Vs>(vs)...), maybeT(std::move(maybeV))
{}
template <typename... Vs>
constexpr explicit HandleF(T&& maybeV, Vs&&... vs) noexcept(
- std::is_nothrow_move_constructible_v<std::optional<T>>&& noexcept(
- std::tuple<As...>(std::declval<Vs>()...))) :
- as(std::forward<Vs>(vs)...),
- maybeT(std::move(maybeV))
+ std::is_nothrow_move_constructible_v<std::optional<T>> &&
+ noexcept(std::tuple<As...>(std::declval<Vs>()...))) :
+ as(std::forward<Vs>(vs)...), maybeT(std::move(maybeV))
{}
HandleF(const HandleF& other) = delete;
@@ -64,16 +66,15 @@
constexpr HandleF(HandleF&& other) noexcept(
std::is_nothrow_move_constructible_v<std::tuple<As...>> &&
std::is_nothrow_move_constructible_v<std::optional<T>>) :
- as(std::move(other.as)),
- maybeT(std::move(other.maybeT))
+ as(std::move(other.as)), maybeT(std::move(other.maybeT))
{
other.maybeT = std::nullopt;
}
constexpr HandleF& operator=(HandleF&& other) noexcept(
- std::is_nothrow_move_assignable_v<std::tuple<As...>>&& noexcept(
- std::declval<HandleF>().reset(
- std::declval<std::optional<T>>())))
+ std::is_nothrow_move_assignable_v<std::tuple<As...>> &&
+ noexcept(std::declval<HandleF>().reset(
+ std::declval<std::optional<T>>())))
{
if (this != &other)
{
@@ -86,8 +87,8 @@
virtual ~HandleF() noexcept(
std::is_nothrow_destructible_v<std::tuple<As...>> &&
- std::is_nothrow_destructible_v<std::optional<T>>&& noexcept(
- std::declval<HandleF>().reset()))
+ std::is_nothrow_destructible_v<std::optional<T>> &&
+ noexcept(std::declval<HandleF>().reset()))
{
reset();
}
diff --git a/include/stdplus/hash.hpp b/include/stdplus/hash.hpp
index 5c521fa..cb93dcd 100644
--- a/include/stdplus/hash.hpp
+++ b/include/stdplus/hash.hpp
@@ -35,8 +35,8 @@
template <typename T, typename... Ts>
constexpr std::size_t
hashMultiS(std::size_t seed, const T& t, const Ts&... ts) noexcept(
- (noexcept(hashMultiS(0, std::declval<T>())) &&
- ...&& noexcept(hashMultiS(0, std::declval<Ts>()))))
+ (noexcept(hashMultiS(0, std::declval<T>())) && ... &&
+ noexcept(hashMultiS(0, std::declval<Ts>()))))
{
return hashMultiS(hashMultiS(seed, t), ts...);
}
@@ -57,8 +57,8 @@
template <typename T, typename... Ts>
constexpr std::size_t hashMulti(const T& t, const Ts&... ts) noexcept(
- noexcept(hashMulti(std::declval<T>())) && noexcept(
- detail::hashMultiS(0, std::declval<Ts>()...)))
+ noexcept(hashMulti(std::declval<T>())) &&
+ noexcept(detail::hashMultiS(0, std::declval<Ts>()...)))
{
return detail::hashMultiS(hashMulti(t), ts...);
}
diff --git a/include/stdplus/net/addr/ip.hpp b/include/stdplus/net/addr/ip.hpp
index 715b9b4..dae3c15 100644
--- a/include/stdplus/net/addr/ip.hpp
+++ b/include/stdplus/net/addr/ip.hpp
@@ -387,8 +387,8 @@
std::same_as<Addr, InAnyAddr>;
template <typename Addr>
-concept InAddrLike = InAddr<Addr> || std::same_as<Addr, in_addr> ||
- std::same_as<Addr, in6_addr>;
+concept InAddrLike =
+ InAddr<Addr> || std::same_as<Addr, in_addr> || std::same_as<Addr, in6_addr>;
struct InAnyAddr : detail::InAnyAddrV
{
diff --git a/include/stdplus/net/addr/sock.hpp b/include/stdplus/net/addr/sock.hpp
index 73b4edf..bec91bf 100644
--- a/include/stdplus/net/addr/sock.hpp
+++ b/include/stdplus/net/addr/sock.hpp
@@ -246,9 +246,9 @@
throw std::invalid_argument("SockUAddr fromBuf");
}
const auto& sun = reinterpret_cast<const sockaddr_un&>(buf);
- return SockUAddr{
- detail::SockAddrUnsafe(),
- {sun.sun_path, buf.len - offsetof(sockaddr_un, sun_path)}};
+ return SockUAddr{detail::SockAddrUnsafe(),
+ {sun.sun_path,
+ buf.len - offsetof(sockaddr_un, sun_path)}};
}
constexpr bool operator==(const SockUAddr& rhs) const noexcept
@@ -461,8 +461,8 @@
using FromAddr = ToStr<In4Addr>;
using FromDec = IntToStr<10, std::uint16_t>;
// Addr + sep + port chars
- static inline constexpr std::size_t buf_size = FromAddr::buf_size + 1 +
- FromDec::buf_size;
+ static inline constexpr std::size_t buf_size =
+ FromAddr::buf_size + 1 + FromDec::buf_size;
template <typename CharT>
constexpr CharT* operator()(CharT* buf, Sock4Addr v) const noexcept
@@ -501,8 +501,8 @@
using FromAddr = ToStr<In6Addr>;
using FromDec = IntToStr<10, std::uint16_t>;
// Addr + sep + port chars
- static inline constexpr std::size_t buf_size = FromAddr::buf_size + 1 +
- FromDec::buf_size;
+ static inline constexpr std::size_t buf_size =
+ FromAddr::buf_size + 1 + FromDec::buf_size;
template <typename CharT>
constexpr CharT* operator()(CharT* buf, Sock6Addr v) const noexcept
@@ -538,8 +538,8 @@
struct ToStr<SockUAddr>
{
using type = SockUAddr;
- static inline constexpr std::size_t buf_size = detail::upfx.size() +
- SockUAddr::maxLen;
+ static inline constexpr std::size_t buf_size =
+ detail::upfx.size() + SockUAddr::maxLen;
template <typename CharT>
constexpr CharT* operator()(CharT* buf, const SockUAddr& v) const noexcept
diff --git a/include/stdplus/net/addr/subnet.hpp b/include/stdplus/net/addr/subnet.hpp
index cbdce20..a28b3f6 100644
--- a/include/stdplus/net/addr/subnet.hpp
+++ b/include/stdplus/net/addr/subnet.hpp
@@ -19,6 +19,7 @@
addr32Mask(std::ptrdiff_t pfx) noexcept
{
// NOLINTNEXTLINE(clang-analyzer-core.UndefinedBinaryOperatorResult)
+ // NOLINTNEXTLINE(clang-analyzer-core.BitwiseShift)
auto v = ~uint32_t{0} << (32 - pfx);
// Positive prefix check + mask to handle UB when the left shift becomes
// more than 31 bits
diff --git a/include/stdplus/pinned.hpp b/include/stdplus/pinned.hpp
index dc2a17a..99deec1 100644
--- a/include/stdplus/pinned.hpp
+++ b/include/stdplus/pinned.hpp
@@ -47,8 +47,7 @@
template <typename... Args>
constexpr Pinned(Args&&... args) noexcept(
- noexcept(CT(std::declval<Args>()...))) :
- CT(std::forward<Args>(args)...)
+ noexcept(CT(std::declval<Args>()...))) : CT(std::forward<Args>(args)...)
{}
template <typename Arg>
diff --git a/include/stdplus/str/buf.hpp b/include/stdplus/str/buf.hpp
index 7aba316..472dbb8 100644
--- a/include/stdplus/str/buf.hpp
+++ b/include/stdplus/str/buf.hpp
@@ -65,8 +65,8 @@
static_assert(sizeof(std::declval<Store>().inl) >=
sizeof(std::declval<Store>().dyn));
- static inline constexpr auto dyn_mask = std::size_t{1}
- << ((sizeof(std::size_t) << 3) - 1);
+ static inline constexpr auto dyn_mask =
+ std::size_t{1} << ((sizeof(std::size_t) << 3) - 1);
static inline constexpr auto inl_mask =
decltype(Store::Inl::len){1} << ((sizeof(Store::Inl::len) << 3) - 1);
diff --git a/include/stdplus/variant.hpp b/include/stdplus/variant.hpp
index 57e0897..77c812d 100644
--- a/include/stdplus/variant.hpp
+++ b/include/stdplus/variant.hpp
@@ -24,8 +24,8 @@
typename... Vs>
struct CanVeq<Veq, T, V, Vs...>
{
- static inline constexpr bool value = Veq<T, V>::value ||
- CanVeq<Veq, T, Vs...>::value;
+ static inline constexpr bool value =
+ Veq<T, V>::value || CanVeq<Veq, T, Vs...>::value;
};
template <typename T1, typename T2>
@@ -78,8 +78,8 @@
{
return std::visit(
[&t](const auto& v) {
- return Veq<std::remove_cvref_t<decltype(v)>, T>{}(v, t);
- },
+ return Veq<std::remove_cvref_t<decltype(v)>, T>{}(v, t);
+ },
vs);
}
@@ -93,15 +93,15 @@
}
template <typename... Vs>
-constexpr bool variantEqFuzzy(const std::variant<Vs...>& vs,
- const auto& t) noexcept
+constexpr bool
+ variantEqFuzzy(const std::variant<Vs...>& vs, const auto& t) noexcept
{
return variantEq<detail::VeqFuzzy>(vs, t);
}
template <typename... Vs>
-constexpr bool variantEqStrict(const std::variant<Vs...>& vs,
- const auto& t) noexcept
+constexpr bool
+ variantEqStrict(const std::variant<Vs...>& vs, const auto& t) noexcept
{
return variantEq<detail::VeqStrict>(vs, t);
}
diff --git a/include/stdplus/zstring.hpp b/include/stdplus/zstring.hpp
index a7cd8c6..101cd3b 100644
--- a/include/stdplus/zstring.hpp
+++ b/include/stdplus/zstring.hpp
@@ -38,8 +38,8 @@
#ifndef NDEBUG
template <typename CharT>
-constexpr std::size_t zstring_validate(const CharT* str, std::size_t min,
- std::size_t max)
+constexpr std::size_t
+ zstring_validate(const CharT* str, std::size_t min, std::size_t max)
{
auto ret = zstring_find_term(str, min, max);
if (ret < 0)
@@ -88,8 +88,7 @@
#ifdef NDEBUG
noexcept
#endif
- :
- data_(str)
+ : data_(str)
{
#ifndef NDEBUG
detail::zstring_validate(str, 0, N);
@@ -106,8 +105,7 @@
#ifdef NDEBUG
noexcept
#endif
- :
- data_(str.data())
+ : data_(str.data())
{
#ifndef NDEBUG
detail::zstring_validate(str.data(), str.size(), str.size() + 1);
diff --git a/include/stdplus/zstring_view.hpp b/include/stdplus/zstring_view.hpp
index 490e5e0..4be31c3 100644
--- a/include/stdplus/zstring_view.hpp
+++ b/include/stdplus/zstring_view.hpp
@@ -80,11 +80,9 @@
template <typename T, size_type N>
constexpr basic_zstring_view(T (&str)[N])
#ifdef NDEBUG
- noexcept :
- sv(str)
+ noexcept : sv(str)
#else
- :
- sv(str, detail::zstring_validate(str, 0, N))
+ : sv(str, detail::zstring_validate(str, 0, N))
#endif
{}
template <typename T, std::enable_if_t<std::is_pointer_v<T>, bool> = true>
@@ -95,8 +93,7 @@
bool> = true>
constexpr basic_zstring_view(const T& str)
#ifdef NDEBUG
- noexcept :
- sv(str)
+ noexcept : sv(str)
#else
:
sv(str.data(),
@@ -323,8 +320,8 @@
consteval auto cexprToZsv()
{
constexpr auto& d = cexprStrArr<f, /*nul=*/true>;
- static_assert(detail::zstring_find_term(d.data(), d.size() - 1, d.size()) >=
- 0);
+ static_assert(
+ detail::zstring_find_term(d.data(), d.size() - 1, d.size()) >= 0);
return detail::unsafe_zstring_view(
std::basic_string_view(d.begin(), d.end() - 1));
}
diff --git a/src/fd/atomic.cpp b/src/fd/atomic.cpp
index 5299789..6b7530c 100644
--- a/src/fd/atomic.cpp
+++ b/src/fd/atomic.cpp
@@ -37,8 +37,7 @@
AtomicWriter::AtomicWriter(const std::filesystem::path& filename, int mode,
std::string_view tmpl) :
- filename(filename),
- mode(mode),
+ filename(filename), mode(mode),
tmpname(!tmpl.empty() ? std::string(tmpl) : makeTmpName(filename)),
fd(mktemp(tmpname))
{}
diff --git a/src/fd/impl.cpp b/src/fd/impl.cpp
index c2d5623..3147e64 100644
--- a/src/fd/impl.cpp
+++ b/src/fd/impl.cpp
@@ -46,9 +46,8 @@
::recv(get(), buf.data(), buf.size(), static_cast<int>(flags)));
}
-std::tuple<std::span<std::byte>, std::span<std::byte>>
- FdImpl::recvfrom(std::span<std::byte> buf, RecvFlags flags,
- std::span<std::byte> sockaddr)
+std::tuple<std::span<std::byte>, std::span<std::byte>> FdImpl::recvfrom(
+ std::span<std::byte> buf, RecvFlags flags, std::span<std::byte> sockaddr)
{
socklen_t sockaddrsize = sockaddr.size();
auto ret =
@@ -67,14 +66,14 @@
std::span<const std::byte> FdImpl::send(std::span<const std::byte> data,
SendFlags flags)
{
- return fret(
- data, "send",
- ::send(get(), data.data(), data.size(), static_cast<int>(flags)));
+ return fret(data, "send",
+ ::send(get(), data.data(), data.size(),
+ static_cast<int>(flags)));
}
-std::span<const std::byte> FdImpl::sendto(std::span<const std::byte> data,
- SendFlags flags,
- std::span<const std::byte> sockaddr)
+std::span<const std::byte>
+ FdImpl::sendto(std::span<const std::byte> data, SendFlags flags,
+ std::span<const std::byte> sockaddr)
{
return fret(
data, "sendto",
diff --git a/src/fd/mmap.cpp b/src/fd/mmap.cpp
index 1f5c211..7026aa6 100644
--- a/src/fd/mmap.cpp
+++ b/src/fd/mmap.cpp
@@ -7,8 +7,7 @@
{
MMap::MMap(Fd& fd, std::span<std::byte> window, ProtFlags prot, MMapFlags flags,
- off_t offset) :
- mapping(fd.mmap(window, prot, flags, offset), fd)
+ off_t offset) : mapping(fd.mmap(window, prot, flags, offset), fd)
{}
std::span<std::byte> MMap::get() const
diff --git a/src/fd/ops.cpp b/src/fd/ops.cpp
index ca549f7..c069a5a 100644
--- a/src/fd/ops.cpp
+++ b/src/fd/ops.cpp
@@ -20,8 +20,8 @@
{
while (total < data.size())
{
- auto r = (fd.*fun)(data.subspan(total),
- std::forward<Args>(args)...);
+ auto r =
+ (fd.*fun)(data.subspan(total), std::forward<Args>(args)...);
if (r.size() == 0)
{
throw exception::WouldBlock(
@@ -76,17 +76,17 @@
}
template <typename Fun, typename Byte, typename... Args>
-static std::span<Byte> opAligned(const char* name, Fun&& fun, Fd& fd,
- size_t align, std::span<Byte> data,
- Args&&... args)
+static std::span<Byte>
+ opAligned(const char* name, Fun&& fun, Fd& fd, size_t align,
+ std::span<Byte> data, Args&&... args)
{
std::size_t total = 0;
try
{
do
{
- auto r = (fd.*fun)(data.subspan(total),
- std::forward<Args>(args)...);
+ auto r =
+ (fd.*fun)(data.subspan(total), std::forward<Args>(args)...);
if (total != 0 && r.size() == 0)
{
throw exception::Incomplete(
@@ -124,9 +124,8 @@
return opAligned("writeAligned", &Fd::write, fd, align, data);
}
-std::span<const std::byte> sendAligned(Fd& fd, size_t align,
- std::span<const std::byte> data,
- SendFlags flags)
+std::span<const std::byte> sendAligned(
+ Fd& fd, size_t align, std::span<const std::byte> data, SendFlags flags)
{
return opAligned("sendAligned", &Fd::send, fd, align, data, flags);
}
diff --git a/test/exception.cpp b/test/exception.cpp
index a0d2e54..48e562e 100644
--- a/test/exception.cpp
+++ b/test/exception.cpp
@@ -16,8 +16,9 @@
auto y = std::make_unique<int>(2);
auto z = std::make_unique<int>(3);
EXPECT_EQ(3, ignore([x = std::move(x)](auto&& v) { return *v + *x; })(y));
- EXPECT_EQ(5, ignore([z = std::move(z)](auto v) { return *v + *z; })(
- std::move(y)));
+ EXPECT_EQ(5, ignore([z = std::move(z)](auto v) {
+ return *v + *z;
+ })(std::move(y)));
}
TEST(Exception, IgnoreQuiet)
diff --git a/test/net/addr/ether.cpp b/test/net/addr/ether.cpp
index cf23223..474bd96 100644
--- a/test/net/addr/ether.cpp
+++ b/test/net/addr/ether.cpp
@@ -43,12 +43,12 @@
tsh(EtherAddr{0x01, 0x02, 0x03, 0x04, 0x05, 0x67}));
EXPECT_EQ("00:00:00:00:00:00",
tsh(ether_addr{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}));
- EXPECT_EQ(
- "a 01:02:03:04:05:67 b",
- fmt::format("a {} b", EtherAddr{0x01, 0x02, 0x03, 0x04, 0x05, 0x67}));
- EXPECT_EQ(
- "a 01:02:03:04:05:67 b",
- std::format("a {} b", EtherAddr{0x01, 0x02, 0x03, 0x04, 0x05, 0x67}));
+ EXPECT_EQ("a 01:02:03:04:05:67 b",
+ fmt::format("a {} b",
+ EtherAddr{0x01, 0x02, 0x03, 0x04, 0x05, 0x67}));
+ EXPECT_EQ("a 01:02:03:04:05:67 b",
+ std::format("a {} b",
+ EtherAddr{0x01, 0x02, 0x03, 0x04, 0x05, 0x67}));
}
TEST(FromStr, EtherAddr)