mika/Atmosphere-libs
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere-libs.git synced 2025-06-28 14:02:40 +02:00
Code Issues Packages Projects Releases Wiki Activity

Modernize C++ usage (#144)

Browse Source 
* Stratosphere: Use modern C++ idioms in some places

* algorithms like std::for_each are used instead of raw loops

* Stratosphere: Replace more raw loops with algorithms

* Stratosphere: Add a utility predicate function to test for equality with a reference element

This can be used to rewrite some common raw loops using algorithms instead

* fs.mitm: Use variant

* fs.mitm: Use enum class

* fs.mitm: Turn RomFSSourceInfo::Cleanup into a destructor

This obsoletes the need for a custom deleter in other places

* fs.mitm: Use enum class some more

* fs.mitm: Use unique_ptr

* fs.mitm: Simplify initialization

* Stratosphere: Simplify initialization

* fs.mitm: Use unique_ptr (fix memory leak along the way)

The previous code was using "delete" rather than "delete[]"

* fs.mitm: Use vector::emplace_back rather than push_back

emplace_back constructs elements in-place, hence avoiding a redundant element copy.

* Stratosphere: Replace more raw loops with algorithms

* Stratosphere: Use unique_ptr

* fs.mitm: Replace more raw loops with algorithms

* Stratosphere: Prefer move-construction over copy-construction when moving sink parameters around
This commit is contained in:
Tony Wasserka 2018-06-19 18:07:31 +00:00 committed by SciresM
parent 51edf0fde9
commit 1b356cd4f2
10 changed files with 102 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
include/meta_tools.hpp Normal file
View File

@ -0,0 +1,37 @@
#pragma once
#include <functional>
namespace detail {
template<typename T>
struct class_of;
template<typename Ret, typename C>
struct class_of<Ret C::*> {
using type = C;
};
template<typename T>
using class_of_t = typename class_of<T>::type;
template<typename Mem, typename T, typename C = class_of_t<Mem>>
struct member_equals_fn_helper {
T ref;
Mem mem_fn;
bool operator()(const C& val) const {
return (std::mem_fn(mem_fn)(val) == ref);
}
bool operator()(C&& val) const {
return (std::mem_fn(mem_fn)(std::move(val)) == ref);
}
};
} // namespace detail
template<typename Mem, typename T>
auto member_equals_fn(Mem mem, T ref) {
return detail::member_equals_fn_helper<Mem, T>{std::move(ref), std::move(mem)};
}

48
include/stratosphere/domainowner.hpp
View File

@ -1,5 +1,6 @@
#pragma once
#include <switch.h>
#include <algorithm>
#include <memory>
#include <type_traits>
@ -11,17 +12,12 @@ class IServiceObject;
class DomainOwner {
private:
std::shared_ptr<IServiceObject> domain_objects[DOMAIN_ID_MAX];
std::array<std::shared_ptr<IServiceObject>, DOMAIN_ID_MAX> domain_objects;
public:
DomainOwner() {
for (unsigned int i = 0; i < DOMAIN_ID_MAX; i++) {
domain_objects[i].reset();
}
}
DomainOwner() = default;
virtual ~DomainOwner() {
/* Shared ptrs should auto delete here. */
}
virtual ~DomainOwner() = default;
std::shared_ptr<IServiceObject> get_domain_object(unsigned int i) {
if (i < DOMAIN_ID_MAX) {
@ -31,20 +27,20 @@ class DomainOwner {
}
Result reserve_object(std::shared_ptr<IServiceObject> object, unsigned int *out_i) {
for (unsigned int i = 4; i < DOMAIN_ID_MAX; i++) {
if (domain_objects[i] == NULL) {
domain_objects[i] = object;
object->set_owner(this);
*out_i = i;
return 0;
}
}
auto object_it = std::find(domain_objects.begin() + 4, domain_objects.end(), nullptr);
if (object_it == domain_objects.end()) {
return 0x1900B;
}
*out_i = std::distance(domain_objects.begin(), object_it);
*object_it = std::move(object);
(*object_it)->set_owner(this);
return 0;
}
Result set_object(std::shared_ptr<IServiceObject> object, unsigned int i) {
if (domain_objects[i] == NULL) {
domain_objects[i] = object;
domain_objects[i] = std::move(object);
object->set_owner(this);
return 0;
}
@ -52,26 +48,18 @@ class DomainOwner {
}
unsigned int get_object_id(std::shared_ptr<IServiceObject> object) {
for (unsigned int i = 0; i < DOMAIN_ID_MAX; i++) {
if (domain_objects[i] == object) {
return i;
}
}
return DOMAIN_ID_MAX;
auto object_it = std::find(domain_objects.begin(), domain_objects.end(), object);
return std::distance(domain_objects.begin(), object_it);
}
void delete_object(unsigned int i) {
if (domain_objects[i]) {
domain_objects[i].reset();
}
}
void delete_object(std::shared_ptr<IServiceObject> object) {
for (unsigned int i = 0; i < DOMAIN_ID_MAX; i++) {
if (domain_objects[i] == object) {
domain_objects[i].reset();
break;
}
auto object_it = std::find(domain_objects.begin(), domain_objects.end(), object);
if (object_it != domain_objects.end()) {
object_it->reset();
}
}
};

5
include/stratosphere/ievent.hpp
View File

@ -1,5 +1,6 @@
#pragma once
#include <switch.h>
#include <algorithm>
#include <vector>
#include "iwaitable.hpp"
@ -22,9 +23,7 @@ class IEvent : public IWaitable {
}
~IEvent() {
for (auto &h : this->handles) {
svcCloseHandle(h);
}
std::for_each(handles.begin(), handles.end(), svcCloseHandle);
}
virtual Result signal_event() = 0;

8
include/stratosphere/ipcsession.hpp
View File

@ -18,9 +18,7 @@ class IPCSession final : public ISession<T> {
fatalSimple(rc);
}
this->service_object = std::make_shared<T>();
this->pointer_buffer_size = pbs;
this->pointer_buffer = new char[this->pointer_buffer_size];
this->is_domain = false;
this->pointer_buffer.resize(pbs);
}
IPCSession<T>(std::shared_ptr<T> so, size_t pbs = 0x400) : ISession<T>(NULL, 0, 0, so, 0) {
@ -28,8 +26,6 @@ class IPCSession final : public ISession<T> {
if (R_FAILED((rc = svcCreateSession(&this->server_handle, &this->client_handle, 0, 0)))) {
fatalSimple(rc);
}
this->pointer_buffer_size = pbs;
this->pointer_buffer = new char[this->pointer_buffer_size];
this->is_domain = false;
this->pointer_buffer.resize(pbs);
}
};

1
include/stratosphere/iserver.hpp
View File

@ -1,5 +1,6 @@
#pragma once
#include <switch.h>
#include <algorithm>
#include <type_traits>
#include "iserviceobject.hpp"

41
include/stratosphere/isession.hpp
View File

@ -17,7 +17,6 @@ enum IpcControlCommand {
IpcCtrl_Cmd_CloneCurrentObjectEx = 4
};
#define POINTER_BUFFER_SIZE_MAX 0xFFFF
#define RESULT_DEFER_SESSION (0x6580A)
@ -34,39 +33,23 @@ class ISession : public IWaitable {
IServer<T> *server;
Handle server_handle;
Handle client_handle;
char *pointer_buffer;
size_t pointer_buffer_size;
std::vector<char> pointer_buffer;
bool is_domain;
bool is_domain = false;
std::shared_ptr<DomainOwner> domain;
std::shared_ptr<IServiceObject> active_object;
static_assert(sizeof(pointer_buffer) <= POINTER_BUFFER_SIZE_MAX, "Incorrect Size for PointerBuffer!");
public:
ISession<T>(IServer<T> *s, Handle s_h, Handle c_h, size_t pbs = 0x400) : server(s), server_handle(s_h), client_handle(c_h), pointer_buffer_size(pbs) {
ISession<T>(IServer<T> *s, Handle s_h, Handle c_h, size_t pbs = 0x400) : server(s), server_handle(s_h), client_handle(c_h), pointer_buffer(pbs) {
this->service_object = std::make_shared<T>();
if (this->pointer_buffer_size) {
this->pointer_buffer = new char[this->pointer_buffer_size];
}
this->is_domain = false;
this->domain.reset();
this->active_object.reset();
}
ISession<T>(IServer<T> *s, Handle s_h, Handle c_h, std::shared_ptr<T> so, size_t pbs = 0x400) : service_object(so), server(s), server_handle(s_h), client_handle(c_h), pointer_buffer_size(pbs) {
if (this->pointer_buffer_size) {
this->pointer_buffer = new char[this->pointer_buffer_size];
}
this->is_domain = false;
this->domain.reset();
this->active_object.reset();
ISession<T>(IServer<T> *s, Handle s_h, Handle c_h, std::shared_ptr<T> so, size_t pbs = 0x400) : service_object(so), server(s), server_handle(s_h), client_handle(c_h), pointer_buffer(pbs) {
}
~ISession() override {
delete this->pointer_buffer;
if (server_handle) {
svcCloseHandle(server_handle);
}
@ -153,7 +136,7 @@ class ISession : public IWaitable {
break;
case IpcCommandType_Request:
case IpcCommandType_RequestWithContext:
retval = this->active_object->dispatch(r, c, cmd_id, (u8 *)this->pointer_buffer, this->pointer_buffer_size);
retval = this->active_object->dispatch(r, c, cmd_id, (u8 *)pointer_buffer.data(), pointer_buffer.size());
break;
case IpcCommandType_Control:
case IpcCommandType_ControlWithContext:
@ -185,7 +168,7 @@ class ISession : public IWaitable {
/* Prepare pointer buffer... */
IpcCommand c_for_reply;
ipcInitialize(&c_for_reply);
ipcAddRecvStatic(&c_for_reply, this->pointer_buffer, this->pointer_buffer_size, 0);
ipcAddRecvStatic(&c_for_reply, this->pointer_buffer.data(), this->pointer_buffer.size(), 0);
ipcPrepareHeader(&c_for_reply, 0);
if (R_SUCCEEDED(rc = svcReplyAndReceive(&handle_index, &this->server_handle, 1, 0, U64_MAX))) {
@ -247,19 +230,19 @@ class ISession : public IWaitable {
/* TODO: Implement. */
switch ((IpcControlCommand)cmd_id) {
case IpcCtrl_Cmd_ConvertCurrentObjectToDomain:
rc = WrapIpcCommandImpl<&ISession::ConvertCurrentObjectToDomain>(this, r, out_c, (u8 *)this->pointer_buffer, this->pointer_buffer_size);
rc = WrapIpcCommandImpl<&ISession::ConvertCurrentObjectToDomain>(this, r, out_c, (u8 *)this->pointer_buffer.data(), pointer_buffer.size());
break;
case IpcCtrl_Cmd_CopyFromCurrentDomain:
rc = WrapIpcCommandImpl<&ISession::CopyFromCurrentDomain>(this, r, out_c, (u8 *)this->pointer_buffer, this->pointer_buffer_size);
rc = WrapIpcCommandImpl<&ISession::CopyFromCurrentDomain>(this, r, out_c, (u8 *)this->pointer_buffer.data(), pointer_buffer.size());
break;
case IpcCtrl_Cmd_CloneCurrentObject:
rc = WrapIpcCommandImpl<&ISession::CloneCurrentObject>(this, r, out_c, (u8 *)this->pointer_buffer, this->pointer_buffer_size);
rc = WrapIpcCommandImpl<&ISession::CloneCurrentObject>(this, r, out_c, (u8 *)this->pointer_buffer.data(), pointer_buffer.size());
break;
case IpcCtrl_Cmd_QueryPointerBufferSize:
rc = WrapIpcCommandImpl<&ISession::QueryPointerBufferSize>(this, r, out_c, (u8 *)this->pointer_buffer, this->pointer_buffer_size);
rc = WrapIpcCommandImpl<&ISession::QueryPointerBufferSize>(this, r, out_c, (u8 *)this->pointer_buffer.data(), pointer_buffer.size());
break;
case IpcCtrl_Cmd_CloneCurrentObjectEx:
rc = WrapIpcCommandImpl<&ISession::CloneCurrentObjectEx>(this, r, out_c, (u8 *)this->pointer_buffer, sizeof(this->pointer_buffer));
rc = WrapIpcCommandImpl<&ISession::CloneCurrentObjectEx>(this, r, out_c, (u8 *)this->pointer_buffer.data(), pointer_buffer.size());
break;
default:
break;
@ -282,7 +265,7 @@ class ISession : public IWaitable {
return {0xF601};
}
std::tuple<Result, u32> QueryPointerBufferSize() {
return {0x0, (u32)this->pointer_buffer_size};
return {0x0, (u32)this->pointer_buffer.size()};
}
std::tuple<Result> CloneCurrentObjectEx() {
/* TODO */

13
include/stratosphere/waitablemanager.hpp
View File

@ -1,5 +1,7 @@
#pragma once
#include <switch.h>
#include <algorithm>
#include <memory>
#include <vector>
#include "waitablemanagerbase.hpp"
@ -12,19 +14,16 @@ class WaitableManager : public WaitableManagerBase {
protected:
std::vector<IWaitable *> to_add_waitables;
std::vector<IWaitable *> waitables;
u64 timeout;
u64 timeout = 0;
HosMutex lock;
std::atomic_bool has_new_items;
std::atomic_bool has_new_items = false;
private:
void process_internal(bool break_on_timeout);
public:
WaitableManager(u64 t) : waitables(0), timeout(t), has_new_items(false) { }
WaitableManager(u64 t) : timeout(t) { }
~WaitableManager() override {
/* This should call the destructor for every waitable. */
for (auto & waitable : waitables) {
delete waitable;
}
waitables.clear();
std::for_each(waitables.begin(), waitables.end(), std::default_delete<IWaitable>{});
}
virtual void add_waitable(IWaitable *waitable);

6
include/stratosphere/waitablemanagerbase.hpp
View File

@ -4,10 +4,10 @@
#include <vector>
class WaitableManagerBase {
std::atomic<u64> cur_priority;
std::atomic<u64> cur_priority = 0;
public:
WaitableManagerBase() : cur_priority(0) { }
virtual ~WaitableManagerBase() { }
WaitableManagerBase() = default;
virtual ~WaitableManagerBase() = default;
u64 get_priority() {
return std::atomic_fetch_add(&cur_priority, (u64)1);

13
source/multithreadedwaitablemanager.cpp
View File

@ -1,6 +1,7 @@
#include <switch.h>
#include <algorithm>
#include <functional>
#include <stratosphere/multithreadedwaitablemanager.hpp>
@ -44,21 +45,15 @@ IWaitable *MultiThreadedWaitableManager::get_waitable() {
rc = svcWaitSynchronization(&handle_index, handles.data(), this->waitables.size(), this->timeout);
IWaitable *w = this->waitables[handle_index];
if (R_SUCCEEDED(rc)) {
for (int i = 0; i < handle_index; i++) {
this->waitables[i]->update_priority();
}
std::for_each(waitables.begin(), waitables.begin() + handle_index, std::mem_fn(&IWaitable::update_priority));
this->waitables.erase(this->waitables.begin() + handle_index);
} else if (rc == 0xEA01) {
/* Timeout. */
for (auto & waitable : this->waitables) {
waitable->update_priority();
}
std::for_each(waitables.begin(), waitables.end(), std::mem_fn(&IWaitable::update_priority));
} else if (rc != 0xF601 && rc != 0xE401) {
/* TODO: Panic. When can this happen? */
} else {
for (int i = 0; i < handle_index; i++) {
this->waitables[i]->update_priority();
}
std::for_each(waitables.begin(), waitables.begin() + handle_index, std::mem_fn(&IWaitable::update_priority));
this->waitables.erase(this->waitables.begin() + handle_index);
delete w;
}

13
source/waitablemanager.cpp
View File

@ -1,6 +1,7 @@
#include <switch.h>
#include <algorithm>
#include <functional>
#include <stratosphere/waitablemanager.hpp>
@ -43,14 +44,10 @@ void WaitableManager::process_internal(bool break_on_timeout) {
rc = this->waitables[handle_index]->handle_signaled(0);
for (int i = 0; i < handle_index; i++) {
this->waitables[i]->update_priority();
}
std::for_each(waitables.begin(), waitables.begin() + handle_index, std::mem_fn(&IWaitable::update_priority));
} else if (rc == 0xEA01) {
/* Timeout. */
for (auto & waitable : this->waitables) {
waitable->update_priority();
}
std::for_each(waitables.begin(), waitables.end(), std::mem_fn(&IWaitable::update_priority));
if (break_on_timeout) {
return;
}
@ -72,9 +69,7 @@ void WaitableManager::process_internal(bool break_on_timeout) {
/* Delete it. */
delete to_delete;
for (int i = 0; i < handle_index; i++) {
this->waitables[i]->update_priority();
}
std::for_each(waitables.begin(), waitables.begin() + handle_index, std::mem_fn(&IWaitable::update_priority));
}
/* Do deferred callback for each waitable. */