N-archive/citra
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

clang-format fixes

Browse source
This commit is contained in:
Hamish Milne 2019-12-27 21:07:29 +00:00 committed by zhupengfei
parent d482fb359c
commit 7b846ffa98
117 changed files with 797 additions and 925 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
src/common/archives.h
View file

@ -5,16 +5,11 @@
using iarchive = boost::archive::binary_iarchive;
using oarchive = boost::archive::binary_oarchive;
#define SERIALIZE_IMPL(A) template void A::serialize<iarchive>( \
iarchive & ar, \
const unsigned int file_version \
); \
template void A::serialize<oarchive>( \
oarchive & ar, \
const unsigned int file_version \
);
#define SERIALIZE_IMPL(A) \
template void A::serialize<iarchive>(iarchive & ar, const unsigned int file_version); \
template void A::serialize<oarchive>(oarchive & ar, const unsigned int file_version);
#define SERIALIZE_EXPORT_IMPL(A) \
BOOST_SERIALIZATION_REGISTER_ARCHIVE(iarchive) \
BOOST_SERIALIZATION_REGISTER_ARCHIVE(oarchive) \
BOOST_CLASS_EXPORT_IMPLEMENT(A)
#define SERIALIZE_EXPORT_IMPL(A) \
BOOST_SERIALIZATION_REGISTER_ARCHIVE(iarchive) \
BOOST_SERIALIZATION_REGISTER_ARCHIVE(oarchive) \
BOOST_CLASS_EXPORT_IMPLEMENT(A)

36
src/common/construct.h
View file

