Avoids unwanted implicit conversions. Thankfully, given the large amount
of cleanup in past PRs, only this tiny amount is left over to cover.

This is already declared in apm/apm.h

The pointed to thread's members are simply observed in this case, so we
don't need to copy it here.

* Regression and Mode Fixes

* Review Fixes

* string_view correction

* Add operator& for FileSys::Mode

* Return std::string from SanitizePath

* Farming Simulator Fix

* Use != With mode operator&

These aren't used externally at all, so they can be made private.

Uses the same type aliases we use for virtual addresses, and converts
one lingering usage of std::array<uint64_t, 2> to u128 for consistency.

Avoids copying a std::string instance and avoids unnecessary atomic
reference count incrementing and decrementing.

RealVfsFile inherits from VfsFile, the instance from std::make_shared is
already compatible with the function argument type, making the copy
constructor call unnecessary.

is_jump_relocation is never used within the function, so we can just
remove it.

It's sufficient to use a forward declaration instead of a direct
inclusion here.

Makes the code more uniform, and also braces cases where the body of an
unbraced conditional travels more than one line.

Makes it consistent with the other Apploader constructors, and prevents
implicit conversions.

This isn't used anywhere in the header.

It's undefined behavior to memcpy an object that isn't considered
trivially copyable, so put a compile-time check in to make sure this
doesn't occur.

Allows avoiding unnecessary copies of the vector depending on the
calling code.

While we're at it, remove a redundant no-parameter base constructor call

This is just an unused hold-over from citra, so we can get rid of this
to trim off an exposed global, among other things.

This is a holdover from citra that's essentially unused.

Forgot to include this in 22f448b6

Cleanup

Review fixes

This just returns the size of the language code buffer.

The return code should be 32-bit in size.

ReplaceFileWithSubdirectory() takes a VirtualFile and a VirtualDir, but
it was being passed a string as one of its arguments. The only reason
this never caused issues is because this template isn't instantiated
anywhere yet.

This corrects an issue before it occurs.

Avoids unnecessary construction of std::string instances where
applicable.

This avoids a truncating cast on size. I doubt we'd ever traverse a
directory this large, however we also shouldn't truncate sizes away.

This behaves quite similarly to the SubmitGPFIFO command. Referenced from Ryujinx.
Many thanks to @gdkchan for investigating this!

Instead of using an unsigned int as a parameter and expecting a user to
always pass in the correct values, we can just convert the enum into an
enum class and use that type as the parameter type instead, which makes
the interface more type safe.

We also get rid of the bookkeeping "NUM_" element in the enum by just
using an unordered map. This function is generally low-frequency in
terms of calls (and I'd hope so, considering otherwise would mean we're
slamming the disk with IO all the time) so I'd consider this acceptable
in this case.

Given we're already constructing the error code, we don't need to call
the constructor inside of it.

We already return by value, so we don't explicitly need to make the
copy.

Avoids unnecessary atomic increment and decrement operations.

This is a little bit more self-documenting on what is being done here.

We can simply use std::clamp() here, instead of using an equivalent
with std::max() and std::min().

Given the data is intended to be directly written, there's no need to
take the std::vector by value and copy the data.

Provides the same behavior, but with less writing

vfs: Amend constness on pointers in WriteBytes() and WriteArrays() member functions to be const qualified

These functions don't modify the data being pointed to, so these can be
pointers to const data

Note that there's currently a dynarmic bug preventing this register from being written.