mirror of
https://github.com/RGBCube/serenity
synced 2025-05-14 12:05:00 +00:00
9b483625e6
Currently, the generated IPC decoders will default-construct the type to be decoded, then pass that value by reference to the concrete decoder. This, of course, requires that the type is default-constructible. This was an issue for decoding Variants, which had to require the first type in the Variant list is Empty, to ensure it is default constructible. Further, this made it possible for values to become uninitialized in user-defined decoders. This patch makes the decoder interface such that the concrete decoders themselves contruct the decoded type upon return from the decoder. To do so, the default decoders in IPC::Decoder had to be moved to the IPC namespace scope, as these decoders are now specializations instead of overloaded methods (C++ requires specializations to be in a namespace scope).
83 lines
1.8 KiB
C++
83 lines
1.8 KiB
C++
/*
|
|
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
|
|
* Copyright (c) 2022, the SerenityOS developers.
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <AK/Error.h>
|
|
#include <AK/Noncopyable.h>
|
|
#include <AK/RefCounted.h>
|
|
#include <AK/RefPtr.h>
|
|
#include <AK/Types.h>
|
|
#include <LibIPC/Forward.h>
|
|
|
|
namespace Core {
|
|
|
|
class AnonymousBufferImpl final : public RefCounted<AnonymousBufferImpl> {
|
|
public:
|
|
static ErrorOr<NonnullRefPtr<AnonymousBufferImpl>> create(int fd, size_t);
|
|
~AnonymousBufferImpl();
|
|
|
|
int fd() const { return m_fd; }
|
|
size_t size() const { return m_size; }
|
|
void* data() { return m_data; }
|
|
void const* data() const { return m_data; }
|
|
|
|
private:
|
|
AnonymousBufferImpl(int fd, size_t, void*);
|
|
|
|
int m_fd { -1 };
|
|
size_t m_size { 0 };
|
|
void* m_data { nullptr };
|
|
};
|
|
|
|
class AnonymousBuffer {
|
|
public:
|
|
static ErrorOr<AnonymousBuffer> create_with_size(size_t);
|
|
static ErrorOr<AnonymousBuffer> create_from_anon_fd(int fd, size_t);
|
|
|
|
AnonymousBuffer() = default;
|
|
|
|
bool is_valid() const { return m_impl; }
|
|
|
|
int fd() const { return m_impl ? m_impl->fd() : -1; }
|
|
size_t size() const { return m_impl ? m_impl->size() : 0; }
|
|
|
|
template<typename T>
|
|
T* data()
|
|
{
|
|
static_assert(IsVoid<T> || IsTrivial<T>);
|
|
if (!m_impl)
|
|
return nullptr;
|
|
return (T*)m_impl->data();
|
|
}
|
|
|
|
template<typename T>
|
|
T const* data() const
|
|
{
|
|
static_assert(IsVoid<T> || IsTrivial<T>);
|
|
if (!m_impl)
|
|
return nullptr;
|
|
return (T const*)m_impl->data();
|
|
}
|
|
|
|
private:
|
|
explicit AnonymousBuffer(NonnullRefPtr<AnonymousBufferImpl>);
|
|
|
|
RefPtr<AnonymousBufferImpl> m_impl;
|
|
};
|
|
|
|
}
|
|
|
|
namespace IPC {
|
|
|
|
template<>
|
|
bool encode(Encoder&, Core::AnonymousBuffer const&);
|
|
|
|
template<>
|
|
ErrorOr<Core::AnonymousBuffer> decode(Decoder&);
|
|
|
|
}
|