@ -2,28 +2,26 @@
class construct_access {
public:
template<class Archive, class T>
static inline void save_construct(Archive & ar, const T * t, const unsigned int file_version) {
template <class Archive, class T>
static inline void save_construct(Archive& ar, const T* t, const unsigned int file_version) {
t->save_construct(ar, file_version);
}
template<class Archive, class T>
static inline void load_construct(Archive & ar, T * t, const unsigned int file_version) {
template <class Archive, class T>
static inline void load_construct(Archive& ar, T* t, const unsigned int file_version) {
T::load_construct(ar, t, file_version);
}
};
#define BOOST_SERIALIZATION_CONSTRUCT(T) \
namespace boost { namespace serialization { \
template<class Archive> \
inline void save_construct_data( \
Archive & ar, const T * t, const unsigned int file_version \
){ \
construct_access::save_construct(ar, t, file_version); \
} \
template<class Archive> \
inline void load_construct_data( \
Archive & ar, T * t, const unsigned int file_version \
){ \
construct_access::load_construct(ar, t, file_version); \
} \
}}
#define BOOST_SERIALIZATION_CONSTRUCT(T) \
namespace boost { \
namespace serialization { \
template <class Archive> \
inline void save_construct_data(Archive& ar, const T* t, const unsigned int file_version) { \
construct_access::save_construct(ar, t, file_version); \
} \
template <class Archive> \
inline void load_construct_data(Archive& ar, T* t, const unsigned int file_version) { \
construct_access::load_construct(ar, t, file_version); \
} \
} \
}

31
src/common/pod.h
View file

@ -1,20 +1,17 @@
#include "boost/serialization/split_member.hpp"
#define SERIALIZE_AS_POD \
private: \
friend class boost::serialization::access; \
template<typename Archive> \
void save(Archive & ar, const unsigned int file_version) const { \
ar.save_binary(this, sizeof(*this)); \
} \
template<typename Archive> \
void load(Archive & ar, const unsigned int file_version) { \
ar.load_binary(this, sizeof(*this)); \
} \
template<class Archive> \
void serialize( \
Archive &ar, \
const unsigned int file_version \
){ \
boost::serialization::split_member(ar, *this, file_version); \
#define SERIALIZE_AS_POD \
private: \
friend class boost::serialization::access; \
template <typename Archive> \
void save(Archive& ar, const unsigned int file_version) const { \
ar.save_binary(this, sizeof(*this)); \
} \
template <typename Archive> \
void load(Archive& ar, const unsigned int file_version) { \
ar.load_binary(this, sizeof(*this)); \
} \
template <class Archive> \
void serialize(Archive& ar, const unsigned int file_version) { \
boost::serialization::split_member(ar, *this, file_version); \
}

9
src/common/serialization/atomic.h
View file

@ -6,20 +6,17 @@
namespace boost::serialization {
template <class Archive, class T>
void serialize(Archive& ar, std::atomic<T>& value, const unsigned int file_version)
{
void serialize(Archive& ar, std::atomic<T>& value, const unsigned int file_version) {
boost::serialization::split_free(ar, value, file_version);
}
template <class Archive, class T>
void save(Archive& ar, const std::atomic<T>& value, const unsigned int file_version)
{
void save(Archive& ar, const std::atomic<T>& value, const unsigned int file_version) {
ar << value.load();
}
template <class Archive, class T>
void load(Archive& ar, std::atomic<T>& value, const unsigned int file_version)
{
void load(Archive& ar, std::atomic<T>& value, const unsigned int file_version) {
T tmp;
ar >> tmp;
value.store(tmp);

15
src/common/serialization/boost_flat_set.h
View file

@ -1,23 +1,21 @@
#pragma once
#include "common/common_types.h"
#include <boost/container/flat_set.hpp>
#include <boost/serialization/split_free.hpp>
#include "common/common_types.h"
namespace boost::serialization {
template <class Archive, class T>
void save(Archive& ar, const boost::container::flat_set<T>& set, const unsigned int file_version)
{
void save(Archive& ar, const boost::container::flat_set<T>& set, const unsigned int file_version) {
ar << static_cast<u64>(set.size());
for (auto &v : set) {
for (auto& v : set) {
ar << v;
}
}
template <class Archive, class T>
void load(Archive& ar, boost::container::flat_set<T>& set, const unsigned int file_version)
{
void load(Archive& ar, boost::container::flat_set<T>& set, const unsigned int file_version) {
u64 count{};
ar >> count;
set.clear();
@ -29,9 +27,8 @@ void load(Archive& ar, boost::container::flat_set<T>& set, const unsigned int fi
}
template <class Archive, class T>
void serialize(Archive& ar, boost::container::flat_set<T>& set, const unsigned int file_version)
{
void serialize(Archive& ar, boost::container::flat_set<T>& set, const unsigned int file_version) {
boost::serialization::split_free(ar, set, file_version);
}
}
} // namespace boost::serialization

75
src/common/serialization/optional.h
View file

@ -7,85 +7,70 @@
#include <optional>
#include <boost/move/utility_core.hpp>
#include <boost/serialization/detail/is_default_constructible.hpp>
#include <boost/serialization/detail/stack_constructor.hpp>
#include <boost/serialization/force_include.hpp>
#include <boost/serialization/item_version_type.hpp>
#include <boost/serialization/split_free.hpp>
#include <boost/serialization/level.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/split_free.hpp>
#include <boost/serialization/version.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/serialization/detail/stack_constructor.hpp>
#include <boost/serialization/detail/is_default_constructible.hpp>
#include <boost/serialization/force_include.hpp>
// function specializations must be defined in the appropriate
// namespace - boost::serialization
namespace boost {
namespace serialization {
template<class Archive, class T>
void save(
Archive & ar,
const std::optional< T > & t,
const unsigned int /*version*/
){
// It is an inherent limitation to the serialization of optional.hpp
// that the underlying type must be either a pointer or must have a
// default constructor. It's possible that this could change sometime
// in the future, but for now, one will have to work around it. This can
// be done by serialization the optional<T> as optional<T *>
#if ! defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
BOOST_STATIC_ASSERT(
boost::serialization::detail::is_default_constructible<T>::value
|| boost::is_pointer<T>::value
);
#endif
template <class Archive, class T>
void save(Archive& ar, const std::optional<T>& t, const unsigned int /*version*/
) {
// It is an inherent limitation to the serialization of optional.hpp
// that the underlying type must be either a pointer or must have a
// default constructor. It's possible that this could change sometime
// in the future, but for now, one will have to work around it. This can
// be done by serialization the optional<T> as optional<T *>
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
BOOST_STATIC_ASSERT(boost::serialization::detail::is_default_constructible<T>::value ||
boost::is_pointer<T>::value);
#endif
const bool tflag = t.has_value();
ar << boost::serialization::make_nvp("initialized", tflag);
if (tflag){
if (tflag) {
ar << boost::serialization::make_nvp("value", *t);
}
}
template<class Archive, class T>
void load(
Archive & ar,
std::optional< T > & t,
const unsigned int version
){
template <class Archive, class T>
void load(Archive& ar, std::optional<T>& t, const unsigned int version) {
bool tflag;
ar >> boost::serialization::make_nvp("initialized", tflag);
if(! tflag){
if (!tflag) {
t.reset();
return;
}
if(0 == version){
if (0 == version) {
boost::serialization::item_version_type item_version(0);
boost::archive::library_version_type library_version(
ar.get_library_version()
);
if(boost::archive::library_version_type(3) < library_version){
boost::archive::library_version_type library_version(ar.get_library_version());
if (boost::archive::library_version_type(3) < library_version) {
ar >> BOOST_SERIALIZATION_NVP(item_version);
}
}
if(! t.has_value())
if (!t.has_value())
t = T();
ar >> boost::serialization::make_nvp("value", *t);
}
template<class Archive, class T>
void serialize(
Archive & ar,
std::optional< T > & t,
const unsigned int version
){
template <class Archive, class T>
void serialize(Archive& ar, std::optional<T>& t, const unsigned int version) {
boost::serialization::split_free(ar, t, version);
}
template<class T>
struct version<std::optional<T> > {
template <class T>
struct version<std::optional<T>> {
BOOST_STATIC_CONSTANT(int, value = 1);
};
} // serialization
} // boost
} // namespace serialization
} // namespace boost

10
src/common/thread_queue_list.h
View file

@ -162,20 +162,20 @@ private:
friend class boost::serialization::access;
template <class Archive>
void save(Archive& ar, const unsigned int file_version) const
{
void save(Archive& ar, const unsigned int file_version) const {
s32 idx = first == UnlinkedTag() ? -1 : static_cast<s32>(first - &queues[0]);
ar << idx;
for (auto i = 0; i < NUM_QUEUES; i++) {
s32 idx1 = first == UnlinkedTag() ? -1 : static_cast<s32>(queues[i].next_nonempty - &queues[0]);
s32 idx1 = first == UnlinkedTag()
? -1
: static_cast<s32>(queues[i].next_nonempty - &queues[0]);
ar << idx1;
ar << queues[i].data;
}
}
template <class Archive>
void load(Archive& ar, const unsigned int file_version)
{
void load(Archive& ar, const unsigned int file_version) {
s32 idx;
ar >> idx;
first = idx < 0 ? UnlinkedTag() : &queues[idx];

33
src/common/vector_math.h
View file

@ -46,11 +46,10 @@ class Vec4;
template <typename T>
class Vec2 {
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & x;
ar & y;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version) {
ar& x;
ar& y;
}
public:
@ -201,12 +200,11 @@ inline float Vec2<float>::Normalize() {
template <typename T>
class Vec3 {
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & x;
ar & y;
ar & z;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version) {
ar& x;
ar& y;
ar& z;
}
public:
@ -418,13 +416,12 @@ using Vec3f = Vec3<float>;
template <typename T>
class Vec4 {
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & x;
ar & y;
ar & z;
ar & w;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version) {
ar& x;
ar& y;
ar& z;
ar& w;
}
public:

12
src/core/arm/arm_interface.h
View file

@ -20,8 +20,7 @@ public:
friend class boost::serialization::access;
template <class Archive>
void save(Archive& ar, const unsigned int file_version) const
{
void save(Archive& ar, const unsigned int file_version) const {
for (auto i = 0; i < 16; i++) {
auto r = GetCpuRegister(i);
ar << r;
@ -39,8 +38,7 @@ public:
}
template <class Archive>
void load(Archive& ar, const unsigned int file_version)
{
void load(Archive& ar, const unsigned int file_version) {
u32 r;
for (auto i = 0; i < 16; i++) {
ar >> r;
@ -220,8 +218,7 @@ private:
friend class boost::serialization::access;
template <class Archive>
void save(Archive& ar, const unsigned int file_version) const
{
void save(Archive& ar, const unsigned int file_version) const {
for (auto i = 0; i < 15; i++) {
auto r = GetReg(i);
ar << r;
@ -245,8 +242,7 @@ private:
}
template <class Archive>
void load(Archive& ar, const unsigned int file_version)
{
void load(Archive& ar, const unsigned int file_version) {
u32 r;
for (auto i = 0; i < 15; i++) {
ar >> r;

39
src/core/core.cpp
View file

@ -48,10 +48,14 @@ namespace Core {
/*static*/ System System::s_instance;
template <>
Core::System& Global() { return System::GetInstance(); }
Core::System& Global() {
return System::GetInstance();
}
template <>
Kernel::KernelSystem& Global() { return System::GetInstance().Kernel(); }
Kernel::KernelSystem& Global() {
return System::GetInstance().Kernel();
}
System::ResultStatus System::RunLoop(bool tight_loop) {
status = ResultStatus::Success;
@ -209,8 +213,8 @@ System::ResultStatus System::Init(Frontend::EmuWindow& emu_window, u32 system_mo
timing = std::make_unique<Timing>();
kernel = std::make_unique<Kernel::KernelSystem>(*memory, *timing,
[this] { PrepareReschedule(); }, system_mode);
kernel = std::make_unique<Kernel::KernelSystem>(
*memory, *timing, [this] { PrepareReschedule(); }, system_mode);
if (Settings::values.use_cpu_jit) {
#ifdef ARCHITECTURE_x86_64
@ -400,32 +404,29 @@ void System::Reset() {
Load(*m_emu_window, m_filepath);
}
template<class Archive>
void System::serialize(Archive & ar, const unsigned int file_version)
{
ar & *cpu_core.get();
ar & *service_manager.get();
ar & GPU::g_regs;
ar & LCD::g_regs;
template <class Archive>
void System::serialize(Archive& ar, const unsigned int file_version) {
ar&* cpu_core.get();
ar&* service_manager.get();
ar& GPU::g_regs;
ar& LCD::g_regs;
ar & dsp_core->GetDspMemory();
ar & *memory.get();
ar & *kernel.get();
ar&* memory.get();
ar&* kernel.get();
}
void System::Save(std::ostream &stream) const
{
void System::Save(std::ostream& stream) const {
{
oarchive oa{stream};
oa & *this;
oa&* this;
}
VideoCore::Save(stream);
}
void System::Load(std::istream &stream)
{
void System::Load(std::istream& stream) {
{
iarchive ia{stream};
ia & *this;
ia&* this;
}
VideoCore::Load(stream);
}

8
src/core/core.h
View file

@ -272,9 +272,9 @@ public:
return registered_image_interface;
}
void Save(std::ostream &stream) const;
void Save(std::ostream& stream) const;
void Load(std::istream &stream);
void Load(std::istream& stream);
private:
/**
@ -345,8 +345,8 @@ private:
std::atomic<bool> shutdown_requested;
friend class boost::serialization::access;
template<typename Archive>
void serialize(Archive & ar, const unsigned int file_version);
template <typename Archive>
void serialize(Archive& ar, const unsigned int file_version);
};
inline ARM_Interface& CPU() {

2
src/core/hle/kernel/address_arbiter.cpp
View file

@ -6,12 +6,12 @@
#include "common/archives.h"
#include "common/common_types.h"
#include "common/logging/log.h"
#include "core/global.h"
#include "core/hle/kernel/address_arbiter.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/thread.h"
#include "core/memory.h"
#include "core/global.h"
////////////////////////////////////////////////////////////////////////////////////////////////////
// Kernel namespace

9
src/core/hle/kernel/address_arbiter.h
View file

@ -74,11 +74,10 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & boost::serialization::base_object<Object>(*this);
ar & name;
ar & waiting_threads;
void serialize(Archive& ar, const unsigned int file_version) {
ar& boost::serialization::base_object<Object>(*this);
ar& name;
ar& waiting_threads;
}
};

2
src/core/hle/kernel/client_port.cpp
View file

@ -4,6 +4,7 @@
#include "common/archives.h"
#include "common/assert.h"
#include "core/global.h"
#include "core/hle/kernel/client_port.h"
#include "core/hle/kernel/client_session.h"
#include "core/hle/kernel/errors.h"
@ -11,7 +12,6 @@
#include "core/hle/kernel/object.h"
#include "core/hle/kernel/server_port.h"
#include "core/hle/kernel/server_session.h"
#include "core/global.h"
SERIALIZE_EXPORT_IMPL(Kernel::ClientPort)

14
src/core/hle/kernel/client_port.h
View file

@ -61,17 +61,15 @@ private:
friend class KernelSystem;
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & boost::serialization::base_object<Object>(*this);
ar & server_port;
ar & max_sessions;
ar & active_sessions;
ar & name;
void serialize(Archive& ar, const unsigned int file_version) {
ar& boost::serialization::base_object<Object>(*this);
ar& server_port;
ar& max_sessions;
ar& active_sessions;
ar& name;
}
};

2
src/core/hle/kernel/client_session.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "common/assert.h"
#include "common/archives.h"
#include "common/assert.h"
#include "core/hle/kernel/client_session.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/hle_ipc.h"

9
src/core/hle/kernel/client_session.h
View file

@ -53,11 +53,10 @@ public:
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & boost::serialization::base_object<Object>(*this);
ar & name;
ar & parent;
void serialize(Archive& ar, const unsigned int file_version) {
ar& boost::serialization::base_object<Object>(*this);
ar& name;
ar& parent;
}
};

5
src/core/hle/kernel/config_mem.h
View file

@ -60,10 +60,9 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
void serialize(Archive& ar, const unsigned int file_version) {
auto o_config_mem = boost::serialization::binary_object(&config_mem, sizeof(config_mem));
ar & o_config_mem;
ar& o_config_mem;
}
};

2
src/core/hle/kernel/event.cpp
View file

@ -5,8 +5,8 @@
#include <algorithm>
#include <map>
#include <vector>
#include "common/assert.h"
#include "common/archives.h"
#include "common/assert.h"
#include "core/hle/kernel/event.h"
#include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/thread.h"

11
src/core/hle/kernel/event.h
View file

@ -53,12 +53,11 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & boost::serialization::base_object<WaitObject>(*this);
ar & reset_type;
ar & signaled;
ar & name;
void serialize(Archive& ar, const unsigned int file_version) {
ar& boost::serialization::base_object<WaitObject>(*this);
ar& reset_type;
ar& signaled;
ar& name;
}
};

11
src/core/hle/kernel/handle_table.h
View file

@ -121,12 +121,11 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & objects;
ar & generations;
ar & next_generation;
ar & next_free_slot;
void serialize(Archive& ar, const unsigned int file_version) {
ar& objects;
ar& generations;
ar& next_generation;
ar& next_free_slot;
}
};

21
src/core/hle/kernel/hle_ipc.h
View file

@ -11,10 +11,10 @@
#include <string>
#include <vector>
#include <boost/container/small_vector.hpp>
#include <boost/serialization/unique_ptr.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/assume_abstract.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/unique_ptr.hpp>
#include <boost/serialization/vector.hpp>
#include "common/common_types.h"
#include "common/swap.h"
#include "core/hle/ipc.h"
@ -74,9 +74,10 @@ public:
/// in each service must inherit from this.
struct SessionDataBase {
virtual ~SessionDataBase() = default;
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version) { }
void serialize(Archive& ar, const unsigned int file_version) {}
friend class boost::serialization::access;
};
@ -104,10 +105,9 @@ protected:
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & session;
ar & data;
void serialize(Archive& ar, const unsigned int file_version) {
ar& session;
ar& data;
}
friend class boost::serialization::access;
};
@ -117,9 +117,8 @@ protected:
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & connected_sessions;
void serialize(Archive& ar, const unsigned int file_version) {
ar& connected_sessions;
}
friend class boost::serialization::access;
};

18
src/core/hle/kernel/ipc.h
View file

@ -30,15 +30,15 @@ struct MappedBufferContext {
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & permissions;
ar & size;
ar & source_address;
ar & target_address;
// TODO: Check whether we need these. If we do, add a field for the size and/or change to a 'vector'
//ar & buffer;
//ar & reserve_buffer;
void serialize(Archive& ar, const unsigned int file_version) {
ar& permissions;
ar& size;
ar& source_address;
ar& target_address;
// TODO: Check whether we need these. If we do, add a field for the size and/or change to a
// 'vector'
// ar & buffer;
// ar & reserve_buffer;
}
friend class boost::serialization::access;
};

25
src/core/hle/kernel/kernel.cpp
View file

@ -104,20 +104,19 @@ void KernelSystem::AddNamedPort(std::string name, std::shared_ptr<ClientPort> po
}
template <class Archive>
void KernelSystem::serialize(Archive& ar, const unsigned int file_version)
{
ar & memory_regions;
ar & named_ports;
ar & *current_cpu.get();
void KernelSystem::serialize(Archive& ar, const unsigned int file_version) {
ar& memory_regions;
ar& named_ports;
ar&* current_cpu.get();
// NB: subsystem references and prepare_reschedule_callback are constant
ar & *resource_limits.get();
ar & next_object_id;
ar & *timer_manager.get();
ar & next_process_id;
ar & process_list;
ar & current_process;
ar & *thread_manager.get();
ar & *config_mem_handler.get();
ar&* resource_limits.get();
ar& next_object_id;
ar&* timer_manager.get();
ar& next_process_id;
ar& process_list;
ar& current_process;
ar&* thread_manager.get();
ar&* config_mem_handler.get();
// Shared page data is read-only at the moment, so doesn't need serializing
// Deliberately don't include debugger info to allow debugging through loads
}

13
src/core/hle/kernel/memory.h
View file

@ -7,8 +7,8 @@
#include <optional>
#include <boost/icl/interval_set.hpp>
#include <boost/serialization/set.hpp>
#include "common/serialization/boost_discrete_interval.hpp"
#include "common/common_types.h"
#include "common/serialization/boost_discrete_interval.hpp"
namespace Kernel {
@ -66,13 +66,12 @@ struct MemoryRegionInfo {
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & base;
ar & size;
ar & used;
void serialize(Archive& ar, const unsigned int file_version) {
ar& base;
ar& size;
ar& used;
// This works because interval_set has exactly one member of type ImplSetT
ar & *(reinterpret_cast<IntervalSet::ImplSetT*>(&free_blocks));
ar&*(reinterpret_cast<IntervalSet::ImplSetT*>(&free_blocks));
}
};

2
src/core/hle/kernel/mutex.cpp
View file

@ -7,12 +7,12 @@
#include "common/archives.h"
#include "common/assert.h"
#include "core/core.h"
#include "core/global.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/mutex.h"
#include "core/hle/kernel/object.h"
#include "core/hle/kernel/thread.h"
#include "core/global.h"
SERIALIZE_EXPORT_IMPL(Kernel::Mutex)

13
src/core/hle/kernel/mutex.h
View file

@ -62,13 +62,12 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & boost::serialization::base_object<WaitObject>(*this);
ar & lock_count;
ar & priority;
ar & name;
ar & holding_thread;
void serialize(Archive& ar, const unsigned int file_version) {
ar& boost::serialization::base_object<WaitObject>(*this);
ar& lock_count;
ar& priority;
ar& name;
ar& holding_thread;
}
};

24
src/core/hle/kernel/object.h
View file

@ -10,10 +10,10 @@
#include <boost/serialization/access.hpp>
#include <boost/serialization/assume_abstract.hpp>
#include <boost/serialization/export.hpp>
#include "common/serialization/atomic.h"
#include "common/common_types.h"
#include "core/hle/kernel/kernel.h"
#include "common/serialization/atomic.h"
#include "core/global.h"
#include "core/hle/kernel/kernel.h"
namespace Kernel {
@ -72,9 +72,8 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & object_id;
void serialize(Archive& ar, const unsigned int file_version) {
ar& object_id;
}
};
@ -102,11 +101,10 @@ inline std::shared_ptr<T> DynamicObjectCast(std::shared_ptr<Object> object) {
BOOST_SERIALIZATION_ASSUME_ABSTRACT(Kernel::Object)
#define CONSTRUCT_KERNEL_OBJECT(T) \
namespace boost::serialization { \
template<class Archive> \
inline void load_construct_data( \
Archive & ar, T * t, const unsigned int file_version \
){ \
::new(t)T(Core::Global<Kernel::KernelSystem>()); \
}}
#define CONSTRUCT_KERNEL_OBJECT(T) \
namespace boost::serialization { \
template <class Archive> \
inline void load_construct_data(Archive& ar, T* t, const unsigned int file_version) { \
::new (t) T(Core::Global<Kernel::KernelSystem>()); \
} \
}

39
src/core/hle/kernel/process.cpp
View file

@ -11,6 +11,7 @@
#include "common/common_funcs.h"
#include "common/logging/log.h"
#include "common/serialization/boost_vector.hpp"
#include "core/global.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/memory.h"
#include "core/hle/kernel/process.h"
@ -18,7 +19,6 @@
#include "core/hle/kernel/thread.h"
#include "core/hle/kernel/vm_manager.h"
#include "core/memory.h"
#include "core/global.h"
SERIALIZE_EXPORT_IMPL(Kernel::Process)
SERIALIZE_EXPORT_IMPL(Kernel::CodeSet)
@ -26,24 +26,25 @@ SERIALIZE_EXPORT_IMPL(Kernel::CodeSet)
namespace Kernel {
template <class Archive>
void Process::serialize(Archive& ar, const unsigned int file_version)
{
ar & boost::serialization::base_object<Object>(*this);
ar & handle_table;
ar & codeset;
ar & resource_limit;
ar & svc_access_mask;
ar & handle_table_size;
ar & (boost::container::vector<AddressMapping, boost::container::dtl::static_storage_allocator<AddressMapping, 8> >&)address_mappings;
ar & flags.raw;
ar & kernel_version;
ar & ideal_processor;
ar & status;
ar & process_id;
ar & vm_manager;
ar & memory_used;
ar & memory_region;
ar & tls_slots;
void Process::serialize(Archive& ar, const unsigned int file_version) {
ar& boost::serialization::base_object<Object>(*this);
ar& handle_table;
ar& codeset;
ar& resource_limit;
ar& svc_access_mask;
ar& handle_table_size;
ar&(boost::container::vector<
AddressMapping, boost::container::dtl::static_storage_allocator<AddressMapping, 8>>&)
address_mappings;
ar& flags.raw;
ar& kernel_version;
ar& ideal_processor;
ar& status;
ar& process_id;
ar& vm_manager;
ar& memory_used;
ar& memory_region;
ar& tls_slots;
}
SERIALIZE_IMPL(Process)

35
src/core/hle/kernel/process.h
View file

@ -11,8 +11,8 @@
#include <string>
#include <vector>
#include <boost/container/static_vector.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/vector.hpp>
#include "common/bit_field.h"
#include "common/common_types.h"
#include "core/hle/kernel/handle_table.h"
@ -31,12 +31,11 @@ struct AddressMapping {
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & address;
ar & size;
ar & read_only;
ar & unk_flag;
void serialize(Archive& ar, const unsigned int file_version) {
ar& address;
ar& size;
ar& read_only;
ar& unk_flag;
}
};
@ -76,11 +75,10 @@ public:
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & offset;
ar & addr;
ar & size;
void serialize(Archive& ar, const unsigned int file_version) {
ar& offset;
ar& addr;
ar& size;
}
};
@ -133,14 +131,13 @@ public:
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & boost::serialization::base_object<Object>(*this);
void serialize(Archive& ar, const unsigned int file_version) {
ar& boost::serialization::base_object<Object>(*this);
// TODO: memory reference
ar & segments;
ar & entrypoint;
ar & name;
ar & program_id;
ar& segments;
ar& entrypoint;
ar& name;
ar& program_id;
}
};

53
src/core/hle/kernel/resource_limit.h
View file

@ -116,30 +116,30 @@ public:
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & boost::serialization::base_object<Object>(*this);
// NB most of these aren't used at all currently, but we're adding them here for forwards compatibility
ar & name;
ar & max_priority;
ar & max_commit;
ar & max_threads;
ar & max_events;
ar & max_mutexes;
ar & max_semaphores;
ar & max_timers;
ar & max_shared_mems;
ar & max_address_arbiters;
ar & max_cpu_time;
ar & current_commit;
ar & current_threads;
ar & current_events;
ar & current_mutexes;
ar & current_semaphores;
ar & current_timers;
ar & current_shared_mems;
ar & current_address_arbiters;
ar & current_cpu_time;
void serialize(Archive& ar, const unsigned int file_version) {
ar& boost::serialization::base_object<Object>(*this);
// NB most of these aren't used at all currently, but we're adding them here for forwards
// compatibility
ar& name;
ar& max_priority;
ar& max_commit;
ar& max_threads;
ar& max_events;
ar& max_mutexes;
ar& max_semaphores;
ar& max_timers;
ar& max_shared_mems;
ar& max_address_arbiters;
ar& max_cpu_time;
ar& current_commit;
ar& current_threads;
ar& current_events;
ar& current_mutexes;
ar& current_semaphores;
ar& current_timers;
ar& current_shared_mems;
ar& current_address_arbiters;
ar& current_cpu_time;
}
};
@ -160,9 +160,8 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & resource_limits;
void serialize(Archive& ar, const unsigned int file_version) {
ar& resource_limits;
}
};

2
src/core/hle/kernel/semaphore.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "common/assert.h"
#include "common/archives.h"
#include "common/assert.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/semaphore.h"

13
src/core/hle/kernel/semaphore.h
View file

@ -5,8 +5,8 @@
#pragma once
#include <string>
#include <queue>
#include <boost/serialization/export.hpp>
#include <queue>
#include "common/common_types.h"
#include "core/hle/kernel/object.h"
#include "core/hle/kernel/wait_object.h"
@ -48,12 +48,11 @@ public:
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & boost::serialization::base_object<WaitObject>(*this);
ar & max_count;
ar & available_count;
ar & name;
void serialize(Archive& ar, const unsigned int file_version) {
ar& boost::serialization::base_object<WaitObject>(*this);
ar& max_count;
ar& available_count;
ar& name;
}
};

13
src/core/hle/kernel/server_port.cpp
View file

@ -7,11 +7,11 @@
#include "common/assert.h"
#include "core/hle/kernel/client_port.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/hle_ipc.h"
#include "core/hle/kernel/object.h"
#include "core/hle/kernel/server_port.h"
#include "core/hle/kernel/server_session.h"
#include "core/hle/kernel/thread.h"
#include "core/hle/kernel/hle_ipc.h"
SERIALIZE_EXPORT_IMPL(Kernel::ServerPort)
@ -53,12 +53,11 @@ KernelSystem::PortPair KernelSystem::CreatePortPair(u32 max_sessions, std::strin
}
template <class Archive>
void ServerPort::serialize(Archive& ar, const unsigned int file_version)
{
ar & boost::serialization::base_object<WaitObject>(*this);
ar & name;
ar & pending_sessions;
ar & hle_handler;
void ServerPort::serialize(Archive& ar, const unsigned int file_version) {
ar& boost::serialization::base_object<WaitObject>(*this);
ar& name;
ar& pending_sessions;
ar& hle_handler;
}
SERIALIZE_IMPL(ServerPort)

2
src/core/hle/kernel/server_session.cpp
View file

@ -4,13 +4,13 @@
#include <tuple>
#include "common/archives.h"
#include "core/global.h"
#include "core/hle/kernel/client_port.h"
#include "core/hle/kernel/client_session.h"
#include "core/hle/kernel/hle_ipc.h"
#include "core/hle/kernel/server_session.h"
#include "core/hle/kernel/session.h"
#include "core/hle/kernel/thread.h"
#include "core/global.h"
SERIALIZE_EXPORT_IMPL(Kernel::ServerSession)

17
src/core/hle/kernel/server_session.h
View file

@ -110,15 +110,14 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & boost::serialization::base_object<Object>(*this);
ar & name;
ar & parent;
ar & hle_handler;
ar & pending_requesting_threads;
ar & currently_handling;
ar & mapped_buffer_context;
void serialize(Archive& ar, const unsigned int file_version) {
ar& boost::serialization::base_object<Object>(*this);
ar& name;
ar& parent;
ar& hle_handler;
ar& pending_requesting_threads;
ar& currently_handling;
ar& mapped_buffer_context;
}
};

15
src/core/hle/kernel/session.cpp
View file

@ -4,22 +4,21 @@
#include <boost/serialization/shared_ptr.hpp>
#include "common/archives.h"
#include "core/hle/kernel/session.h"
#include "core/hle/kernel/client_session.h"
#include "core/hle/kernel/server_session.h"
#include "core/hle/kernel/client_port.h"
#include "core/hle/kernel/client_session.h"
#include "core/hle/kernel/hle_ipc.h"
#include "core/hle/kernel/server_session.h"
#include "core/hle/kernel/session.h"
SERIALIZE_IMPL(Kernel::Session)
namespace Kernel {
template <class Archive>
void Session::serialize(Archive& ar, const unsigned int file_version)
{
ar & client;
ar & server;
ar & port;
void Session::serialize(Archive& ar, const unsigned int file_version) {
ar& client;
ar& server;
ar& port;
}
} // namespace Kernel

2
src/core/hle/kernel/shared_memory.cpp
View file

@ -5,11 +5,11 @@
#include <cstring>
#include "common/archives.h"
#include "common/logging/log.h"
#include "core/global.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/memory.h"
#include "core/hle/kernel/shared_memory.h"
#include "core/memory.h"
#include "core/global.h"
SERIALIZE_EXPORT_IMPL(Kernel::SharedMemory)

19
src/core/hle/kernel/shared_memory.h
View file

@ -107,17 +107,16 @@ private:
KernelSystem& kernel;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & linear_heap_phys_offset;
void serialize(Archive& ar, const unsigned int file_version) {
ar& linear_heap_phys_offset;
// TODO: backing blocks u8* (this is always FCRAM I think)
ar & size;
ar & permissions;
ar & other_permissions;
ar & owner_process;
ar & base_address;
ar & name;
ar & *(reinterpret_cast<MemoryRegionInfo::IntervalSet::ImplSetT*>(&holding_memory));
ar& size;
ar& permissions;
ar& other_permissions;
ar& owner_process;
ar& base_address;
ar& name;
ar&*(reinterpret_cast<MemoryRegionInfo::IntervalSet::ImplSetT*>(&holding_memory));
}
friend class boost::serialization::access;
};

5
src/core/hle/kernel/shared_page.h
View file

@ -108,10 +108,9 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
void serialize(Archive& ar, const unsigned int file_version) {
auto o_shared_page = boost::serialization::binary_object(&shared_page, sizeof(shared_page));
ar & o_shared_page;
ar& o_shared_page;
}
};

37
src/core/hle/kernel/thread.cpp
View file

@ -15,6 +15,7 @@
#include "core/arm/arm_interface.h"
#include "core/arm/skyeye_common/armstate.h"
#include "core/core.h"
#include "core/global.h"
#include "core/hle/kernel/errors.h"
#include "core/hle/kernel/handle_table.h"
#include "core/hle/kernel/kernel.h"
@ -24,31 +25,29 @@
#include "core/hle/kernel/thread.h"
#include "core/hle/result.h"
#include "core/memory.h"
#include "core/global.h"
SERIALIZE_EXPORT_IMPL(Kernel::Thread)
namespace Kernel {
template <class Archive>
void Thread::serialize(Archive& ar, const unsigned int file_version)
{
ar & *context.get();
ar & thread_id;
ar & status;
ar & entry_point;
ar & stack_top;
ar & nominal_priority;
ar & current_priority;
ar & last_running_ticks;
ar & processor_id;
ar & tls_address;
ar & held_mutexes;
ar & pending_mutexes;
ar & owner_process;
ar & wait_objects;
ar & wait_address;
ar & name;
void Thread::serialize(Archive& ar, const unsigned int file_version) {
ar&* context.get();
ar& thread_id;
ar& status;
ar& entry_point;
ar& stack_top;
ar& nominal_priority;
ar& current_priority;
ar& last_running_ticks;
ar& processor_id;
ar& tls_address;
ar& held_mutexes;
ar& pending_mutexes;
ar& owner_process;
ar& wait_objects;
ar& wait_address;
ar& name;
// TODO: How the hell to do wakeup_callback
}

15
src/core/hle/kernel/thread.h
View file

@ -9,10 +9,10 @@
#include <unordered_map>
#include <vector>
#include <boost/container/flat_set.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/unordered_map.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/export.hpp>
#include "common/common_types.h"
#include "common/thread_queue_list.h"
#include "core/arm/arm_interface.h"
@ -152,13 +152,12 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & next_thread_id;
ar & current_thread;
ar & ready_queue;
ar & wakeup_callback_table;
ar & thread_list;
void serialize(Archive& ar, const unsigned int file_version) {
ar& next_thread_id;
ar& current_thread;
ar& ready_queue;
ar& wakeup_callback_table;
ar& thread_list;
}
};

2
src/core/hle/kernel/timer.cpp
View file

@ -8,11 +8,11 @@
#include "common/assert.h"
#include "common/logging/log.h"
#include "core/core.h"
#include "core/global.h"
#include "core/hle/kernel/handle_table.h"
#include "core/hle/kernel/object.h"
#include "core/hle/kernel/thread.h"
#include "core/hle/kernel/timer.h"
#include "core/global.h"
SERIALIZE_EXPORT_IMPL(Kernel::Timer)

22
src/core/hle/kernel/timer.h
View file

@ -37,10 +37,9 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & next_timer_callback_id;
ar & timer_callback_table;
void serialize(Archive& ar, const unsigned int file_version) {
ar& next_timer_callback_id;
ar& timer_callback_table;
}
};
@ -115,14 +114,13 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & reset_type;
ar & initial_delay;
ar & interval_delay;
ar & signaled;
ar & name;
ar & callback_id;
void serialize(Archive& ar, const unsigned int file_version) {
ar& reset_type;
ar& initial_delay;
ar& interval_delay;
ar& signaled;
ar& name;
ar& callback_id;
}
};

35
src/core/hle/kernel/vm_manager.h
View file

@ -86,17 +86,16 @@ struct VirtualMemoryArea {
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & base;
ar & size;
ar & type;
ar & permissions;
ar & meminfo_state;
void serialize(Archive& ar, const unsigned int file_version) {
ar& base;
ar& size;
ar& type;
ar& permissions;
ar& meminfo_state;
// TODO: backing memory ref
// backing memory can be: Physical/FCRAM pointer, config mem, shared page
ar & paddr;
ar & mmio_handler;
ar& paddr;
ar& mmio_handler;
}
};
@ -213,27 +212,25 @@ public:
private:
friend class boost::serialization::access;
template <class Archive>
void save(Archive& ar, const unsigned int file_version) const
{
ar & vma_map;
void save(Archive& ar, const unsigned int file_version) const {
ar& vma_map;
for (int i = 0; i < page_table.pointers.size(); i++) {
ar << memory.GetFCRAMOffset(page_table.pointers[i]);
}
ar & page_table.special_regions;
ar & page_table.attributes;
ar& page_table.special_regions;
ar& page_table.attributes;
}
template <class Archive>
void load(Archive& ar, const unsigned int file_version)
{
ar & vma_map;
void load(Archive& ar, const unsigned int file_version) {
ar& vma_map;
for (int i = 0; i < page_table.pointers.size(); i++) {
u32 offset{};
ar >> offset;
page_table.pointers[i] = memory.GetFCRAMPointer(offset);
}
ar & page_table.special_regions;
ar & page_table.attributes;
ar& page_table.special_regions;
ar& page_table.attributes;
}
BOOST_SERIALIZATION_SPLIT_MEMBER()

7
src/core/hle/kernel/wait_object.h
View file

@ -69,10 +69,9 @@ private:
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int file_version)
{
ar & boost::serialization::base_object<Object>(*this);
ar & waiting_threads;
void serialize(Archive& ar, const unsigned int file_version) {
ar& boost::serialization::base_object<Object>(*this);
ar& waiting_threads;
// NB: hle_notifier *not* serialized since it's a callback!
// Fortunately it's only used in one place (DSP) so we can reconstruct it there
}

13
src/core/hle/service/ac/ac.cpp
View file

@ -3,9 +3,9 @@
// Refer to the license.txt file included.
#include <vector>
#include "common/archives.h"
#include "common/common_types.h"
#include "common/logging/log.h"
#include "common/archives.h"
#include "core/core.h"
#include "core/hle/ipc.h"
#include "core/hle/ipc_helpers.h"
@ -181,12 +181,11 @@ void InstallInterfaces(Core::System& system) {
}
template <class Archive>
void Module::serialize(Archive& ar, const unsigned int)
{
ar & ac_connected;
ar & close_event;
ar & connect_event;
ar & disconnect_event;
void Module::serialize(Archive& ar, const unsigned int) {
ar& ac_connected;
ar& close_event;
ar& connect_event;
ar& disconnect_event;
// default_config is never written to
}

2
src/core/hle/service/ac/ac_i.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/ac/ac_i.h"
#include "common/archives.h"
#include "core/hle/service/ac/ac_i.h"
namespace Service::AC {

2
src/core/hle/service/ac/ac_u.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/ac/ac_u.h"
#include "common/archives.h"
#include "core/hle/service/ac/ac_u.h"
namespace Service::AC {

3
src/core/hle/service/act/act.h
View file

@ -23,9 +23,10 @@ public:
protected:
std::shared_ptr<Module> act;
};
private:
template <class Archive>
inline void serialize(Archive& ar, const unsigned int file_version) { }
inline void serialize(Archive& ar, const unsigned int file_version) {}
friend class boost::serialization::access;
};

2
src/core/hle/service/act/act_a.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/act/act_a.h"
#include "common/archives.h"
#include "core/hle/service/act/act_a.h"
namespace Service::ACT {

1
src/core/hle/service/act/act_a.h
View file

@ -11,6 +11,7 @@ namespace Service::ACT {
class ACT_A final : public Module::Interface {
public:
explicit ACT_A(std::shared_ptr<Module> act);
private:
SERVICE_SERIALIZATION(ACT_A, act, Module)
};

2
src/core/hle/service/act/act_u.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/act/act_u.h"
#include "common/archives.h"
#include "core/hle/service/act/act_u.h"
namespace Service::ACT {

1
src/core/hle/service/act/act_u.h
View file

@ -11,6 +11,7 @@ namespace Service::ACT {
class ACT_U final : public Module::Interface {
public:
explicit ACT_U(std::shared_ptr<Module> act);
private:
SERVICE_SERIALIZATION(ACT_U, act, Module)
};

2
src/core/hle/service/am/am.cpp
View file

@ -1455,7 +1455,7 @@ Module::Module(Core::System& system) : kernel(system.Kernel()) {
system_updater_mutex = system.Kernel().CreateMutex(false, "AM::SystemUpdaterMutex");
}
Module::Module(Kernel::KernelSystem& kernel) : kernel(kernel) { }
Module::Module(Kernel::KernelSystem& kernel) : kernel(kernel) {}
Module::~Module() = default;

22
src/core/hle/service/am/am.h
View file

@ -10,15 +10,15 @@
#include <string>
#include <vector>
#include <boost/serialization/array.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/vector.hpp>
#include "common/common_types.h"
#include "core/file_sys/cia_container.h"
#include "core/file_sys/file_backend.h"
#include "core/global.h"
#include "core/hle/kernel/mutex.h"
#include "core/hle/result.h"
#include "core/hle/service/service.h"
#include "core/global.h"
namespace Core {
class System;
@ -585,11 +585,10 @@ private:
std::shared_ptr<Kernel::Mutex> system_updater_mutex;
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & cia_installing;
ar & am_title_list;
ar & system_updater_mutex;
void serialize(Archive& ar, const unsigned int) {
ar& cia_installing;
ar& am_title_list;
ar& system_updater_mutex;
}
friend class boost::serialization::access;
};
@ -599,9 +598,8 @@ void InstallInterfaces(Core::System& system);
} // namespace Service::AM
namespace boost::serialization {
template <class Archive>
inline void load_construct_data(Archive& ar, Service::AM::Module* t, const unsigned int)
{
::new(t)Service::AM::Module(Core::Global<Kernel::KernelSystem>());
}
template <class Archive>
inline void load_construct_data(Archive& ar, Service::AM::Module* t, const unsigned int) {
::new (t) Service::AM::Module(Core::Global<Kernel::KernelSystem>());
}
} // namespace boost::serialization

2
src/core/hle/service/am/am_app.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/am/am_app.h"
#include "common/archives.h"
#include "core/hle/service/am/am_app.h"
namespace Service::AM {

1
src/core/hle/service/am/am_app.h
View file

@ -11,6 +11,7 @@ namespace Service::AM {
class AM_APP final : public Module::Interface {
public:
explicit AM_APP(std::shared_ptr<Module> am);
private:
SERVICE_SERIALIZATION(AM_APP, am, Module)
};

2
src/core/hle/service/am/am_net.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/am/am_net.h"
#include "common/archives.h"
#include "core/hle/service/am/am_net.h"
namespace Service::AM {

1
src/core/hle/service/am/am_net.h
View file

@ -11,6 +11,7 @@ namespace Service::AM {
class AM_NET final : public Module::Interface {
public:
explicit AM_NET(std::shared_ptr<Module> am);
private:
SERVICE_SERIALIZATION(AM_NET, am, Module)
};

2
src/core/hle/service/am/am_sys.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/am/am_sys.h"
#include "common/archives.h"
#include "core/hle/service/am/am_sys.h"
namespace Service::AM {

1
src/core/hle/service/am/am_sys.h
View file

@ -11,6 +11,7 @@ namespace Service::AM {
class AM_SYS final : public Module::Interface {
public:
explicit AM_SYS(std::shared_ptr<Module> am);
private:
SERVICE_SERIALIZATION(AM_SYS, am, Module)
};

2
src/core/hle/service/am/am_u.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/am/am_u.h"
#include "common/archives.h"
#include "core/hle/service/am/am_u.h"
namespace Service::AM {

1
src/core/hle/service/am/am_u.h
View file

@ -11,6 +11,7 @@ namespace Service::AM {
class AM_U final : public Module::Interface {
public:
explicit AM_U(std::shared_ptr<Module> am);
private:
SERVICE_SERIALIZATION(AM_U, am, Module)
};

65
src/core/hle/service/apt/applet_manager.h
View file

@ -10,10 +10,10 @@
#include <vector>
#include <boost/serialization/array.hpp>
#include "common/serialization/optional.h"
#include "core/global.h"
#include "core/hle/kernel/event.h"
#include "core/hle/result.h"
#include "core/hle/service/fs/archive.h"
#include "core/global.h"
namespace Core {
class System;
@ -90,13 +90,12 @@ struct MessageParameter {
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & sender_id;
ar & destination_id;
ar & signal;
ar & object;
ar & buffer;
void serialize(Archive& ar, const unsigned int) {
ar& sender_id;
ar& destination_id;
ar& signal;
ar& object;
ar& buffer;
}
friend class boost::serialization::access;
};
@ -179,12 +178,11 @@ public:
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & next_title_id;
ar & next_media_type;
ar & current_title_id;
ar & current_media_type;
void serialize(Archive& ar, const unsigned int) {
ar& next_title_id;
ar& next_media_type;
ar& current_title_id;
ar& current_media_type;
}
friend class boost::serialization::access;
};
@ -228,16 +226,15 @@ private:
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & applet_id;
ar & slot;
ar & title_id;
ar & registered;
ar & loaded;
ar & attributes.raw;
ar & notification_event;
ar & parameter_event;
void serialize(Archive& ar, const unsigned int) {
ar& applet_id;
ar& slot;
ar& title_id;
ar& registered;
ar& loaded;
ar& attributes.raw;
ar& notification_event;
ar& parameter_event;
}
friend class boost::serialization::access;
};
@ -260,12 +257,11 @@ private:
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & next_parameter;
ar & app_jump_parameters;
ar & applet_slots;
ar & library_applet_closing_command;
void serialize(Archive& ar, const unsigned int) {
ar& next_parameter;
ar& app_jump_parameters;
ar& applet_slots;
ar& library_applet_closing_command;
}
friend class boost::serialization::access;
};
@ -273,9 +269,8 @@ private:
} // namespace Service::APT
namespace boost::serialization {
template <class Archive>
inline void load_construct_data(Archive& ar, Service::APT::AppletManager* t, const unsigned int)
{
::new(t)Service::APT::AppletManager(Core::Global<Core::System>());
}
template <class Archive>
inline void load_construct_data(Archive& ar, Service::APT::AppletManager* t, const unsigned int) {
::new (t) Service::APT::AppletManager(Core::Global<Core::System>());
}
} // namespace boost::serialization

23
src/core/hle/service/apt/apt.cpp
View file

@ -2,10 +2,10 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "common/archives.h"
#include "common/common_paths.h"
#include "common/file_util.h"
#include "common/logging/log.h"
#include "common/archives.h"
#include "core/core.h"
#include "core/file_sys/archive_ncch.h"
#include "core/file_sys/file_backend.h"
@ -32,17 +32,16 @@ SERVICE_CONSTRUCT_IMPL(Service::APT::Module)
namespace Service::APT {
template <class Archive>
void Module::serialize(Archive& ar, const unsigned int)
{
ar & shared_font_mem;
ar & shared_font_loaded;
ar & shared_font_relocated;
ar & lock;
ar & cpu_percent;
ar & unknown_ns_state_field;
ar & screen_capture_buffer;
ar & screen_capture_post_permission;
ar & applet_manager;
void Module::serialize(Archive& ar, const unsigned int) {
ar& shared_font_mem;
ar& shared_font_loaded;
ar& shared_font_relocated;
ar& lock;
ar& cpu_percent;
ar& unknown_ns_state_field;
ar& screen_capture_buffer;
ar& screen_capture_post_permission;
ar& applet_manager;
}
SERIALIZE_IMPL(Module)

14
src/core/hle/service/apt/apt.h
View file

@ -12,10 +12,9 @@
#include "common/common_funcs.h"
#include "common/common_types.h"
#include "common/swap.h"
#include "core/hle/kernel/kernel.h"
#include "core/hle/service/apt/applet_manager.h"
#include "core/hle/service/service.h"
#include "core/global.h"
#include "core/hle/kernel/kernel.h"
#include "core/hle/service/service.h"
namespace Core {
class System;
@ -612,9 +611,8 @@ public:
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & application_reset_prepared;
void serialize(Archive& ar, const unsigned int) {
ar& application_reset_prepared;
}
friend class boost::serialization::access;
};
@ -654,6 +652,6 @@ void InstallInterfaces(Core::System& system);
} // namespace Service::APT
namespace boost::serialization {
template <class Archive>
void load_construct_data(Archive& ar, Service::APT::Module* t, const unsigned int);
template <class Archive>
void load_construct_data(Archive& ar, Service::APT::Module* t, const unsigned int);
}

2
src/core/hle/service/apt/apt_a.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/apt/apt_a.h"
#include "common/archives.h"
#include "core/hle/service/apt/apt_a.h"
namespace Service::APT {

1
src/core/hle/service/apt/apt_a.h
View file

@ -11,6 +11,7 @@ namespace Service::APT {
class APT_A final : public Module::APTInterface {
public:
explicit APT_A(std::shared_ptr<Module> apt);
private:
SERVICE_SERIALIZATION(APT_A, apt, Module)
};

2
src/core/hle/service/apt/apt_s.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/apt/apt_s.h"
#include "common/archives.h"
#include "core/hle/service/apt/apt_s.h"
namespace Service::APT {

1
src/core/hle/service/apt/apt_s.h
View file

@ -18,6 +18,7 @@ namespace Service::APT {
class APT_S final : public Module::APTInterface {
public:
explicit APT_S(std::shared_ptr<Module> apt);
private:
SERVICE_SERIALIZATION(APT_S, apt, Module)
};

2
src/core/hle/service/apt/apt_u.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/apt/apt_u.h"
#include "common/archives.h"
#include "core/hle/service/apt/apt_u.h"
namespace Service::APT {

1
src/core/hle/service/apt/apt_u.h
View file

@ -18,6 +18,7 @@ namespace Service::APT {
class APT_U final : public Module::APTInterface {
public:
explicit APT_U(std::shared_ptr<Module> apt);
private:
SERVICE_SERIALIZATION(APT_U, apt, Module)
};

2
src/core/hle/service/apt/ns_s.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/apt/ns_s.h"
#include "common/archives.h"
#include "core/hle/service/apt/ns_s.h"
namespace Service::NS {

1
src/core/hle/service/apt/ns_s.h
View file

@ -14,6 +14,7 @@ namespace Service::NS {
class NS_S final : public Service::APT::Module::NSInterface {
public:
explicit NS_S(std::shared_ptr<Service::APT::Module> apt);
private:
SERVICE_SERIALIZATION(NS_S, apt, Service::APT::Module)
};

27
src/core/hle/service/boss/boss.h
View file

@ -6,9 +6,9 @@
#include <memory>
#include <boost/serialization/shared_ptr.hpp>
#include "core/global.h"
#include "core/hle/kernel/event.h"
#include "core/hle/service/service.h"
#include "core/global.h"
namespace Core {
class System;
@ -964,12 +964,11 @@ public:
u8 output_flag;
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & new_arrival_flag;
ar & ns_data_new_flag;
ar & ns_data_new_flag_privileged;
ar & output_flag;
void serialize(Archive& ar, const unsigned int) {
ar& new_arrival_flag;
ar& ns_data_new_flag;
ar& ns_data_new_flag_privileged;
ar& output_flag;
}
friend class boost::serialization::access;
};
@ -978,9 +977,8 @@ private:
std::shared_ptr<Kernel::Event> task_finish_event;
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & task_finish_event;
void serialize(Archive& ar, const unsigned int) {
ar& task_finish_event;
}
friend class boost::serialization::access;
};
@ -990,9 +988,8 @@ void InstallInterfaces(Core::System& system);
} // namespace Service::BOSS
namespace boost::serialization {
template <class Archive>
inline void load_construct_data(Archive& ar, Service::BOSS::Module* t, const unsigned int)
{
::new(t)Service::BOSS::Module(Core::Global<Core::System>());
}
template <class Archive>
inline void load_construct_data(Archive& ar, Service::BOSS::Module* t, const unsigned int) {
::new (t) Service::BOSS::Module(Core::Global<Core::System>());
}
} // namespace boost::serialization

2
src/core/hle/service/boss/boss_p.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/boss/boss_p.h"
#include "common/archives.h"
#include "core/hle/service/boss/boss_p.h"
namespace Service::BOSS {

2
src/core/hle/service/boss/boss_u.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/boss/boss_u.h"
#include "common/archives.h"
#include "core/hle/service/boss/boss_u.h"
namespace Service::BOSS {

9
src/core/hle/service/cam/cam.cpp
View file

@ -24,11 +24,10 @@
namespace Service::CAM {
template <class Archive>
void Module::serialize(Archive& ar, const unsigned int)
{
ar & cameras;
ar & ports;
ar & is_camera_reload_pending;
void Module::serialize(Archive& ar, const unsigned int) {
ar& cameras;
ar& ports;
ar& is_camera_reload_pending;
}
SERIALIZE_IMPL(Module)

87
src/core/hle/service/cam/cam.h
View file

@ -10,9 +10,9 @@
#include <vector>
#include "common/common_types.h"
#include "common/swap.h"
#include "core/global.h"
#include "core/hle/result.h"
#include "core/hle/service/service.h"
#include "core/global.h"
namespace Core {
class System;
@ -183,14 +183,13 @@ struct Resolution {
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & width;
ar & height;
ar & crop_x0;
ar & crop_y0;
ar & crop_x1;
ar & crop_y1;
void serialize(Archive& ar, const unsigned int) {
ar& width;
ar& height;
ar& crop_x0;
ar& crop_y0;
ar& crop_x1;
ar& crop_y1;
}
friend class boost::serialization::access;
};
@ -755,12 +754,11 @@ private:
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & flip;
ar & effect;
ar & format;
ar & resolution;
void serialize(Archive& ar, const unsigned int) {
ar& flip;
ar& effect;
ar& format;
ar& resolution;
}
friend class boost::serialization::access;
};
@ -773,12 +771,11 @@ private:
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & impl;
ar & contexts;
ar & current_context;
ar & frame_rate;
void serialize(Archive& ar, const unsigned int) {
ar& impl;
ar& contexts;
ar& current_context;
ar& frame_rate;
}
friend class boost::serialization::access;
};
@ -818,27 +815,26 @@ private:
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & camera_id;
ar & is_active;
ar & is_pending_receiving;
ar & is_busy;
ar & is_receiving;
ar & is_trimming;
ar & x0;
ar & y0;
ar & x1;
ar & y1;
ar & transfer_bytes;
ar & completion_event;
ar & buffer_error_interrupt_event;
ar & vsync_interrupt_event;
void serialize(Archive& ar, const unsigned int) {
ar& camera_id;
ar& is_active;
ar& is_pending_receiving;
ar& is_busy;
ar& is_receiving;
ar& is_trimming;
ar& x0;
ar& y0;
ar& x1;
ar& y1;
ar& transfer_bytes;
ar& completion_event;
ar& buffer_error_interrupt_event;
ar& vsync_interrupt_event;
// TODO: Check if this is ever needed:
//ar & capture_result;
ar & dest_process;
ar & dest;
ar & dest_size;
// ar & capture_result;
ar& dest_process;
ar& dest;
ar& dest_size;
}
friend class boost::serialization::access;
};
@ -864,9 +860,8 @@ void InstallInterfaces(Core::System& system);
} // namespace Service::CAM
namespace boost::serialization {
template <class Archive>
inline void load_construct_data(Archive& ar, Service::CAM::Module* t, const unsigned int)
{
::new(t)Service::CAM::Module(Core::Global<Core::System>());
}
template <class Archive>
inline void load_construct_data(Archive& ar, Service::CAM::Module* t, const unsigned int) {
::new (t) Service::CAM::Module(Core::Global<Core::System>());
}
} // namespace boost::serialization

2
src/core/hle/service/cam/cam_c.cpp
View file

@ -2,9 +2,9 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "common/archives.h"
#include "core/hle/service/cam/cam.h"
#include "core/hle/service/cam/cam_c.h"
#include "common/archives.h"
namespace Service::CAM {

2
src/core/hle/service/cam/cam_q.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/cam/cam_q.h"
#include "common/archives.h"
#include "core/hle/service/cam/cam_q.h"
namespace Service::CAM {

6
src/core/hle/service/cam/cam_q.h
View file

@ -11,11 +11,11 @@ namespace Service::CAM {
class CAM_Q : public ServiceFramework<CAM_Q> {
public:
CAM_Q();
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
void serialize(Archive& ar, const unsigned int) {
ar& boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
}
friend class boost::serialization::access;
};

2
src/core/hle/service/cam/cam_s.cpp
View file

@ -2,9 +2,9 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "common/archives.h"
#include "core/hle/service/cam/cam.h"
#include "core/hle/service/cam/cam_s.h"
#include "common/archives.h"
namespace Service::CAM {

2
src/core/hle/service/cam/cam_u.cpp
View file

@ -2,9 +2,9 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "common/archives.h"
#include "core/hle/service/cam/cam.h"
#include "core/hle/service/cam/cam_u.h"
#include "common/archives.h"
namespace Service::CAM {

69
src/core/hle/service/csnd/csnd_snd.h
View file

@ -38,10 +38,9 @@ struct AdpcmState {
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & predictor;
ar & step_index;
void serialize(Archive& ar, const unsigned int) {
ar& predictor;
ar& step_index;
}
friend class boost::serialization::access;
};
@ -66,24 +65,23 @@ struct Channel {
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & block1_address;
ar & block2_address;
ar & block1_size;
ar & block2_size;
ar & block1_adpcm_state;
ar & block2_adpcm_state;
ar & block2_adpcm_reload;
ar & left_channel_volume;
ar & right_channel_volume;
ar & left_capture_volume;
ar & right_capture_volume;
ar & sample_rate;
ar & linear_interpolation;
ar & loop_mode;
ar & encoding;
ar & psg_duty;
void serialize(Archive& ar, const unsigned int) {
ar& block1_address;
ar& block2_address;
ar& block1_size;
ar& block2_size;
ar& block1_adpcm_state;
ar& block2_adpcm_state;
ar& block2_adpcm_reload;
ar& left_channel_volume;
ar& right_channel_volume;
ar& left_capture_volume;
ar& right_capture_volume;
ar& sample_rate;
ar& linear_interpolation;
ar& loop_mode;
ar& encoding;
ar& psg_duty;
}
friend class boost::serialization::access;
};
@ -258,18 +256,17 @@ private:
u32 acquired_channel_mask = 0;
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
ar & mutex;
ar & shared_memory;
ar & capture_units;
ar & channels;
ar & master_state_offset;
ar & channel_state_offset;
ar & capture_state_offset;
ar & type1_command_offset;
ar & acquired_channel_mask;
void serialize(Archive& ar, const unsigned int) {
ar& boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
ar& mutex;
ar& shared_memory;
ar& capture_units;
ar& channels;
ar& master_state_offset;
ar& channel_state_offset;
ar& capture_state_offset;
ar& type1_command_offset;
ar& acquired_channel_mask;
}
friend class boost::serialization::access;
};
@ -282,6 +279,6 @@ void InstallInterfaces(Core::System& system);
BOOST_CLASS_EXPORT_KEY(Service::CSND::CSND_SND)
namespace boost::serialization {
template <class Archive>
void load_construct_data(Archive& ar, Service::CSND::CSND_SND* t, const unsigned int);
template <class Archive>
void load_construct_data(Archive& ar, Service::CSND::CSND_SND* t, const unsigned int);
}

2
src/core/hle/service/dlp/dlp_clnt.cpp
View file

@ -2,9 +2,9 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "common/archives.h"
#include "core/hle/ipc_helpers.h"
#include "core/hle/service/dlp/dlp_clnt.h"
#include "common/archives.h"
SERIALIZE_EXPORT_IMPL(Service::DLP::DLP_CLNT)

6
src/core/hle/service/dlp/dlp_clnt.h
View file

@ -12,11 +12,11 @@ class DLP_CLNT final : public ServiceFramework<DLP_CLNT> {
public:
DLP_CLNT();
~DLP_CLNT() = default;
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
void serialize(Archive& ar, const unsigned int) {
ar& boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
}
friend class boost::serialization::access;
};

2
src/core/hle/service/dlp/dlp_fkcl.cpp
View file

@ -2,9 +2,9 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "common/archives.h"
#include "core/hle/ipc_helpers.h"
#include "core/hle/service/dlp/dlp_fkcl.h"
#include "common/archives.h"
SERIALIZE_EXPORT_IMPL(Service::DLP::DLP_FKCL)

6
src/core/hle/service/dlp/dlp_fkcl.h
View file

@ -12,11 +12,11 @@ class DLP_FKCL final : public ServiceFramework<DLP_FKCL> {
public:
DLP_FKCL();
~DLP_FKCL() = default;
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
void serialize(Archive& ar, const unsigned int) {
ar& boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
}
friend class boost::serialization::access;
};

2
src/core/hle/service/dlp/dlp_srvr.cpp
View file

@ -2,12 +2,12 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "common/archives.h"
#include "common/common_types.h"
#include "common/logging/log.h"
#include "core/hle/ipc_helpers.h"
#include "core/hle/result.h"
#include "core/hle/service/dlp/dlp_srvr.h"
#include "common/archives.h"
SERIALIZE_EXPORT_IMPL(Service::DLP::DLP_SRVR)

5
src/core/hle/service/dlp/dlp_srvr.h
View file

@ -17,9 +17,8 @@ private:
void IsChild(Kernel::HLERequestContext& ctx);
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
void serialize(Archive& ar, const unsigned int) {
ar& boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
}
friend class boost::serialization::access;
};

19
src/core/hle/service/dsp/dsp_dsp.h
View file

@ -266,14 +266,13 @@ private:
std::array<std::shared_ptr<Kernel::Event>, AudioCore::num_dsp_pipe> pipes = {{}};
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
ar & semaphore_event;
ar & preset_semaphore;
ar & interrupt_zero;
ar & interrupt_one;
ar & pipes;
void serialize(Archive& ar, const unsigned int) {
ar& boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
ar& semaphore_event;
ar& preset_semaphore;
ar& interrupt_zero;
ar& interrupt_one;
ar& pipes;
}
friend class boost::serialization::access;
};
@ -285,6 +284,6 @@ void InstallInterfaces(Core::System& system);
BOOST_CLASS_EXPORT_KEY(Service::DSP::DSP_DSP)
namespace boost::serialization {
template <class Archive>
void load_construct_data(Archive& ar, Service::DSP::DSP_DSP* t, const unsigned int);
template <class Archive>
void load_construct_data(Archive& ar, Service::DSP::DSP_DSP* t, const unsigned int);
}

15
src/core/hle/service/err_f.cpp
View file

@ -20,16 +20,15 @@
SERIALIZE_EXPORT_IMPL(Service::ERR::ERR_F)
namespace boost::serialization {
template <class Archive>
void load_construct_data(Archive& ar, Service::ERR::ERR_F* t, const unsigned int)
{
::new(t)Service::ERR::ERR_F(Core::Global<Core::System>());
}
template
void load_construct_data<iarchive>(iarchive& ar, Service::ERR::ERR_F* t, const unsigned int);
template <class Archive>
void load_construct_data(Archive& ar, Service::ERR::ERR_F* t, const unsigned int) {
::new (t) Service::ERR::ERR_F(Core::Global<Core::System>());
}
template void load_construct_data<iarchive>(iarchive& ar, Service::ERR::ERR_F* t,
const unsigned int);
} // namespace boost::serialization
namespace Service::ERR {
enum class FatalErrType : u32 {

9
src/core/hle/service/err_f.h
View file

@ -36,9 +36,8 @@ private:
Core::System& system;
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
void serialize(Archive& ar, const unsigned int) {
ar& boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
}
friend class boost::serialization::access;
};
@ -50,6 +49,6 @@ void InstallInterfaces(Core::System& system);
BOOST_CLASS_EXPORT_KEY(Service::ERR::ERR_F)
namespace boost::serialization {
template <class Archive>
void load_construct_data(Archive& ar, Service::ERR::ERR_F* t, const unsigned int);
template <class Archive>
void load_construct_data(Archive& ar, Service::ERR::ERR_F* t, const unsigned int);
}

21
src/core/hle/service/frd/frd.h
View file

@ -21,11 +21,10 @@ struct FriendKey {
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & friend_id;
ar & unknown;
ar & friend_code;
void serialize(Archive& ar, const unsigned int) {
ar& friend_id;
ar& unknown;
ar& friend_code;
}
friend class boost::serialization::access;
};
@ -35,9 +34,8 @@ struct MyPresence {
private:
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & unknown;
void serialize(Archive& ar, const unsigned int) {
ar& unknown;
}
friend class boost::serialization::access;
};
@ -157,10 +155,9 @@ private:
MyPresence my_presence = {};
template <class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & my_friend_key;
ar & my_presence;
void serialize(Archive& ar, const unsigned int) {
ar& my_friend_key;
ar& my_presence;
}
friend class boost::serialization::access;
};

2
src/core/hle/service/frd/frd_a.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/frd/frd_a.h"
#include "common/archives.h"
#include "core/hle/service/frd/frd_a.h"
SERIALIZE_EXPORT_IMPL(Service::FRD::FRD_A)

1
src/core/hle/service/frd/frd_a.h
View file

@ -11,6 +11,7 @@ namespace Service::FRD {
class FRD_A final : public Module::Interface {
public:
explicit FRD_A(std::shared_ptr<Module> frd);
private:
SERVICE_SERIALIZATION(FRD_A, frd, Module)
};

2
src/core/hle/service/frd/frd_u.cpp
View file

@ -2,8 +2,8 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/hle/service/frd/frd_u.h"
#include "common/archives.h"
#include "core/hle/service/frd/frd_u.h"
SERIALIZE_EXPORT_IMPL(Service::FRD::FRD_U)

1
src/core/hle/service/frd/frd_u.h
View file

@ -11,6 +11,7 @@ namespace Service::FRD {
class FRD_U final : public Module::Interface {
public:
explicit FRD_U(std::shared_ptr<Module> frd);
private:
SERVICE_SERIALIZATION(FRD_U, frd, Module)
};

Some files were not shown because too many files have changed in this diff Show more