mirror of
https://github.com/RGBCube/serenity
synced 2025-07-28 08:37:35 +00:00
LibIPC+IPCCompiler+AK: Make IPC value decoders return ErrorOr<void>
This allows us to use TRY() in decoding helpers, leading to a nice reduction in line count.
This commit is contained in:
Andreas Kling
parent
8d76eb773f
commit
cb9cac4e40
21 changed files with 207 additions and 296 deletions
|
|
@ -8,6 +8,7 @@
|
|||
#include <AK/URL.h>
|
||||
#include <LibCore/AnonymousBuffer.h>
|
||||
#include <LibCore/DateTime.h>
|
||||
#include <LibCore/System.h>
|
||||
#include <LibIPC/Decoder.h>
|
||||
#include <LibIPC/Dictionary.h>
|
||||
#include <LibIPC/File.h>
|
||||
|
|
@ -18,196 +19,175 @@
|
|||
|
||||
namespace IPC {
|
||||
|
||||
bool Decoder::decode(bool& value)
|
||||
ErrorOr<void> Decoder::decode(bool& value)
|
||||
{
|
||||
m_stream >> value;
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(u8& value)
|
||||
ErrorOr<void> Decoder::decode(u8& value)
|
||||
{
|
||||
m_stream >> value;
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(u16& value)
|
||||
ErrorOr<void> Decoder::decode(u16& value)
|
||||
{
|
||||
m_stream >> value;
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(u32& value)
|
||||
ErrorOr<void> Decoder::decode(u32& value)
|
||||
{
|
||||
m_stream >> value;
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(u64& value)
|
||||
ErrorOr<void> Decoder::decode(u64& value)
|
||||
{
|
||||
m_stream >> value;
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(i8& value)
|
||||
ErrorOr<void> Decoder::decode(i8& value)
|
||||
{
|
||||
m_stream >> value;
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(i16& value)
|
||||
ErrorOr<void> Decoder::decode(i16& value)
|
||||
{
|
||||
m_stream >> value;
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(i32& value)
|
||||
ErrorOr<void> Decoder::decode(i32& value)
|
||||
{
|
||||
m_stream >> value;
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(i64& value)
|
||||
ErrorOr<void> Decoder::decode(i64& value)
|
||||
{
|
||||
m_stream >> value;
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(float& value)
|
||||
ErrorOr<void> Decoder::decode(float& value)
|
||||
{
|
||||
m_stream >> value;
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(double& value)
|
||||
ErrorOr<void> Decoder::decode(double& value)
|
||||
{
|
||||
m_stream >> value;
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(String& value)
|
||||
ErrorOr<void> Decoder::decode(String& value)
|
||||
{
|
||||
i32 length = 0;
|
||||
m_stream >> length;
|
||||
if (m_stream.handle_any_error())
|
||||
return false;
|
||||
i32 length;
|
||||
TRY(decode(length));
|
||||
|
||||
if (length < 0) {
|
||||
value = {};
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
if (length == 0) {
|
||||
value = String::empty();
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
char* text_buffer = nullptr;
|
||||
auto text_impl = StringImpl::create_uninitialized(static_cast<size_t>(length), text_buffer);
|
||||
m_stream >> Bytes { text_buffer, static_cast<size_t>(length) };
|
||||
value = *text_impl;
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(ByteBuffer& value)
|
||||
ErrorOr<void> Decoder::decode(ByteBuffer& value)
|
||||
{
|
||||
i32 length = 0;
|
||||
m_stream >> length;
|
||||
if (m_stream.handle_any_error())
|
||||
return false;
|
||||
i32 length;
|
||||
TRY(decode(length));
|
||||
|
||||
if (length < 0) {
|
||||
value = {};
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
if (length == 0) {
|
||||
value = {};
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
|
||||
if (auto buffer_result = ByteBuffer::create_uninitialized(length); buffer_result.has_value())
|
||||
value = buffer_result.release_value();
|
||||
else
|
||||
return false;
|
||||
return Error::from_errno(ENOMEM);
|
||||
|
||||
m_stream >> value.bytes();
|
||||
return !m_stream.handle_any_error();
|
||||
return m_stream.try_handle_any_error();
|
||||
}
|
||||
|
||||
bool Decoder::decode(URL& value)
|
||||
ErrorOr<void> Decoder::decode(URL& value)
|
||||
{
|
||||
String string;
|
||||
if (!decode(string))
|
||||
return false;
|
||||
TRY(decode(string));
|
||||
value = URL(string);
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
|
||||
bool Decoder::decode(Dictionary& dictionary)
|
||||
ErrorOr<void> Decoder::decode(Dictionary& dictionary)
|
||||
{
|
||||
u64 size = 0;
|
||||
m_stream >> size;
|
||||
if (m_stream.handle_any_error())
|
||||
return false;
|
||||
if (size >= (size_t)NumericLimits<i32>::max()) {
|
||||
u64 size;
|
||||
TRY(decode(size));
|
||||
if (size >= (size_t)NumericLimits<i32>::max())
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < size; ++i) {
|
||||
String key;
|
||||
if (!decode(key))
|
||||
return false;
|
||||
TRY(decode(key));
|
||||
String value;
|
||||
if (!decode(value))
|
||||
return false;
|
||||
TRY(decode(value));
|
||||
dictionary.add(move(key), move(value));
|
||||
}
|
||||
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
|
||||
bool Decoder::decode([[maybe_unused]] File& file)
|
||||
ErrorOr<void> Decoder::decode([[maybe_unused]] File& file)
|
||||
{
|
||||
#ifdef __serenity__
|
||||
int fd = recvfd(m_sockfd, O_CLOEXEC);
|
||||
if (fd < 0) {
|
||||
dbgln("recvfd: {}", strerror(errno));
|
||||
return false;
|
||||
}
|
||||
int fd = TRY(Core::System::recvfd(m_sockfd, O_CLOEXEC));
|
||||
file = File(fd, File::ConstructWithReceivedFileDescriptor);
|
||||
return true;
|
||||
return {};
|
||||
#else
|
||||
[[maybe_unused]] auto fd = m_sockfd;
|
||||
warnln("fd passing is not supported on this platform, sorry :(");
|
||||
return false;
|
||||
return Error::from_string_literal("File descriptor passing not supported on this platform");
|
||||
#endif
|
||||
}
|
||||
|
||||
bool decode(Decoder& decoder, Core::AnonymousBuffer& buffer)
|
||||
ErrorOr<void> decode(Decoder& decoder, Core::AnonymousBuffer& buffer)
|
||||
{
|
||||
bool valid = false;
|
||||
if (!decoder.decode(valid))
|
||||
return false;
|
||||
bool valid;
|
||||
TRY(decoder.decode(valid));
|
||||
if (!valid) {
|
||||
buffer = {};
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
u32 size;
|
||||
if (!decoder.decode(size))
|
||||
return false;
|
||||
TRY(decoder.decode(size));
|
||||
IPC::File anon_file;
|
||||
if (!decoder.decode(anon_file))
|
||||
return false;
|
||||
TRY(decoder.decode(anon_file));
|
||||
|
||||
auto new_buffer_or_error = Core::AnonymousBuffer::create_from_anon_fd(anon_file.take_fd(), size);
|
||||
if (new_buffer_or_error.is_error())
|
||||
return false;
|
||||
buffer = new_buffer_or_error.release_value();
|
||||
return buffer.is_valid();
|
||||
buffer = TRY(Core::AnonymousBuffer::create_from_anon_fd(anon_file.take_fd(), size));
|
||||
return {};
|
||||
}
|
||||
|
||||
bool decode(Decoder& decoder, Core::DateTime& datetime)
|
||||
ErrorOr<void> decode(Decoder& decoder, Core::DateTime& datetime)
|
||||
{
|
||||
i64 timestamp = -1;
|
||||
if (!decoder.decode(timestamp))
|
||||
return false;
|
||||
|
||||
i64 timestamp;
|
||||
TRY(decoder.decode(timestamp));
|
||||
datetime = Core::DateTime::from_timestamp(static_cast<time_t>(timestamp));
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
namespace IPC {
|
||||
|
||||
template<typename T>
|
||||
inline bool decode(Decoder&, T&)
|
||||
inline ErrorOr<void> decode(Decoder&, T&)
|
||||
{
|
||||
static_assert(DependentFalse<T>, "Base IPC::decoder() instantiated");
|
||||
VERIFY_NOT_REACHED();
|
||||
|
|
@ -31,90 +31,85 @@ public:
|
|||
{
|
||||
}
|
||||
|
||||
bool decode(bool&);
|
||||
bool decode(u8&);
|
||||
bool decode(u16&);
|
||||
bool decode(u32&);
|
||||
bool decode(u64&);
|
||||
bool decode(i8&);
|
||||
bool decode(i16&);
|
||||
bool decode(i32&);
|
||||
bool decode(i64&);
|
||||
bool decode(float&);
|
||||
bool decode(double&);
|
||||
bool decode(String&);
|
||||
bool decode(ByteBuffer&);
|
||||
bool decode(URL&);
|
||||
bool decode(Dictionary&);
|
||||
bool decode(File&);
|
||||
ErrorOr<void> decode(bool&);
|
||||
ErrorOr<void> decode(u8&);
|
||||
ErrorOr<void> decode(u16&);
|
||||
ErrorOr<void> decode(u32&);
|
||||
ErrorOr<void> decode(u64&);
|
||||
ErrorOr<void> decode(i8&);
|
||||
ErrorOr<void> decode(i16&);
|
||||
ErrorOr<void> decode(i32&);
|
||||
ErrorOr<void> decode(i64&);
|
||||
ErrorOr<void> decode(float&);
|
||||
ErrorOr<void> decode(double&);
|
||||
ErrorOr<void> decode(String&);
|
||||
ErrorOr<void> decode(ByteBuffer&);
|
||||
ErrorOr<void> decode(URL&);
|
||||
ErrorOr<void> decode(Dictionary&);
|
||||
ErrorOr<void> decode(File&);
|
||||
template<typename K, typename V>
|
||||
bool decode(HashMap<K, V>& hashmap)
|
||||
ErrorOr<void> decode(HashMap<K, V>& hashmap)
|
||||
{
|
||||
u32 size;
|
||||
if (!decode(size) || size > NumericLimits<i32>::max())
|
||||
return false;
|
||||
TRY(decode(size));
|
||||
if (size > NumericLimits<i32>::max())
|
||||
return Error::from_string_literal("IPC: Invalid HashMap size"sv);
|
||||
|
||||
for (size_t i = 0; i < size; ++i) {
|
||||
K key;
|
||||
if (!decode(key))
|
||||
return false;
|
||||
|
||||
TRY(decode(key));
|
||||
V value;
|
||||
if (!decode(value))
|
||||
return false;
|
||||
|
||||
hashmap.set(move(key), move(value));
|
||||
TRY(decode(value));
|
||||
TRY(hashmap.try_set(move(key), move(value)));
|
||||
}
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
|
||||
template<Enum T>
|
||||
bool decode(T& enum_value)
|
||||
ErrorOr<void> decode(T& enum_value)
|
||||
{
|
||||
UnderlyingType<T> inner_value;
|
||||
if (!decode(inner_value))
|
||||
return false;
|
||||
|
||||
TRY(decode(inner_value));
|
||||
enum_value = T(inner_value);
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool decode(T& value)
|
||||
ErrorOr<void> decode(T& value)
|
||||
{
|
||||
return IPC::decode(*this, value);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool decode(Vector<T>& vector)
|
||||
ErrorOr<void> decode(Vector<T>& vector)
|
||||
{
|
||||
u64 size;
|
||||
if (!decode(size) || size > NumericLimits<i32>::max())
|
||||
return false;
|
||||
TRY(decode(size));
|
||||
if (size > NumericLimits<i32>::max())
|
||||
return Error::from_string_literal("IPC: Invalid Vector size"sv);
|
||||
VERIFY(vector.is_empty());
|
||||
TRY(vector.try_ensure_capacity(size));
|
||||
for (size_t i = 0; i < size; ++i) {
|
||||
T value;
|
||||
if (!decode(value))
|
||||
return false;
|
||||
vector.append(move(value));
|
||||
TRY(decode(value));
|
||||
vector.template unchecked_append(move(value));
|
||||
}
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool decode(Optional<T>& optional)
|
||||
ErrorOr<void> decode(Optional<T>& optional)
|
||||
{
|
||||
bool has_value;
|
||||
if (!decode(has_value))
|
||||
return false;
|
||||
TRY(decode(has_value));
|
||||
if (!has_value) {
|
||||
optional = {};
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
T value;
|
||||
if (!decode(value))
|
||||
return false;
|
||||
TRY(decode(value));
|
||||
optional = move(value);
|
||||
return true;
|
||||
return {};
|
||||
}
|
||||
|
||||
private:
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue