span: switch to std
There are no longer any external users in the openbmc org which are
not compiled with C++20 and using std::span directly. Migrate all
internal code to use std::span, delete the typedefs, and remove the old
span-lite dependency.
Signed-off-by: Patrick Williams <patrick@stwcx.xyz>
Change-Id: I86bc9c0688c3828f9fe2ce006b273a55fc5fded9
diff --git a/src/stdplus/fd/gmock.hpp b/src/stdplus/fd/gmock.hpp
index 37dc3eb..97a4f01 100644
--- a/src/stdplus/fd/gmock.hpp
+++ b/src/stdplus/fd/gmock.hpp
@@ -10,21 +10,23 @@
class FdMock : public Fd
{
public:
- MOCK_METHOD(span<std::byte>, read, (span<std::byte> buf), (override));
- MOCK_METHOD(span<std::byte>, recv, (span<std::byte> buf, RecvFlags flags),
+ MOCK_METHOD(std::span<std::byte>, read, (std::span<std::byte> buf),
(override));
- MOCK_METHOD(span<const std::byte>, write, (span<const std::byte> data),
- (override));
- MOCK_METHOD(span<const std::byte>, send,
- (span<const std::byte> data, SendFlags flags), (override));
+ MOCK_METHOD(std::span<std::byte>, recv,
+ (std::span<std::byte> buf, RecvFlags flags), (override));
+ MOCK_METHOD(std::span<const std::byte>, write,
+ (std::span<const std::byte> data), (override));
+ MOCK_METHOD(std::span<const std::byte>, send,
+ (std::span<const std::byte> data, SendFlags flags), (override));
MOCK_METHOD(size_t, lseek, (off_t offset, Whence whence), (override));
MOCK_METHOD(void, truncate, (off_t size), (override));
- MOCK_METHOD(void, bind, (span<const std::byte> sockaddr), (override));
+ MOCK_METHOD(void, bind, (std::span<const std::byte> sockaddr), (override));
MOCK_METHOD(void, listen, (int backlog), (override));
- MOCK_METHOD((std::tuple<std::optional<int>, span<std::byte>>), accept,
- (span<std::byte> sockaddr), (override));
+ MOCK_METHOD((std::tuple<std::optional<int>, std::span<std::byte>>), accept,
+ (std::span<std::byte> sockaddr), (override));
MOCK_METHOD(void, setsockopt,
- (SockLevel level, SockOpt optname, span<const std::byte> opt),
+ (SockLevel level, SockOpt optname,
+ std::span<const std::byte> opt),
(override));
MOCK_METHOD(int, ioctl, (unsigned long id, void* data), (override));
MOCK_METHOD(int, constIoctl, (unsigned long id, void* data),
diff --git a/src/stdplus/fd/impl.cpp b/src/stdplus/fd/impl.cpp
index 4335cf5..2d92b72 100644
--- a/src/stdplus/fd/impl.cpp
+++ b/src/stdplus/fd/impl.cpp
@@ -15,7 +15,7 @@
using namespace std::literals::string_view_literals;
-span<std::byte> FdImpl::read(span<std::byte> buf)
+std::span<std::byte> FdImpl::read(std::span<std::byte> buf)
{
ssize_t amt = ::read(get(), buf.data(), buf.size());
if (amt == -1)
@@ -33,7 +33,7 @@
return buf.subspan(0, amt);
}
-span<std::byte> FdImpl::recv(span<std::byte> buf, RecvFlags flags)
+std::span<std::byte> FdImpl::recv(std::span<std::byte> buf, RecvFlags flags)
{
ssize_t amt =
::recv(get(), buf.data(), buf.size(), static_cast<int>(flags));
@@ -52,7 +52,7 @@
return buf.subspan(0, amt);
}
-span<const std::byte> FdImpl::write(span<const std::byte> data)
+std::span<const std::byte> FdImpl::write(std::span<const std::byte> data)
{
ssize_t amt = ::write(get(), data.data(), data.size());
if (amt == -1)
@@ -66,7 +66,8 @@
return data.subspan(0, amt);
}
-span<const std::byte> FdImpl::send(span<const std::byte> data, SendFlags flags)
+std::span<const std::byte> FdImpl::send(std::span<const std::byte> data,
+ SendFlags flags)
{
ssize_t amt =
::send(get(), data.data(), data.size(), static_cast<int>(flags));
@@ -107,7 +108,7 @@
CHECK_ERRNO(::ftruncate(get(), size), fmt::format("ftruncate {}B", size));
}
-void FdImpl::bind(span<const std::byte> sockaddr)
+void FdImpl::bind(std::span<const std::byte> sockaddr)
{
CHECK_ERRNO(
::bind(get(), reinterpret_cast<const struct sockaddr*>(sockaddr.data()),
@@ -120,8 +121,8 @@
CHECK_ERRNO(::listen(get(), backlog), "listen");
}
-std::tuple<std::optional<int>, span<std::byte>>
- FdImpl::accept(span<std::byte> sockaddr)
+std::tuple<std::optional<int>, std::span<std::byte>>
+ FdImpl::accept(std::span<std::byte> sockaddr)
{
socklen_t len = sockaddr.size();
auto fd = ::accept(
@@ -138,7 +139,7 @@
}
void FdImpl::setsockopt(SockLevel level, SockOpt optname,
- span<const std::byte> opt)
+ std::span<const std::byte> opt)
{
CHECK_ERRNO(::setsockopt(get(), static_cast<int>(level),
static_cast<int>(optname), opt.data(), opt.size()),
diff --git a/src/stdplus/fd/impl.hpp b/src/stdplus/fd/impl.hpp
index 0487aba..b4e134c 100644
--- a/src/stdplus/fd/impl.hpp
+++ b/src/stdplus/fd/impl.hpp
@@ -11,19 +11,20 @@
public:
virtual int get() const = 0;
- span<std::byte> read(span<std::byte> buf) override;
- span<std::byte> recv(span<std::byte> buf, RecvFlags flags) override;
- span<const std::byte> write(span<const std::byte> data) override;
- span<const std::byte> send(span<const std::byte> data,
- SendFlags flags) override;
+ std::span<std::byte> read(std::span<std::byte> buf) override;
+ std::span<std::byte> recv(std::span<std::byte> buf,
+ RecvFlags flags) override;
+ std::span<const std::byte> write(std::span<const std::byte> data) override;
+ std::span<const std::byte> send(std::span<const std::byte> data,
+ SendFlags flags) override;
size_t lseek(off_t offset, Whence whence) override;
void truncate(off_t size) override;
- void bind(span<const std::byte> sockaddr) override;
+ void bind(std::span<const std::byte> sockaddr) override;
void listen(int backlog) override;
- std::tuple<std::optional<int>, span<std::byte>>
- accept(span<std::byte> sockaddr) override;
+ std::tuple<std::optional<int>, std::span<std::byte>>
+ accept(std::span<std::byte> sockaddr) override;
void setsockopt(SockLevel level, SockOpt optname,
- span<const std::byte> opt) override;
+ std::span<const std::byte> opt) override;
int ioctl(unsigned long id, void* data) override;
int constIoctl(unsigned long id, void* data) const override;
void fcntlSetfd(FdFlags flags) override;
diff --git a/src/stdplus/fd/intf.hpp b/src/stdplus/fd/intf.hpp
index bd8de13..7778ae1 100644
--- a/src/stdplus/fd/intf.hpp
+++ b/src/stdplus/fd/intf.hpp
@@ -2,8 +2,8 @@
#include <cstddef>
#include <fcntl.h>
#include <optional>
+#include <span>
#include <stdplus/flags.hpp>
-#include <stdplus/types.hpp>
#include <sys/socket.h>
#include <tuple>
@@ -85,19 +85,21 @@
public:
virtual ~Fd() = default;
- virtual span<std::byte> read(span<std::byte> buf) = 0;
- virtual span<std::byte> recv(span<std::byte> buf, RecvFlags flags) = 0;
- virtual span<const std::byte> write(span<const std::byte> data) = 0;
- virtual span<const std::byte> send(span<const std::byte> data,
- SendFlags flags) = 0;
+ virtual std::span<std::byte> read(std::span<std::byte> buf) = 0;
+ virtual std::span<std::byte> recv(std::span<std::byte> buf,
+ RecvFlags flags) = 0;
+ virtual std::span<const std::byte>
+ write(std::span<const std::byte> data) = 0;
+ virtual std::span<const std::byte> send(std::span<const std::byte> data,
+ SendFlags flags) = 0;
virtual size_t lseek(off_t offset, Whence whence) = 0;
virtual void truncate(off_t size) = 0;
- virtual void bind(span<const std::byte> sockaddr) = 0;
+ virtual void bind(std::span<const std::byte> sockaddr) = 0;
virtual void listen(int backlog) = 0;
- virtual std::tuple<std::optional<int>, span<std::byte>>
- accept(span<std::byte> sockaddr) = 0;
+ virtual std::tuple<std::optional<int>, std::span<std::byte>>
+ accept(std::span<std::byte> sockaddr) = 0;
virtual void setsockopt(SockLevel level, SockOpt optname,
- span<const std::byte> opt) = 0;
+ std::span<const std::byte> opt) = 0;
virtual int ioctl(unsigned long id, void* data) = 0;
virtual int constIoctl(unsigned long id, void* data) const = 0;
virtual void fcntlSetfd(FdFlags flags) = 0;
diff --git a/src/stdplus/fd/ops.cpp b/src/stdplus/fd/ops.cpp
index d96dbb5..d47dbb3 100644
--- a/src/stdplus/fd/ops.cpp
+++ b/src/stdplus/fd/ops.cpp
@@ -11,7 +11,7 @@
{
template <typename Fun, typename Byte, typename... Args>
-static void opExact(const char* name, Fun&& fun, Fd& fd, span<Byte> data,
+static void opExact(const char* name, Fun&& fun, Fd& fd, std::span<Byte> data,
Args&&... args)
{
while (data.size() > 0)
@@ -26,31 +26,32 @@
}
}
-void readExact(Fd& fd, span<std::byte> data)
+void readExact(Fd& fd, std::span<std::byte> data)
{
opExact("readExact", &Fd::read, fd, data);
}
-void recvExact(Fd& fd, span<std::byte> data, RecvFlags flags)
+void recvExact(Fd& fd, std::span<std::byte> data, RecvFlags flags)
{
opExact("recvExact", &Fd::recv, fd, data, flags);
}
-void writeExact(Fd& fd, span<const std::byte> data)
+void writeExact(Fd& fd, std::span<const std::byte> data)
{
opExact("writeExact", &Fd::write, fd, data);
}
-void sendExact(Fd& fd, span<const std::byte> data, SendFlags flags)
+void sendExact(Fd& fd, std::span<const std::byte> data, SendFlags flags)
{
opExact("sendExact", &Fd::send, fd, data, flags);
}
template <typename Fun, typename Byte, typename... Args>
-static span<Byte> opAligned(const char* name, Fun&& fun, Fd& fd, size_t align,
- 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)
{
- span<Byte> ret;
+ std::span<Byte> ret;
do
{
auto r =
@@ -65,25 +66,26 @@
return ret;
}
-span<std::byte> readAligned(Fd& fd, size_t align, span<std::byte> buf)
+std::span<std::byte> readAligned(Fd& fd, size_t align, std::span<std::byte> buf)
{
return opAligned("readAligned", &Fd::read, fd, align, buf);
}
-span<std::byte> recvAligned(Fd& fd, size_t align, span<std::byte> buf,
- RecvFlags flags)
+std::span<std::byte> recvAligned(Fd& fd, size_t align, std::span<std::byte> buf,
+ RecvFlags flags)
{
return opAligned("recvAligned", &Fd::recv, fd, align, buf, flags);
}
-span<const std::byte> writeAligned(Fd& fd, size_t align,
- span<const std::byte> data)
+std::span<const std::byte> writeAligned(Fd& fd, size_t align,
+ std::span<const std::byte> data)
{
return opAligned("writeAligned", &Fd::write, fd, align, data);
}
-span<const std::byte> sendAligned(Fd& fd, size_t align,
- 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/src/stdplus/fd/ops.hpp b/src/stdplus/fd/ops.hpp
index 4bfc5ba..8f3735b 100644
--- a/src/stdplus/fd/ops.hpp
+++ b/src/stdplus/fd/ops.hpp
@@ -1,9 +1,9 @@
#pragma once
+#include <span>
#include <stdexcept>
#include <stdplus/fd/dupable.hpp>
#include <stdplus/fd/intf.hpp>
#include <stdplus/raw.hpp>
-#include <stdplus/types.hpp>
#include <utility>
namespace stdplus
@@ -13,18 +13,20 @@
namespace detail
{
-void readExact(Fd& fd, span<std::byte> data);
-void recvExact(Fd& fd, span<std::byte> data, RecvFlags flags);
-void writeExact(Fd& fd, span<const std::byte> data);
-void sendExact(Fd& fd, span<const std::byte> data, SendFlags flags);
+void readExact(Fd& fd, std::span<std::byte> data);
+void recvExact(Fd& fd, std::span<std::byte> data, RecvFlags flags);
+void writeExact(Fd& fd, std::span<const std::byte> data);
+void sendExact(Fd& fd, std::span<const std::byte> data, SendFlags flags);
-span<std::byte> readAligned(Fd& fd, size_t align, span<std::byte> buf);
-span<std::byte> recvAligned(Fd& fd, size_t align, span<std::byte> buf,
- RecvFlags flags);
-span<const std::byte> writeAligned(Fd& fd, size_t align,
- span<const std::byte> data);
-span<const std::byte> sendAligned(Fd& fd, size_t align,
- span<const std::byte> data, SendFlags flags);
+std::span<std::byte> readAligned(Fd& fd, size_t align,
+ std::span<std::byte> buf);
+std::span<std::byte> recvAligned(Fd& fd, size_t align, std::span<std::byte> buf,
+ 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);
template <typename Fun, typename Container, typename... Args>
auto alignedOp(Fun&& fun, Fd& fd, Container&& c, Args&&... args)
@@ -32,7 +34,7 @@
using Data = raw::detail::dataType<Container>;
auto ret = fun(fd, sizeof(Data), raw::asSpan<std::byte>(c),
std::forward<Args>(args)...);
- return span<Data>(std::begin(c), ret.size() / sizeof(Data));
+ return std::span<Data>(std::begin(c), ret.size() / sizeof(Data));
}
} // namespace detail
@@ -127,7 +129,7 @@
inline std::optional<stdplus::DupableFd> accept(Fd& fd)
{
- auto ret = std::get<0>(fd.accept(span<std::byte>{}));
+ auto ret = std::get<0>(fd.accept(std::span<std::byte>{}));
if (!ret)
{
return std::nullopt;