Previously this would fall through and return successfully, despite
being an out of bounds read or write.

Renames the members to more accurately indicate what they signify.
"OneShot" and "Sticky" are kind of ambiguous identifiers for the reset
types, and can be kind of misleading. Automatic and Manual communicate
the kind of reset type in a clearer manner. Either the event is
automatically reset, or it isn't and must be manually cleared.

The "OneShot" and "Sticky" terminology is just a hold-over from Citra
where the kernel had a third type of event reset type known as "Pulse".
Given the Switch kernel only has two forms of event reset types, we
don't need to keep the old terminology around anymore.

Updates function tables based off information from SwitchBrew.

In several places, we have request parsers where there's nothing to
really parse, simply because the HLE function in question operates on
buffers. In these cases we can just remove these instances altogether.

In the other cases, we can retrieve the relevant members from the parser
and at least log them out, giving them some use.

For whatever reason, shared memory was being used here instead of
transfer memory, which (quite clearly) will not work based off the name
of the function.

This corrects this wonky usage of shared memory.

These functions act in tandem similar to how a lock or mutex require a
balanced lock()/unlock() sequence.

EnterFatalSection simply increments a counter for how many times it has
been called, while LeaveFatalSection ensures that a previous call to
EnterFatalSection has occured. If a previous call has occurred (the
counter is not zero), then the counter gets decremented as one would
expect. If a previous call has not occurred (the counter is zero), then
an error code is returned.

Makes the declaration order of the handling functions consistent with
the handler table itself.

We already have the service related stuff set up for this, however, it's
missing the function table.

All this does is supply a new volume level and a fade time in
nanoseconds for the volume transition to occur within.

Like the other volume setter, this mainly just sets a data member within
the service, nothing too special.

This function passes in the desired main applet and library applet
volume levels. We can then just pass those values back within the
relevant volume getter functions, allowing us to unstub those as well.

The initial values for the library and main applet volumes differ. The
main applet volume is 0.25 by default, while the library applet volume
is initialized to 1.0 by default in the services themselves.

Converts many of the Find* functions to return a std::optional<T> as
opposed to returning the raw return values directly. This allows
removing a few assertions and handles error cases like the service
itself does.

When we have no messages, we should be returning an error code.

These functions come in a pair and are needed by Smash Ultimate, Minecraft, and Skyrim, amongst others.

This is supposed to return the current process' ID. (0 indicates an
invalid ID for both process IDs and ARU IDs).

This was causing some games (most notably Pokemon Quest) to softlock due to an event being fired when not supposed to. This also removes a hack wherein we were firing the state changed event when the game retrieves it, which is incorrect.

Changed logging to be "Log before execution", Added more error logging, all services should now log on some level

The interface for shared memory was changed, but another commit was
merged that relied on the (previously public) internals of SharedMemory.

This amends that discrepancy.

The accessor should be doing just that, accessing, rather than retaining
the lifetime of the data broker as well.

This cleans up most of the callbacks and such in the Applets::Applet interface, while also properly implementing all four data channels.

a

Allows the game to verify and send a message to the frontend.

Allows use of software keyboard applet and future applets to be easily added by adding enum ID and a switch case.

Now starts the applet provided in constructor.