From aaf240c07093456c704dc18dfac5d4e4077309c8 Mon Sep 17 00:00:00 2001 From: Sour Date: Tue, 26 Jul 2022 23:36:38 -0400 Subject: [PATCH] Movies: Save/load settings and cheats, fixed bugs/crashes, fixed todos --- Core/Debugger/DebugBreakHelper.h | 2 +- Core/NES/APU/NesApu.cpp | 2 +- Core/NES/NesConsole.cpp | 12 +- Core/Netplay/GameClient.cpp | 2 +- Core/Shared/Emulator.cpp | 17 +- Core/Shared/Emulator.h | 1 + Core/Shared/MessageManager.cpp | 1 + Core/Shared/Movies/MesenMovie.cpp | 164 ++- Core/Shared/Movies/MesenMovie.h | 13 +- Core/Shared/Movies/MovieManager.cpp | 8 +- Core/Shared/Movies/MovieManager.h | 8 +- Core/Shared/Movies/MovieRecorder.cpp | 48 +- Core/Shared/Movies/MovieRecorder.h | 2 +- Core/Shared/Movies/MovieTypes.h | 34 - Core/Shared/SettingTypes.h | 1 - NewUI/ViewModels/MainMenuViewModel.cs | 7 +- NewUI/Windows/AboutWindow.axaml.cs | 5 +- Utilities/Serializer.cpp | 97 +- Utilities/Serializer.h | 71 +- Utilities/Utilities.vcxproj | 1 + Utilities/Utilities.vcxproj.filters | 1 + Utilities/magic_enum.hpp | 1378 +++++++++++++++++++++++++ Utilities/safe_ptr.h | 12 + 23 files changed, 1654 insertions(+), 233 deletions(-) create mode 100644 Utilities/magic_enum.hpp diff --git a/Core/Debugger/DebugBreakHelper.h b/Core/Debugger/DebugBreakHelper.h index 9d4d03ac..a148fd4d 100644 --- a/Core/Debugger/DebugBreakHelper.h +++ b/Core/Debugger/DebugBreakHelper.h @@ -14,7 +14,7 @@ public: { _debugger = debugger; - _needBreak = debugger->GetEmulator()->GetEmulationThreadId() != std::this_thread::get_id(); + _needBreak = !debugger->GetEmulator()->IsEmulationThread(); if(_needBreak) { //Only attempt to break if this is done in a thread other than the main emulation thread (and the debugger is active) diff --git a/Core/NES/APU/NesApu.cpp b/Core/NES/APU/NesApu.cpp index a3e19103..01fb247c 100644 --- a/Core/NES/APU/NesApu.cpp +++ b/Core/NES/APU/NesApu.cpp @@ -100,7 +100,7 @@ uint8_t NesApu::ReadRam(uint16_t addr) uint8_t NesApu::PeekRam(uint16_t addr) { - if(_console->GetEmulator()->GetEmulationThreadId() == std::this_thread::get_id()) { + if(_console->GetEmulator()->IsEmulationThread()) { //Only run the Apu (to catch up) if we're running this in the emulation thread (not 100% accurate, but we can't run the Apu from any other thread without locking) Run(); } diff --git a/Core/NES/NesConsole.cpp b/Core/NES/NesConsole.cpp index c8b48bf3..edde6c95 100644 --- a/Core/NES/NesConsole.cpp +++ b/Core/NES/NesConsole.cpp @@ -135,8 +135,8 @@ LoadRomResult NesConsole::LoadRom(VirtualFile& romFile) } } - //If in DB or a NES 2.0 file, auto-configure the inputs (if option is enabled) - if(GetNesConfig().AutoConfigureInput && (romData.Info.IsInDatabase || romData.Info.IsNes20Header) && romData.Info.InputType != GameInputType::Unspecified) { + if(GetNesConfig().AutoConfigureInput && romData.Info.InputType != GameInputType::Unspecified) { + //Auto-configure the inputs (if option is enabled) InitializeInputDevices(romData.Info.InputType, romData.Info.System); } @@ -152,14 +152,6 @@ LoadRomResult NesConsole::LoadRom(VirtualFile& romFile) _controlManager.reset(new NesControlManager(this)); } - /* - //Temporarely disable battery saves to prevent battery files from being created for the wrong game (for Battle Box & Turbo File) - _batteryManager->SetSaveEnabled(false); - */ - - //Re-enable battery saves - /*_batteryManager->SetSaveEnabled(true); - */ if(_hdData && (!_hdData->Tiles.empty() || !_hdData->Backgrounds.empty())) { _ppu.reset(new HdNesPpu(this, _hdData.get())); } else if(dynamic_cast(_mapper.get())) { diff --git a/Core/Netplay/GameClient.cpp b/Core/Netplay/GameClient.cpp index 0ac0b416..f22a4684 100644 --- a/Core/Netplay/GameClient.cpp +++ b/Core/Netplay/GameClient.cpp @@ -70,7 +70,7 @@ void GameClient::ProcessNotification(ConsoleNotificationType type, void* paramet { if(type == ConsoleNotificationType::GameLoaded && std::this_thread::get_id() != _clientThread->get_id() && - std::this_thread::get_id() != _emu->GetEmulationThreadId() + !_emu->IsEmulationThread() ) { //Disconnect if the client tried to manually load a game //A deadlock occurs if this is called from the emulation thread while a network message is being processed diff --git a/Core/Shared/Emulator.cpp b/Core/Shared/Emulator.cpp index 361530f3..3010c788 100644 --- a/Core/Shared/Emulator.cpp +++ b/Core/Shared/Emulator.cpp @@ -65,7 +65,6 @@ Emulator::Emulator() : _isRunAheadFrame = false; _lockCounter = 0; _threadPaused = false; - _lockCounter = 0; _debugRequestCount = 0; _allowDebuggerRequest = true; @@ -147,8 +146,6 @@ void Emulator::Run() } } - _movieManager->Stop(); - _emulationThreadId = thread::id(); if(_runLock.IsLockedByCurrentThread()) { @@ -283,6 +280,7 @@ void Emulator::Stop(bool sendNotification, bool preventRecentGameSave, bool save _notificationManager->SendNotification(ConsoleNotificationType::BeforeEmulationStop); } + _movieManager->Stop(); _videoDecoder->StopThread(); _videoRenderer->StopThread(); _rewindManager.reset(); @@ -330,7 +328,7 @@ void Emulator::PowerCycle() bool Emulator::LoadRom(VirtualFile romFile, VirtualFile patchFile, bool stopRom, bool forPowerCycle) { - if(GetEmulationThreadId() == std::this_thread::get_id()) { + if(IsEmulationThread()) { _threadPaused = true; } @@ -367,7 +365,11 @@ bool Emulator::LoadRom(VirtualFile romFile, VirtualFile patchFile, bool stopRom, //Make sure the battery is saved to disk before we load another game (or reload the same game) _console->SaveBattery(); } - + + if(!forPowerCycle) { + _movieManager->Stop(); + } + unique_ptr console; LoadRomResult result = LoadRomResult::UnknownType; TryLoadRom(romFile, result, console); @@ -1013,6 +1015,11 @@ thread::id Emulator::GetEmulationThreadId() return _emulationThreadId; } +bool Emulator::IsEmulationThread() +{ + return _emulationThreadId == std::this_thread::get_id(); +} + void Emulator::RegisterMemory(MemoryType type, void* memory, uint32_t size) { _consoleMemory[(int)type] = { memory, size }; diff --git a/Core/Shared/Emulator.h b/Core/Shared/Emulator.h index 49e44f52..6242d74d 100644 --- a/Core/Shared/Emulator.h +++ b/Core/Shared/Emulator.h @@ -226,6 +226,7 @@ public: bool IsDebugging(); thread::id GetEmulationThreadId(); + bool IsEmulationThread(); void RegisterMemory(MemoryType type, void* memory, uint32_t size); ConsoleMemoryInfo GetMemory(MemoryType type); diff --git a/Core/Shared/MessageManager.cpp b/Core/Shared/MessageManager.cpp index 1fdccbb3..f156e623 100644 --- a/Core/Shared/MessageManager.cpp +++ b/Core/Shared/MessageManager.cpp @@ -45,6 +45,7 @@ std::unordered_map MessageManager::_enResources = { { "Lag", u8"Lag" }, { "Mapper", u8"Mapper: %1, SubMapper: %2" }, { "MovieEnded", u8"Movie ended." }, + { "MovieStopped", u8"Movie stopped." }, { "MovieInvalid", u8"Invalid movie file." }, { "MovieMissingRom", u8"Missing ROM required (%1) to play movie." }, { "MovieNewerVersion", u8"Cannot load movies created by a more recent version of Mesen. Please download the latest version." }, diff --git a/Core/Shared/Movies/MesenMovie.cpp b/Core/Shared/Movies/MesenMovie.cpp index d8c6bc8b..f76f548b 100644 --- a/Core/Shared/Movies/MesenMovie.cpp +++ b/Core/Shared/Movies/MesenMovie.cpp @@ -15,6 +15,8 @@ #include "Utilities/StringUtilities.h" #include "Utilities/HexUtilities.h" #include "Utilities/VirtualFile.h" +#include "Utilities/magic_enum.hpp" +#include "Utilities/Serializer.h" MesenMovie::MesenMovie(Emulator* emu, bool forTest) { @@ -30,19 +32,30 @@ MesenMovie::~MesenMovie() void MesenMovie::Stop() { if(_playing) { + bool isEndOfMovie = _lastPollCounter >= _inputData.size(); + if(!_forTest) { - MessageManager::DisplayMessage("Movies", "MovieEnded"); + MessageManager::DisplayMessage("Movies", isEndOfMovie ? "MovieEnded" : "MovieStopped"); } - if(_emu->GetSettings()->GetPreferences().PauseOnMovieEnd) { - _emu->Pause(); - } + if(!_emu->IsEmulationThread()) { + EmuSettings* settings = _emu->GetSettings(); + if(isEndOfMovie && settings->GetPreferences().PauseOnMovieEnd) { + _emu->Pause(); + } + _emu->GetCheatManager()->SetCheats(_originalCheats); - _emu->GetCheatManager()->SetCheats(_originalCheats); + Serializer backup(0, false, false); + backup.LoadFrom(_emuSettingsBackup); + backup.Stream(*settings, "", -1); + } _playing = false; } - _emu->GetControlManager()->UnregisterInputProvider(this); + + if(_emu->GetControlManager()) { + _emu->GetControlManager()->UnregisterInputProvider(this); + } } bool MesenMovie::SetInput(BaseControlDevice *device) @@ -59,6 +72,7 @@ bool MesenMovie::SetInput(BaseControlDevice *device) _deviceIndex = 0; } } else { + //End of input data reached (movie end) _emu->GetMovieManager()->Stop(); } return true; @@ -114,40 +128,33 @@ bool MesenMovie::Play(VirtualFile &file) _deviceIndex = 0; - ParseSettings(settingsData); + auto emuLock = _emu->AcquireLock(); - _emu->Lock(); - - _emu->GetBatteryManager()->SetBatteryProvider(shared_from_this()); - _emu->GetNotificationManager()->RegisterNotificationListener(shared_from_this()); - ApplySettings(); + ParseSettings(settingsData); - //TODO - //Disable auto-configure input option (otherwise the movie file's input types are ignored) - //bool autoConfigureInput = _console->GetSettings()->CheckFlag(EmulationFlags::AutoConfigureInput); - //_console->GetSettings()->ClearFlags(EmulationFlags::AutoConfigureInput); - - BaseControlManager *controlManager = _emu->GetControlManager(); - if(controlManager) { - //ControlManager can be empty if no game is loaded - controlManager->SetPollCounter(0); + if(LoadInt(_settings, MovieKeys::MovieFormatVersion, 0) < 2) { + MessageManager::DisplayMessage("Movies", "MovieIncompatibleVersion"); + return false; } - //bool gameLoaded = LoadGame(); - //TODO - //_console->GetSettings()->SetFlagState(EmulationFlags::AutoConfigureInput, autoConfigureInput); - - /*if(!gameLoaded) { - _console->Unlock(); + if(!ApplySettings(settingsData)) { return false; - }*/ + } + + _emu->GetBatteryManager()->SetBatteryProvider(shared_from_this()); + _emu->GetNotificationManager()->RegisterNotificationListener(shared_from_this()); + + _emu->PowerCycle(); + + //Re-apply settings - power cycling can alter some (e.g auto-configure input types, etc.) + ApplySettings(settingsData); _originalCheats = _emu->GetCheatManager()->GetCheats(); - controlManager->UpdateControlDevices(); - if(!_forTest) { - _emu->PowerCycle(); - } else { + BaseControlManager *controlManager = _emu->GetControlManager(); + + if(_forTest) { + //TODO to validate test behavior controlManager->RegisterInputProvider(this); } @@ -156,17 +163,14 @@ bool MesenMovie::Play(VirtualFile &file) stringstream saveStateData; if(_reader->GetStream("SaveState.mss", saveStateData)) { if(!_emu->GetSaveStateManager()->LoadState(saveStateData, true)) { - _emu->Resume(); return false; - } else { - _emu->GetControlManager()->SetPollCounter(0); } } + controlManager->UpdateControlDevices(); + controlManager->SetPollCounter(0); _playing = true; - _emu->Unlock(); - return true; } @@ -203,66 +207,30 @@ void MesenMovie::ParseSettings(stringstream &data) } } -bool MesenMovie::LoadGame() -{ - /*string mesenVersion = LoadString(_settings, MovieKeys::MesenVersion); - string gameFile = LoadString(_settings, MovieKeys::GameFile); - string sha1Hash = LoadString(_settings, MovieKeys::Sha1); - //string patchFile = LoadString(_settings, MovieKeys::PatchFile); - //string patchFileSha1 = LoadString(_settings, MovieKeys::PatchFileSha1); - //string patchedRomSha1 = LoadString(_settings, MovieKeys::PatchedRomSha1); - - if(_console->GetSettings()->CheckFlag(EmulationFlags::AllowMismatchingSaveState) && _console->GetRomInfo().RomName == gameFile) { - //Loaded game has the right name, and we don't want to validate the hash values - _console->PowerCycle(); - return true; - } - - HashInfo hashInfo; - hashInfo.Sha1 = sha1Hash; - - VirtualFile romFile = _console->FindMatchingRom(gameFile, hashInfo); - bool gameLoaded = false; - if(romFile.IsValid()) { - VirtualFile patchFile(_movieFile.GetFilePath(), "PatchData.dat"); - if(patchFile.IsValid()) { - gameLoaded = _console->Initialize(romFile, patchFile); - } else { - gameLoaded = _console->Initialize(romFile); - } - } - - return gameLoaded;*/ - return true; -} - -void MesenMovie::ApplySettings() +bool MesenMovie::ApplySettings(istream& settingsData) { EmuSettings* settings = _emu->GetSettings(); - EmulationConfig emuConfig = settings->GetEmulationConfig(); + + settingsData.clear(); + settingsData.seekg(0, std::ios::beg); + Serializer s(0, false, true); + s.LoadFrom(settingsData); - //TODO - /*InputConfig inputConfig = settings->GetInputConfig(); + ConsoleType consoleType = {}; + s.Stream(consoleType, "emu.consoleType", -1); - inputConfig.Controllers[0].Type = FromString(LoadString(_settings, MovieKeys::Controller1), ControllerTypeNames, ControllerType::None); - inputConfig.Controllers[1].Type = FromString(LoadString(_settings, MovieKeys::Controller2), ControllerTypeNames, ControllerType::None); - inputConfig.Controllers[2].Type = FromString(LoadString(_settings, MovieKeys::Controller3), ControllerTypeNames, ControllerType::None); - inputConfig.Controllers[3].Type = FromString(LoadString(_settings, MovieKeys::Controller4), ControllerTypeNames, ControllerType::None); - inputConfig.Controllers[4].Type = FromString(LoadString(_settings, MovieKeys::Controller5), ControllerTypeNames, ControllerType::None); - emuConfig.Region = FromString(LoadString(_settings, MovieKeys::Region), ConsoleRegionNames, ConsoleRegion::Ntsc); - */ - - //TODO - /* - if(!_forTest) { - emuConfig.RamPowerOnState = FromString(LoadString(_settings, MovieKeys::RamPowerOnState), RamStateNames, RamState::AllOnes); + if(consoleType != _emu->GetConsoleType()) { + return false; } - emuConfig.PpuExtraScanlinesAfterNmi = LoadInt(_settings, MovieKeys::ExtraScanlinesAfterNmi); - emuConfig.PpuExtraScanlinesBeforeNmi = LoadInt(_settings, MovieKeys::ExtraScanlinesBeforeNmi); - emuConfig.GsuClockSpeed = LoadInt(_settings, MovieKeys::GsuClockSpeed, 100);*/ - //settings->SetEmulationConfig(emuConfig); - //settings->SetInputConfig(inputConfig); + Serializer backup(0, true, false); + backup.Stream(*settings, "", -1); + backup.SaveTo(_emuSettingsBackup); + + //Load settings + s.Stream(*settings, "", -1); + + return true; } uint32_t MesenMovie::LoadInt(std::unordered_map &settings, string name, uint32_t defaultValue) @@ -324,12 +292,14 @@ bool MesenMovie::LoadCheat(string cheatData, CheatCode &code) vector data = StringUtilities::Split(cheatData, ' '); if(data.size() == 2) { - //TODO - //code.Address = HexUtilities::FromHex(data[0]); - //code.Value = HexUtilities::FromHex(data[1]); - return true; - } else { - MessageManager::Log("[Movie] Invalid cheat definition: " + cheatData); + auto cheatType = magic_enum::enum_cast(data[0]); + if(cheatType.has_value() && data[1].size() <= 15) { + code.Type = cheatType.value(); + memcpy(code.Code, data[1].c_str(), data[1].size() + 1); + return true; + } } + + MessageManager::Log("[Movie] Invalid cheat definition: " + cheatData); return false; } diff --git a/Core/Shared/Movies/MesenMovie.h b/Core/Shared/Movies/MesenMovie.h index ade2c3d9..78ae5415 100644 --- a/Core/Shared/Movies/MesenMovie.h +++ b/Core/Shared/Movies/MesenMovie.h @@ -13,7 +13,7 @@ struct CheatCode; class MesenMovie : public IMovie, public INotificationListener, public IBatteryProvider, public std::enable_shared_from_this { private: - Emulator* _emu; + Emulator* _emu = nullptr; VirtualFile _movieFile; unique_ptr _reader; @@ -23,15 +23,14 @@ private: vector> _inputData; vector _cheats; vector _originalCheats; - std::unordered_map _settings; + stringstream _emuSettingsBackup; + unordered_map _settings; string _filename; - bool _forTest; + bool _forTest = false; private: void ParseSettings(stringstream &data); - void ApplySettings(); - bool LoadGame(); - void Stop(); + bool ApplySettings(istream& settingsData); uint32_t LoadInt(std::unordered_map &settings, string name, uint32_t defaultValue = 0); bool LoadBool(std::unordered_map &settings, string name); @@ -45,6 +44,8 @@ public: virtual ~MesenMovie(); bool Play(VirtualFile &file) override; + void Stop() override; + bool SetInput(BaseControlDevice* device) override; bool IsPlaying() override; diff --git a/Core/Shared/Movies/MovieManager.cpp b/Core/Shared/Movies/MovieManager.cpp index 0cf8cfa3..92bb2309 100644 --- a/Core/Shared/Movies/MovieManager.cpp +++ b/Core/Shared/Movies/MovieManager.cpp @@ -17,7 +17,7 @@ void MovieManager::Record(RecordMovieOptions options) { shared_ptr recorder(new MovieRecorder(_emu)); if(recorder->Record(options)) { - _recorder = recorder; + _recorder.reset(recorder); } } @@ -38,7 +38,7 @@ void MovieManager::Play(VirtualFile file, bool forTest) } if(player && player->Play(file)) { - _player = player; + _player.reset(player); if(!forTest) { MessageManager::DisplayMessage("Movies", "MoviePlaying", file.GetFileName()); } @@ -48,6 +48,10 @@ void MovieManager::Play(VirtualFile file, bool forTest) void MovieManager::Stop() { + shared_ptr player = _player.lock(); + if(player) { + player->Stop(); + } _player.reset(); _recorder.reset(); } diff --git a/Core/Shared/Movies/MovieManager.h b/Core/Shared/Movies/MovieManager.h index c67bb2e5..8adac2b2 100644 --- a/Core/Shared/Movies/MovieManager.h +++ b/Core/Shared/Movies/MovieManager.h @@ -4,6 +4,7 @@ #include "Shared/Interfaces/IInputProvider.h" #include "Shared/Movies/MovieTypes.h" #include "Shared/Movies/MovieRecorder.h" +#include "Utilities/safe_ptr.h" class VirtualFile; class Emulator; @@ -11,7 +12,8 @@ class Emulator; class IMovie : public IInputProvider { public: - virtual bool Play(VirtualFile &file) = 0; + virtual bool Play(VirtualFile& file) = 0; + virtual void Stop() = 0; virtual bool IsPlaying() = 0; }; @@ -19,8 +21,8 @@ class MovieManager { private: Emulator* _emu; - shared_ptr _player; - shared_ptr _recorder; + safe_ptr _player; + safe_ptr _recorder; public: MovieManager(Emulator* emu); diff --git a/Core/Shared/Movies/MovieRecorder.cpp b/Core/Shared/Movies/MovieRecorder.cpp index 155b0eae..4a10ffac 100644 --- a/Core/Shared/Movies/MovieRecorder.cpp +++ b/Core/Shared/Movies/MovieRecorder.cpp @@ -16,6 +16,8 @@ #include "Shared/Movies/MovieRecorder.h" #include "Shared/BatteryManager.h" #include "Shared/CheatManager.h" +#include "Utilities/Serializer.h" +#include "Utilities/magic_enum.hpp" MovieRecorder::MovieRecorder(Emulator* emu) { @@ -72,9 +74,6 @@ bool MovieRecorder::Record(RecordMovieOptions options) void MovieRecorder::GetGameSettings(stringstream &out) { EmuSettings* settings = _emu->GetSettings(); - EmulationConfig emuConfig = settings->GetEmulationConfig(); - InputConfig inputConfig = settings->GetInputConfig(); - WriteString(out, MovieKeys::MesenVersion, settings->GetVersionString()); WriteInt(out, MovieKeys::MovieFormatVersion, MovieRecorder::MovieFormatVersion); @@ -91,43 +90,18 @@ void MovieRecorder::GetGameSettings(stringstream &out) WriteString(out, MovieKeys::PatchedRomSha1, romFile.GetSha1Hash()); } - ConsoleRegion region = _emu->GetRegion(); - switch(region) { - case ConsoleRegion::Auto: - case ConsoleRegion::Ntsc: WriteString(out, MovieKeys::Region, "NTSC"); break; + Serializer s(0, true, true); + ConsoleType consoleType = _emu->GetConsoleType(); + s.Stream(consoleType, "emu.consoleType", -1); + s.Stream(*settings, "", -1); - case ConsoleRegion::Pal: WriteString(out, MovieKeys::Region, "PAL"); break; - } + std::stringstream settingsOut; + s.SaveTo(settingsOut, 0); - /*WriteString(out, MovieKeys::Controller1, ControllerTypeNames[(int)inputConfig.Controllers[0].Type]); - WriteString(out, MovieKeys::Controller2, ControllerTypeNames[(int)inputConfig.Controllers[1].Type]); - WriteString(out, MovieKeys::Controller3, ControllerTypeNames[(int)inputConfig.Controllers[2].Type]); - WriteString(out, MovieKeys::Controller4, ControllerTypeNames[(int)inputConfig.Controllers[3].Type]); - WriteString(out, MovieKeys::Controller5, ControllerTypeNames[(int)inputConfig.Controllers[4].Type]);*/ - - switch(_emu->GetConsoleType()) { - case ConsoleType::Snes: { - SnesConfig snesCfg = settings->GetSnesConfig(); - WriteInt(out, MovieKeys::ExtraScanlinesBeforeNmi, snesCfg.PpuExtraScanlinesBeforeNmi); - WriteInt(out, MovieKeys::ExtraScanlinesAfterNmi, snesCfg.PpuExtraScanlinesAfterNmi); - WriteInt(out, MovieKeys::GsuClockSpeed, snesCfg.GsuClockSpeed); - - switch(snesCfg.RamPowerOnState) { - case RamState::AllZeros: WriteString(out, MovieKeys::RamPowerOnState, "AllZeros"); break; - case RamState::AllOnes: WriteString(out, MovieKeys::RamPowerOnState, "AllOnes"); break; - case RamState::Random: WriteString(out, MovieKeys::RamPowerOnState, "AllOnes"); break; //TODO: Random memory isn't supported for movies yet - } - break; - } - - default: - //TODO - break; - } + out << settingsOut.str(); for(CheatCode &code : _emu->GetCheatManager()->GetCheats()) { - //TODO - out << "Cheat " << string(code.Code) << "\n"; + out << "Cheat " << magic_enum::enum_name(code.Type) << " " << string(code.Code) << "\n"; } } @@ -212,6 +186,8 @@ void MovieRecorder::ProcessNotification(ConsoleNotificationType type, void *para _emu->GetControlManager()->RegisterInputRecorder(this); } } + +//TODO history viewer /* bool MovieRecorder::CreateMovie(string movieFile, std::deque &data, uint32_t startPosition, uint32_t endPosition) { diff --git a/Core/Shared/Movies/MovieRecorder.h b/Core/Shared/Movies/MovieRecorder.h index 0b3313aa..7744c8cd 100644 --- a/Core/Shared/Movies/MovieRecorder.h +++ b/Core/Shared/Movies/MovieRecorder.h @@ -13,7 +13,7 @@ class Emulator; class MovieRecorder : public INotificationListener, public IInputRecorder, public IBatteryRecorder, public IBatteryProvider, public std::enable_shared_from_this { private: - static const uint32_t MovieFormatVersion = 1; + static const uint32_t MovieFormatVersion = 2; Emulator* _emu; string _filename; diff --git a/Core/Shared/Movies/MovieTypes.h b/Core/Shared/Movies/MovieTypes.h index c665f8b2..6bd3f5b2 100644 --- a/Core/Shared/Movies/MovieTypes.h +++ b/Core/Shared/Movies/MovieTypes.h @@ -17,28 +17,6 @@ struct RecordMovieOptions RecordMovieFrom RecordFrom = RecordMovieFrom::StartWithoutSaveData; }; -const vector ConsoleRegionNames = { - "Auto", - "NTSC", - "PAL" -}; - -//TODO -const vector ControllerTypeNames = { - "None", - "SnesController", - "SnesMouse", - "SuperScope", - "Multitap", - "NesController" -}; - -const vector RamStateNames = { - "AllZeros", - "AllOnes", - "Random" -}; - namespace MovieKeys { constexpr const char* MesenVersion = "MesenVersion"; @@ -48,16 +26,4 @@ namespace MovieKeys constexpr const char* PatchFile = "PatchFile"; constexpr const char* PatchFileSha1 = "PatchFileSHA1"; constexpr const char* PatchedRomSha1 = "PatchedRomSHA1"; - constexpr const char* Region = "Region"; - constexpr const char* ConsoleType = "ConsoleType"; - constexpr const char* Controller1 = "Controller1"; - constexpr const char* Controller2 = "Controller2"; - constexpr const char* Controller3 = "Controller3"; - constexpr const char* Controller4 = "Controller4"; - constexpr const char* Controller5 = "Controller5"; - constexpr const char* ExtraScanlinesBeforeNmi = "ExtraScanlinesBeforeNmi"; - constexpr const char* ExtraScanlinesAfterNmi = "ExtraScanlinesAfterNmi"; - constexpr const char* RamPowerOnState = "RamPowerOnState"; - constexpr const char* InputPollScanline = "InputPollScanline"; - constexpr const char* GsuClockSpeed = "GsuClockSpeed"; }; \ No newline at end of file diff --git a/Core/Shared/SettingTypes.h b/Core/Shared/SettingTypes.h index eb0ebff3..ad206873 100644 --- a/Core/Shared/SettingTypes.h +++ b/Core/Shared/SettingTypes.h @@ -160,7 +160,6 @@ struct AudioConfig uint32_t AudioPlayerSilenceDelay = 3; }; -//Update ControllerTypeNames when changing this enum class ControllerType { None, diff --git a/NewUI/ViewModels/MainMenuViewModel.cs b/NewUI/ViewModels/MainMenuViewModel.cs index 91a591ca..ed54c6fb 100644 --- a/NewUI/ViewModels/MainMenuViewModel.cs +++ b/NewUI/ViewModels/MainMenuViewModel.cs @@ -537,11 +537,8 @@ namespace Mesen.ViewModels new MainMenuAction() { ActionType = ActionType.Stop, IsEnabled = () => IsGameRunning && (RecordApi.MovieRecording() || RecordApi.MoviePlaying()), - OnClick = async () => { - string? filename = await FileDialogHelper.OpenFile(ConfigManager.MovieFolder, wnd, FileDialogHelper.MesenMovieExt); - if(filename != null) { - RecordApi.MovieStop(); - } + OnClick = () => { + RecordApi.MovieStop(); } } } diff --git a/NewUI/Windows/AboutWindow.axaml.cs b/NewUI/Windows/AboutWindow.axaml.cs index 9ab41f93..36d2fb3a 100644 --- a/NewUI/Windows/AboutWindow.axaml.cs +++ b/NewUI/Windows/AboutWindow.axaml.cs @@ -61,10 +61,11 @@ namespace Mesen.Windows new("nes_ntsc", "blargg", "LGPL", "http://slack.net/~ant/"), new("snes_ntsc", "blargg", "LGPL", "http://slack.net/~ant/"), new("stb_vorbis", "", "Public domain", "https://github.com/nothings/stb"), - new("emu2413.c (Mitsukata Okazaki)", "Mitsukata Okazaki", "?", ""), + new("emu2413", "Mitsukata Okazaki", "MIT", "https://github.com/digital-sound-antiques/emu2413"), new("SDD-1 Decomp. (Andreas Naive)", "Andreas Naive", "Public domain", ""), new("LED Icons", "", "CC BY 4.0", "http://led24.de"), - new("SDL2", "", "zlib", "https://www.libsdl.org/") + new("SDL2", "", "zlib", "https://www.libsdl.org/"), + new("magic_enum", "", "MIT", "https://github.com/Neargye/magic_enum") }; LibraryList.Sort((a, b) => a.Name.CompareTo(b.Name)); diff --git a/Utilities/Serializer.cpp b/Utilities/Serializer.cpp index 293209e0..47289509 100644 --- a/Utilities/Serializer.cpp +++ b/Utilities/Serializer.cpp @@ -4,10 +4,11 @@ #include "ISerializable.h" #include "miniz.h" -Serializer::Serializer(uint32_t version, bool forSave) +Serializer::Serializer(uint32_t version, bool forSave, bool useTextFormat) { _version = version; _saving = forSave; + _useTextFormat = useTextFormat; if(forSave) { _data.reserve(0x50000); } @@ -19,6 +20,10 @@ bool Serializer::LoadFrom(istream &file) return false; } + if(_useTextFormat) { + return LoadFromTextFormat(file); + } + char value = 0; file.get(value); bool isCompressed = value == 1; @@ -95,24 +100,83 @@ bool Serializer::LoadFrom(istream &file) return _values.size() > 0; } +bool Serializer::LoadFromTextFormat(istream& file) +{ + uint32_t pos = (uint32_t)file.tellg(); + file.seekg(0, std::ios::end); + uint32_t stateSize = (uint32_t)file.tellg() - pos; + file.seekg(pos, std::ios::beg); + + _data = vector(stateSize, 0); + file.read((char*)_data.data(), stateSize); + + uint32_t size = (uint32_t)_data.size(); + uint32_t i = 0; + string key; + while(i < size) { + key.clear(); + for(uint32_t j = i; j < size; j++) { + if(_data[j] == ' ') { + key.append((char*)&_data[i], j - i); + break; + } else if(_data[j] < ' ' || _data[j] >= 127) { + //invalid characters in key, state is invalid + return false; + } + } + + if(key.empty()) { + //invalid + return false; + } + + i += (uint32_t)key.size() + 1; + if(i >= size - 4) { + //invalid + return false; + } + + uint32_t valueSize = 0; + for(uint32_t j = i; j < size; j++) { + if(_data[j] == '\n') { + valueSize = j - i; + break; + } + } + + if(i + valueSize > size) { + //invalid + return false; + } + + _values.emplace(key, SerializeValue(&_data[i], valueSize)); + + i += valueSize + 1; + } +} + void Serializer::SaveTo(ostream& file, int compressionLevel) { - bool isCompressed = compressionLevel > 0; - file.put((char)isCompressed); - - if(isCompressed) { - unsigned long compressedSize = compressBound((unsigned long)_data.size()); - uint8_t* compressedData = new uint8_t[compressedSize]; - compress2(compressedData, &compressedSize, (unsigned char*)_data.data(), (unsigned long)_data.size(), compressionLevel); - - uint32_t size = (uint32_t)compressedSize; - uint32_t originalSize = (uint32_t)_data.size(); - file.write((char*)&originalSize, sizeof(uint32_t)); - file.write((char*)&size, sizeof(uint32_t)); - file.write((char*)compressedData, compressedSize); - delete[] compressedData; - } else { + if(_useTextFormat) { file.write((char*)_data.data(), _data.size()); + } else { + bool isCompressed = compressionLevel > 0; + file.put((char)isCompressed); + + if(isCompressed) { + unsigned long compressedSize = compressBound((unsigned long)_data.size()); + uint8_t* compressedData = new uint8_t[compressedSize]; + compress2(compressedData, &compressedSize, (unsigned char*)_data.data(), (unsigned long)_data.size(), compressionLevel); + + uint32_t size = (uint32_t)compressedSize; + uint32_t originalSize = (uint32_t)_data.size(); + file.write((char*)&originalSize, sizeof(uint32_t)); + file.write((char*)&size, sizeof(uint32_t)); + file.write((char*)compressedData, compressedSize); + delete[] compressedData; + } else { + file.write((char*)_data.data(), _data.size()); + } } } @@ -132,4 +196,3 @@ void Serializer::PopNamePrefix() { _prefixes.pop_back(); } - diff --git a/Utilities/Serializer.h b/Utilities/Serializer.h index d23533e0..17d74180 100644 --- a/Utilities/Serializer.h +++ b/Utilities/Serializer.h @@ -3,6 +3,7 @@ #include "stdafx.h" #include "Utilities/ISerializable.h" #include "Utilities/FastString.h" +#include "Utilities/magic_enum.hpp" class Serializer; @@ -42,8 +43,11 @@ private: uint32_t _version = 0; bool _saving = false; + bool _useTextFormat = false; private: + bool LoadFromTextFormat(istream& file); + string GetKey(const char* name, int index) { string key; @@ -110,8 +114,45 @@ private: } } + template + void WriteTextFormat(string key, T& value) + { + //Write key + _data.insert(_data.end(), key.begin(), key.end()); + _data.push_back(' '); + if constexpr(std::is_enum::value) { + auto enumStr = magic_enum::enum_name(value); + _data.insert(_data.end(), enumStr.begin(), enumStr.end()); + } else if constexpr(std::is_same::value) { + string boolStr = value ? "true" : "false"; + _data.insert(_data.end(), boolStr.begin(), boolStr.end()); + } else { + auto valueStr = std::to_string(value); + _data.insert(_data.end(), valueStr.begin(), valueStr.end()); + } + _data.push_back('\n'); + } + + template + void ReadTextFormat(SerializeValue& savedValue, T& value) + { + string textValue(savedValue.DataPtr, savedValue.DataPtr + savedValue.Size); + if constexpr(std::is_enum::value) { + auto enumValue = magic_enum::enum_cast(textValue); + if(enumValue.has_value()) { + value = enumValue.value(); + } + } else if constexpr(std::is_same::value) { + value = textValue == "true"; + } else { + if(textValue.find_first_not_of("0123456789") == string::npos) { + value = (T)std::stol(textValue); + } + } + } + public: - Serializer(uint32_t version, bool forSave); + Serializer(uint32_t version, bool forSave, bool useTextFormat = false); uint32_t GetVersion() { return _version; } bool IsSaving() { return _saving; } @@ -138,23 +179,31 @@ public: } if(_saving) { - //Write key - _data.insert(_data.end(), key.begin(), key.end()); - _data.push_back(0); + if(_useTextFormat) { + WriteTextFormat(key, value); + } else { + //Write key + _data.insert(_data.end(), key.begin(), key.end()); + _data.push_back(0); - //Write value size - WriteValue((uint32_t)sizeof(T)); + //Write value size + WriteValue((uint32_t)sizeof(T)); - //Write value - WriteValue(value); + //Write value + WriteValue(value); + } } else { auto result = _values.find(key); if(result != _values.end()) { SerializeValue& savedValue = result->second; - if(savedValue.Size >= sizeof(T)) { - ReadValue(value, savedValue.DataPtr); + if(_useTextFormat) { + ReadTextFormat(savedValue, value); } else { - value = (T)0; + if(savedValue.Size >= sizeof(T)) { + ReadValue(value, savedValue.DataPtr); + } else { + value = (T)0; + } } } else { value = (T)0; diff --git a/Utilities/Utilities.vcxproj b/Utilities/Utilities.vcxproj index 7f41c2dd..013053f8 100644 --- a/Utilities/Utilities.vcxproj +++ b/Utilities/Utilities.vcxproj @@ -202,6 +202,7 @@ + diff --git a/Utilities/Utilities.vcxproj.filters b/Utilities/Utilities.vcxproj.filters index 84ff4665..71905ec9 100644 --- a/Utilities/Utilities.vcxproj.filters +++ b/Utilities/Utilities.vcxproj.filters @@ -172,6 +172,7 @@ + diff --git a/Utilities/magic_enum.hpp b/Utilities/magic_enum.hpp new file mode 100644 index 00000000..d59a19a5 --- /dev/null +++ b/Utilities/magic_enum.hpp @@ -0,0 +1,1378 @@ +// __ __ _ ______ _____ +// | \/ | (_) | ____| / ____|_ _ +// | \ / | __ _ __ _ _ ___ | |__ _ __ _ _ _ __ ___ | | _| |_ _| |_ +// | |\/| |/ _` |/ _` | |/ __| | __| | '_ \| | | | '_ ` _ \ | | |_ _|_ _| +// | | | | (_| | (_| | | (__ | |____| | | | |_| | | | | | | | |____|_| |_| +// |_| |_|\__,_|\__, |_|\___| |______|_| |_|\__,_|_| |_| |_| \_____| +// __/ | https://github.com/Neargye/magic_enum +// |___/ version 0.8.0 +// +// Licensed under the MIT License . +// SPDX-License-Identifier: MIT +// Copyright (c) 2019 - 2022 Daniil Goncharov . +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +#ifndef NEARGYE_MAGIC_ENUM_HPP +#define NEARGYE_MAGIC_ENUM_HPP + +#define MAGIC_ENUM_VERSION_MAJOR 0 +#define MAGIC_ENUM_VERSION_MINOR 8 +#define MAGIC_ENUM_VERSION_PATCH 0 + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(MAGIC_ENUM_CONFIG_FILE) +#include MAGIC_ENUM_CONFIG_FILE +#endif + +#if !defined(MAGIC_ENUM_USING_ALIAS_OPTIONAL) +#include +#endif +#if !defined(MAGIC_ENUM_USING_ALIAS_STRING) +#include +#endif +#if !defined(MAGIC_ENUM_USING_ALIAS_STRING_VIEW) +#include +#endif + +#if defined(__clang__) +# pragma clang diagnostic push +#elif defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // May be used uninitialized 'return {};'. +#elif defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 26495) // Variable 'static_string::chars_' is uninitialized. +# pragma warning(disable : 28020) // Arithmetic overflow: Using operator '-' on a 4 byte value and then casting the result to a 8 byte value. +# pragma warning(disable : 26451) // The expression '0<=_Param_(1)&&_Param_(1)<=1-1' is not true at this call. +# pragma warning(disable : 4514) // Unreferenced inline function has been removed. +#endif + +// Checks magic_enum compiler compatibility. +#if defined(__clang__) && __clang_major__ >= 5 || defined(__GNUC__) && __GNUC__ >= 9 || defined(_MSC_VER) && _MSC_VER >= 1910 +# undef MAGIC_ENUM_SUPPORTED +# define MAGIC_ENUM_SUPPORTED 1 +#endif + +// Checks magic_enum compiler aliases compatibility. +#if defined(__clang__) && __clang_major__ >= 5 || defined(__GNUC__) && __GNUC__ >= 9 || defined(_MSC_VER) && _MSC_VER >= 1920 +# undef MAGIC_ENUM_SUPPORTED_ALIASES +# define MAGIC_ENUM_SUPPORTED_ALIASES 1 +#endif + +// Enum value must be greater or equals than MAGIC_ENUM_RANGE_MIN. By default MAGIC_ENUM_RANGE_MIN = -128. +// If need another min range for all enum types by default, redefine the macro MAGIC_ENUM_RANGE_MIN. +#if !defined(MAGIC_ENUM_RANGE_MIN) +# define MAGIC_ENUM_RANGE_MIN 0 +#endif + +// Enum value must be less or equals than MAGIC_ENUM_RANGE_MAX. By default MAGIC_ENUM_RANGE_MAX = 128. +// If need another max range for all enum types by default, redefine the macro MAGIC_ENUM_RANGE_MAX. +#if !defined(MAGIC_ENUM_RANGE_MAX) +# define MAGIC_ENUM_RANGE_MAX 128 +#endif + +namespace magic_enum { + +// If need another optional type, define the macro MAGIC_ENUM_USING_ALIAS_OPTIONAL. +#if defined(MAGIC_ENUM_USING_ALIAS_OPTIONAL) +MAGIC_ENUM_USING_ALIAS_OPTIONAL +#else +using std::optional; +#endif + +// If need another string_view type, define the macro MAGIC_ENUM_USING_ALIAS_STRING_VIEW. +#if defined(MAGIC_ENUM_USING_ALIAS_STRING_VIEW) +MAGIC_ENUM_USING_ALIAS_STRING_VIEW +#else +using std::string_view; +#endif + +// If need another string type, define the macro MAGIC_ENUM_USING_ALIAS_STRING. +#if defined(MAGIC_ENUM_USING_ALIAS_STRING) +MAGIC_ENUM_USING_ALIAS_STRING +#else +using std::string; +#endif + +namespace customize { + +// Enum value must be in range [MAGIC_ENUM_RANGE_MIN, MAGIC_ENUM_RANGE_MAX]. By default MAGIC_ENUM_RANGE_MIN = -128, MAGIC_ENUM_RANGE_MAX = 128. +// If need another range for all enum types by default, redefine the macro MAGIC_ENUM_RANGE_MIN and MAGIC_ENUM_RANGE_MAX. +// If need another range for specific enum type, add specialization enum_range for necessary enum type. +template +struct enum_range { + static_assert(std::is_enum_v, "magic_enum::customize::enum_range requires enum type."); + static constexpr int min = MAGIC_ENUM_RANGE_MIN; + static constexpr int max = MAGIC_ENUM_RANGE_MAX; + static_assert(max > min, "magic_enum::customize::enum_range requires max > min."); +}; + +static_assert(MAGIC_ENUM_RANGE_MAX > MAGIC_ENUM_RANGE_MIN, "MAGIC_ENUM_RANGE_MAX must be greater than MAGIC_ENUM_RANGE_MIN."); +static_assert((MAGIC_ENUM_RANGE_MAX - MAGIC_ENUM_RANGE_MIN) < (std::numeric_limits::max)(), "MAGIC_ENUM_RANGE must be less than UINT16_MAX."); + +namespace detail { +enum class default_customize_tag {}; +enum class invalid_customize_tag {}; +} // namespace magic_enum::customize::detail + +using customize_t = std::variant; + +// Default customize. +inline constexpr auto default_tag = detail::default_customize_tag{}; +// Invalid customize. +inline constexpr auto invalid_tag = detail::invalid_customize_tag{}; + +// If need custom names for enum, add specialization enum_name for necessary enum type. +template +constexpr customize_t enum_name(E) noexcept { + return default_tag; +} + +// If need custom type name for enum, add specialization enum_type_name for necessary enum type. +template +constexpr customize_t enum_type_name() noexcept { + return default_tag; +} + +} // namespace magic_enum::customize + +namespace detail { + +template >>> +using enum_constant = std::integral_constant, V>; + +template +inline constexpr bool always_false_v = false; + +template +struct supported +#if defined(MAGIC_ENUM_SUPPORTED) && MAGIC_ENUM_SUPPORTED || defined(MAGIC_ENUM_NO_CHECK_SUPPORT) + : std::true_type {}; +#else + : std::false_type {}; +#endif + +template +struct has_is_flags : std::false_type {}; + +template +struct has_is_flags::is_flags)>> : std::bool_constant::is_flags)>>> {}; + +template +struct range_min : std::integral_constant {}; + +template +struct range_min::min)>> : std::integral_constant::min), customize::enum_range::min> {}; + +template +struct range_max : std::integral_constant {}; + +template +struct range_max::max)>> : std::integral_constant::max), customize::enum_range::max> {}; + +template +class static_string { + public: + constexpr explicit static_string(string_view str) noexcept : static_string{str, std::make_index_sequence{}} { + assert(str.size() == N); + } + + constexpr const char* data() const noexcept { return chars_; } + + constexpr std::size_t size() const noexcept { return N; } + + constexpr operator string_view() const noexcept { return {data(), size()}; } + + private: + template + constexpr static_string(string_view str, std::index_sequence) noexcept : chars_{str[I]..., '\0'} {} + + char chars_[N + 1]; +}; + +template <> +class static_string<0> { + public: + constexpr explicit static_string() = default; + + constexpr explicit static_string(string_view) noexcept {} + + constexpr const char* data() const noexcept { return nullptr; } + + constexpr std::size_t size() const noexcept { return 0; } + + constexpr operator string_view() const noexcept { return {}; } +}; + +constexpr string_view pretty_name(string_view name) noexcept { + for (std::size_t i = name.size(); i > 0; --i) { + if (!((name[i - 1] >= '0' && name[i - 1] <= '9') || + (name[i - 1] >= 'a' && name[i - 1] <= 'z') || + (name[i - 1] >= 'A' && name[i - 1] <= 'Z') || +#if defined(MAGIC_ENUM_ENABLE_NONASCII) + (name[i - 1] & 0x80) || +#endif + (name[i - 1] == '_'))) { + name.remove_prefix(i); + break; + } + } + + if (name.size() > 0 && ((name.front() >= 'a' && name.front() <= 'z') || + (name.front() >= 'A' && name.front() <= 'Z') || +#if defined(MAGIC_ENUM_ENABLE_NONASCII) + (name.front() & 0x80) || +#endif + (name.front() == '_'))) { + return name; + } + + return {}; // Invalid name. +} + +class case_insensitive { + static constexpr char to_lower(char c) noexcept { + return (c >= 'A' && c <= 'Z') ? static_cast(c + ('a' - 'A')) : c; + } + + public: + template + constexpr auto operator()([[maybe_unused]] L lhs, [[maybe_unused]] R rhs) const noexcept -> std::enable_if_t, char> && std::is_same_v, char>, bool> { +#if defined(MAGIC_ENUM_ENABLE_NONASCII) + static_assert(always_false_v, "magic_enum::case_insensitive not supported Non-ASCII feature."); + return false; +#else + return to_lower(lhs) == to_lower(rhs); +#endif + } +}; + +constexpr std::size_t find(string_view str, char c) noexcept { +#if defined(__clang__) && __clang_major__ < 9 && defined(__GLIBCXX__) || defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__) +// https://stackoverflow.com/questions/56484834/constexpr-stdstring-viewfind-last-of-doesnt-work-on-clang-8-with-libstdc +// https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html + constexpr bool workaround = true; +#else + constexpr bool workaround = false; +#endif + + if constexpr (workaround) { + for (std::size_t i = 0; i < str.size(); ++i) { + if (str[i] == c) { + return i; + } + } + + return string_view::npos; + } else { + return str.find_first_of(c); + } +} + +template +constexpr std::array, N> to_array(T (&a)[N], std::index_sequence) noexcept { + return {{a[I]...}}; +} + +template +constexpr bool is_default_predicate() noexcept { + return std::is_same_v, std::equal_to> || + std::is_same_v, std::equal_to<>>; +} + +template +constexpr bool is_nothrow_invocable() { + return is_default_predicate() || + std::is_nothrow_invocable_r_v; +} + +template +constexpr bool cmp_equal(string_view lhs, string_view rhs, [[maybe_unused]] BinaryPredicate&& p) noexcept(is_nothrow_invocable()) { +#if defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__) + // https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html + // https://developercommunity.visualstudio.com/content/problem/232218/c-constexpr-string-view.html + constexpr bool workaround = true; +#else + constexpr bool workaround = false; +#endif + + if constexpr (!is_default_predicate() || workaround) { + if (lhs.size() != rhs.size()) { + return false; + } + + const auto size = lhs.size(); + for (std::size_t i = 0; i < size; ++i) { + if (!p(lhs[i], rhs[i])) { + return false; + } + } + + return true; + } else { + return lhs == rhs; + } +} + +template +constexpr bool cmp_less(L lhs, R rhs) noexcept { + static_assert(std::is_integral_v && std::is_integral_v, "magic_enum::detail::cmp_less requires integral type."); + + if constexpr (std::is_signed_v == std::is_signed_v) { + // If same signedness (both signed or both unsigned). + return lhs < rhs; + } else if constexpr (std::is_same_v) { // bool special case + return static_cast(lhs) < rhs; + } else if constexpr (std::is_same_v) { // bool special case + return lhs < static_cast(rhs); + } else if constexpr (std::is_signed_v) { + // If 'right' is negative, then result is 'false', otherwise cast & compare. + return rhs > 0 && lhs < static_cast>(rhs); + } else { + // If 'left' is negative, then result is 'true', otherwise cast & compare. + return lhs < 0 || static_cast>(lhs) < rhs; + } +} + +template +constexpr I log2(I value) noexcept { + static_assert(std::is_integral_v, "magic_enum::detail::log2 requires integral type."); + + if constexpr (std::is_same_v) { // bool special case + return assert(false), value; + } else { + auto ret = I{0}; + for (; value > I{1}; value >>= I{1}, ++ret) {} + + return ret; + } +} + +template +inline constexpr bool is_enum_v = std::is_enum_v && std::is_same_v>; + +template +constexpr auto n() noexcept { + static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); + + [[maybe_unused]] constexpr auto custom = customize::enum_type_name(); + static_assert(std::is_same_v, customize::customize_t>, "magic_enum::customize requires customize_t type."); + if constexpr (custom.index() == 0) { + constexpr auto name = std::get(custom); + static_assert(!name.empty(), "magic_enum::customize requires not empty string."); + return static_string{name}; + } else if constexpr (custom.index() == 1 && supported::value) { +#if defined(__clang__) || defined(__GNUC__) + constexpr auto name = pretty_name({__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 2}); +#elif defined(_MSC_VER) + constexpr auto name = pretty_name({__FUNCSIG__, sizeof(__FUNCSIG__) - 17}); +#else + constexpr auto name = string_view{}; +#endif + return static_string{name}; + } else { + return static_string<0>{}; // Unsupported compiler or Invalid customize. + } +} + +template +inline constexpr auto type_name_v = n(); + +template +constexpr auto n() noexcept { + static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); + + [[maybe_unused]] constexpr auto custom = customize::enum_name(V); + static_assert(std::is_same_v, customize::customize_t>, "magic_enum::customize requires customize_t type."); + if constexpr (custom.index() == 0) { + constexpr auto name = std::get(custom); + static_assert(!name.empty(), "magic_enum::customize requires not empty string."); + return static_string{name}; + } else if constexpr (custom.index() == 1 && supported::value) { +#if defined(__clang__) || defined(__GNUC__) + constexpr auto name = pretty_name({__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 2}); +#elif defined(_MSC_VER) + constexpr auto name = pretty_name({__FUNCSIG__, sizeof(__FUNCSIG__) - 17}); +#else + constexpr auto name = string_view{}; +#endif + return static_string{name}; + } else { + return static_string<0>{}; // Unsupported compiler or Invalid customize. + } +} + +template +inline constexpr auto enum_name_v = n(); + +template +constexpr bool is_valid() noexcept { + static_assert(is_enum_v, "magic_enum::detail::is_valid requires enum type."); + + return n(V)>().size() != 0; +} + +template > +constexpr E value(std::size_t i) noexcept { + static_assert(is_enum_v, "magic_enum::detail::value requires enum type."); + + if constexpr (std::is_same_v) { // bool special case + static_assert(O == 0, "magic_enum::detail::value requires valid offset."); + + return static_cast(i); + } else if constexpr (IsFlags) { + return static_cast(U{1} << static_cast(static_cast(i) + O)); + } else { + return static_cast(static_cast(i) + O); + } +} + +template > +constexpr int reflected_min() noexcept { + static_assert(is_enum_v, "magic_enum::detail::reflected_min requires enum type."); + + if constexpr (IsFlags) { + return 0; + } else { + constexpr auto lhs = range_min::value; + constexpr auto rhs = (std::numeric_limits::min)(); + + if constexpr (cmp_less(rhs, lhs)) { + return lhs; + } else { + return rhs; + } + } +} + +template > +constexpr int reflected_max() noexcept { + static_assert(is_enum_v, "magic_enum::detail::reflected_max requires enum type."); + + if constexpr (IsFlags) { + return std::numeric_limits::digits - 1; + } else { + constexpr auto lhs = range_max::value; + constexpr auto rhs = (std::numeric_limits::max)(); + + if constexpr (cmp_less(lhs, rhs)) { + return lhs; + } else { + return rhs; + } + } +} + +template +inline constexpr auto reflected_min_v = reflected_min(); + +template +inline constexpr auto reflected_max_v = reflected_max(); + +template +constexpr std::size_t values_count(const bool (&valid)[N]) noexcept { + auto count = std::size_t{0}; + for (std::size_t i = 0; i < N; ++i) { + if (valid[i]) { + ++count; + } + } + + return count; +} + +template +constexpr auto values(std::index_sequence) noexcept { + static_assert(is_enum_v, "magic_enum::detail::values requires enum type."); + constexpr bool valid[sizeof...(I)] = {is_valid(I)>()...}; + constexpr std::size_t count = values_count(valid); + + if constexpr (count > 0) { + E values[count] = {}; + for (std::size_t i = 0, v = 0; v < count; ++i) { + if (valid[i]) { + values[v++] = value(i); + } + } + + return to_array(values, std::make_index_sequence{}); + } else { + return std::array{}; + } +} + +template > +constexpr auto values() noexcept { + static_assert(is_enum_v, "magic_enum::detail::values requires enum type."); + constexpr auto min = reflected_min_v; + constexpr auto max = reflected_max_v; + constexpr auto range_size = max - min + 1; + static_assert(range_size > 0, "magic_enum::enum_range requires valid size."); + static_assert(range_size < (std::numeric_limits::max)(), "magic_enum::enum_range requires valid size."); + + return values>(std::make_index_sequence{}); +} + +template > +constexpr bool is_flags_enum() noexcept { + static_assert(is_enum_v, "magic_enum::detail::is_flags_enum requires enum type."); + + if constexpr (has_is_flags::value) { + return customize::enum_range::is_flags; + } else if constexpr (std::is_same_v) { // bool special case + return false; + } else { +#if defined(MAGIC_ENUM_NO_CHECK_FLAGS) + return false; +#else + constexpr auto flags_values = values(); + constexpr auto default_values = values(); + if (flags_values.size() == 0 || default_values.size() > flags_values.size()) { + return false; + } + for (std::size_t i = 0; i < default_values.size(); ++i) { + const auto v = static_cast(default_values[i]); + if (v != 0 && (v & (v - 1)) != 0) { + return false; + } + } + return flags_values.size() > 0; +#endif + } +} + +template +inline constexpr bool is_flags_v = is_flags_enum(); + +template +inline constexpr std::array values_v = values>(); + +template > +using values_t = decltype((values_v)); + +template +inline constexpr auto count_v = values_v.size(); + +template > +inline constexpr auto min_v = (count_v > 0) ? static_cast(values_v.front()) : U{0}; + +template > +inline constexpr auto max_v = (count_v > 0) ? static_cast(values_v.back()) : U{0}; + +template +constexpr auto names(std::index_sequence) noexcept { + static_assert(is_enum_v, "magic_enum::detail::names requires enum type."); + + return std::array{{enum_name_v[I]>...}}; +} + +template +inline constexpr std::array names_v = names(std::make_index_sequence>{}); + +template > +using names_t = decltype((names_v)); + +template +constexpr auto entries(std::index_sequence) noexcept { + static_assert(is_enum_v, "magic_enum::detail::entries requires enum type."); + + return std::array, sizeof...(I)>{{{values_v[I], enum_name_v[I]>}...}}; +} + +template +inline constexpr std::array entries_v = entries(std::make_index_sequence>{}); + +template > +using entries_t = decltype((entries_v)); + +template > +constexpr bool is_sparse() noexcept { + static_assert(is_enum_v, "magic_enum::detail::is_sparse requires enum type."); + + if constexpr (count_v == 0) { + return false; + } else if constexpr (std::is_same_v) { // bool special case + return false; + } else { + constexpr auto max = is_flags_v ? log2(max_v) : max_v; + constexpr auto min = is_flags_v ? log2(min_v) : min_v; + constexpr auto range_size = max - min + 1; + + return range_size != count_v; + } +} + +template +inline constexpr bool is_sparse_v = is_sparse(); + +template > +constexpr U values_ors() noexcept { + static_assert(is_enum_v, "magic_enum::detail::values_ors requires enum type."); + + auto ors = U{0}; + for (std::size_t i = 0; i < count_v; ++i) { + ors |= static_cast(values_v[i]); + } + + return ors; +} + +template +struct enable_if_enum {}; + +template +struct enable_if_enum { + using type = R; + static_assert(supported::value, "magic_enum unsupported compiler (https://github.com/Neargye/magic_enum#compiler-compatibility)."); +}; + +template > +using enable_if_t = typename enable_if_enum> && std::is_invocable_r_v, R>::type; + +template >>> +using enum_concept = T; + +template > +struct is_scoped_enum : std::false_type {}; + +template +struct is_scoped_enum : std::bool_constant>> {}; + +template > +struct is_unscoped_enum : std::false_type {}; + +template +struct is_unscoped_enum : std::bool_constant>> {}; + +template >> +struct underlying_type {}; + +template +struct underlying_type : std::underlying_type> {}; + +template +struct constexpr_hash_t; + +template +struct constexpr_hash_t>> { + constexpr auto operator()(Value value) const noexcept { + using U = typename underlying_type::type; + if constexpr (std::is_same_v) { // bool special case + return static_cast(value); + } else { + return static_cast(value); + } + } + using secondary_hash = constexpr_hash_t; +}; + +template +struct constexpr_hash_t>> { + static constexpr std::uint32_t crc_table[256] { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L, + 0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L, + 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, + 0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L, + 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, + 0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL, + 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, + 0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L, + 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, + 0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L, + 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, + 0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L, + 0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, + 0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L, + 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, + 0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L, + 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, + 0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L, + 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, + 0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL, + 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, + 0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L, + 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, + 0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL, + 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL, + 0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL + }; + constexpr std::uint32_t operator()(string_view value) const noexcept { + auto crc = static_cast(0xffffffffL); + for (const auto c : value) { + crc = (crc >> 8) ^ crc_table[(crc ^ static_cast(c)) & 0xff]; + } + return crc ^ 0xffffffffL; + } + + struct secondary_hash { + constexpr std::uint32_t operator()(string_view value) const noexcept { + auto acc = static_cast(2166136261ULL); + for (const auto c : value) { + acc = ((acc ^ static_cast(c)) * static_cast(16777619ULL)) & (std::numeric_limits::max)(); + } + return static_cast(acc); + } + }; +}; + +template +constexpr static Hash hash_v{}; + +template +constexpr auto calculate_cases(std::size_t Page) noexcept { + constexpr std::array values = *GlobValues; + constexpr std::size_t size = values.size(); + + using switch_t = std::invoke_result_t; + static_assert(std::is_integral_v && !std::is_same_v); + const std::size_t values_to = (std::min)(static_cast(256), size - Page); + + std::array result{}; + auto fill = result.begin(); + { + auto first = values.begin() + static_cast(Page); + auto last = values.begin() + static_cast(Page + values_to); + while (first != last) { + *fill++ = hash_v(*first++); + } + } + + // dead cases, try to avoid case collisions + for (switch_t last_value = result[values_to - 1]; fill != result.end() && last_value != (std::numeric_limits::max)(); *fill++ = ++last_value) { + } + + { + auto it = result.begin(); + auto last_value = (std::numeric_limits::min)(); + for (; fill != result.end(); *fill++ = last_value++) { + while (last_value == *it) { + ++last_value, ++it; + } + } + } + + return result; +} + +template +constexpr R invoke_r(F&& f, Args&&... args) noexcept(std::is_nothrow_invocable_r_v) { + if constexpr (std::is_void_v) { + std::forward(f)(std::forward(args)...); + } else { + return static_cast(std::forward(f)(std::forward(args)...)); + } +} + +enum class case_call_t { + index, value +}; + +template +inline constexpr auto default_result_type_lambda = []() noexcept(std::is_nothrow_default_constructible_v) { return T{}; }; + +template <> +inline constexpr auto default_result_type_lambda = []() noexcept {}; + +template +constexpr bool no_duplicate() noexcept { + using value_t = std::decay_t; + using hash_value_t = std::invoke_result_t; + std::arraysize()> hashes{}; + std::size_t size = 0; + for (auto elem : *Arr) { + hashes[size] = hash_v(elem); + for (auto i = size++; i > 0; --i) { + if (hashes[i] < hashes[i - 1]) { + auto tmp = hashes[i]; + hashes[i] = hashes[i - 1]; + hashes[i - 1] = tmp; + } else if (hashes[i] == hashes[i - 1]) { + return false; + } else { + break; + } + } + } + return true; +} + +#define MAGIC_ENUM_FOR_EACH_256(T) T(0)T(1)T(2)T(3)T(4)T(5)T(6)T(7)T(8)T(9)T(10)T(11)T(12)T(13)T(14)T(15)T(16)T(17)T(18)T(19)T(20)T(21)T(22)T(23)T(24)T(25)T(26)T(27)T(28)T(29)T(30)T(31)T(32)T(33)T(34)T(35)T(36)T(37)T(38)T(39)T(40)T(41)T(42)T(43)T(44)T(45)T(46)T(47)T(48)T(49)T(50)T(51)T(52) + +#define MAGIC_ENUM_CASE(val) \ + case cases[val]: \ + if (!pred(values[val + Page], searched)) { \ + break; \ + } \ + if constexpr (CallValue == case_call_t::index) { \ + if constexpr (std::is_invocable_r_v>) { \ + return detail::invoke_r(std::forward(lambda), std::integral_constant{}); \ + } else if constexpr (std::is_invocable_v>) { \ + assert(false && "magic_enum::detail::constexpr_switch wrong result type."); \ + } \ + } else if constexpr (CallValue == case_call_t::value) { \ + if constexpr (std::is_invocable_r_v>) { \ + return detail::invoke_r(std::forward(lambda), enum_constant{}); \ + } else if constexpr (std::is_invocable_r_v>) { \ + assert(false && "magic_enum::detail::constexpr_switch wrong result type."); \ + } \ + } \ + break; + +template ::value_type>, + typename Lambda, typename ResultGetterType = decltype(default_result_type_lambda<>), + typename BinaryPredicate = std::equal_to<>> +constexpr std::invoke_result_t constexpr_switch( + Lambda&& lambda, + typename std::decay_t::value_type searched, + ResultGetterType&& def = default_result_type_lambda<>, + BinaryPredicate&& pred = {}) { + using result_t = std::invoke_result_t; + using hash_t = std::conditional_t(), Hash, typename Hash::secondary_hash>; + constexpr std::array values = *GlobValues; + constexpr std::size_t size = values.size(); + constexpr std::array cases = calculate_cases(Page); + + switch (hash_v(searched)) { + MAGIC_ENUM_FOR_EACH_256(MAGIC_ENUM_CASE) + default: + if constexpr (size > 256 + Page) { + return constexpr_switch(std::forward(lambda), searched, std::forward(def)); + } + break; + } + return def(); +} + +#undef MAGIC_ENUM_FOR_EACH_256 +#undef MAGIC_ENUM_CASE + +template +constexpr auto for_each(Lambda&& lambda, std::index_sequence) { + static_assert(is_enum_v, "magic_enum::detail::for_each requires enum type."); + constexpr bool has_void_return = (std::is_void_v[I]>>> || ...); + constexpr bool all_same_return = (std::is_same_v[0]>>, std::invoke_result_t[I]>>> && ...); + + if constexpr (has_void_return) { + (lambda(enum_constant[I]>{}), ...); + } else if constexpr (all_same_return) { + return std::array{lambda(enum_constant[I]>{})...}; + } else { + return std::tuple{lambda(enum_constant[I]>{})...}; + } +} + +} // namespace magic_enum::detail + +// Checks is magic_enum supported compiler. +inline constexpr bool is_magic_enum_supported = detail::supported::value; + +template +using Enum = detail::enum_concept; + +// Checks whether T is an Unscoped enumeration type. +// Provides the member constant value which is equal to true, if T is an [Unscoped enumeration](https://en.cppreference.com/w/cpp/language/enum#Unscoped_enumeration) type. Otherwise, value is equal to false. +template +struct is_unscoped_enum : detail::is_unscoped_enum {}; + +template +inline constexpr bool is_unscoped_enum_v = is_unscoped_enum::value; + +// Checks whether T is an Scoped enumeration type. +// Provides the member constant value which is equal to true, if T is an [Scoped enumeration](https://en.cppreference.com/w/cpp/language/enum#Scoped_enumerations) type. Otherwise, value is equal to false. +template +struct is_scoped_enum : detail::is_scoped_enum {}; + +template +inline constexpr bool is_scoped_enum_v = is_scoped_enum::value; + +// If T is a complete enumeration type, provides a member typedef type that names the underlying type of T. +// Otherwise, if T is not an enumeration type, there is no member type. Otherwise (T is an incomplete enumeration type), the program is ill-formed. +template +struct underlying_type : detail::underlying_type {}; + +template +using underlying_type_t = typename underlying_type::type; + +template +using enum_constant = detail::enum_constant; + +// Returns type name of enum. +template +[[nodiscard]] constexpr auto enum_type_name() noexcept -> detail::enable_if_t { + constexpr string_view name = detail::type_name_v>; + static_assert(!name.empty(), "magic_enum::enum_type_name enum type does not have a name."); + + return name; +} + +// Returns number of enum values. +template +[[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_t { + return detail::count_v>; +} + +// Returns enum value at specified index. +// No bounds checking is performed: the behavior is undefined if index >= number of enum values. +template +[[nodiscard]] constexpr auto enum_value(std::size_t index) noexcept -> detail::enable_if_t> { + using D = std::decay_t; + + if constexpr (detail::is_sparse_v) { + return assert((index < detail::count_v)), detail::values_v[index]; + } else { + constexpr bool is_flag = detail::is_flags_v; + constexpr auto min = is_flag ? detail::log2(detail::min_v) : detail::min_v; + + return assert((index < detail::count_v)), detail::value(index); + } +} + +// Returns enum value at specified index. +template +[[nodiscard]] constexpr auto enum_value() noexcept -> detail::enable_if_t> { + using D = std::decay_t; + static_assert(I < detail::count_v, "magic_enum::enum_value out of range."); + + return enum_value(I); +} + +// Returns std::array with enum values, sorted by enum value. +template +[[nodiscard]] constexpr auto enum_values() noexcept -> detail::enable_if_t> { + return detail::values_v>; +} + +// Returns integer value from enum value. +template +[[nodiscard]] constexpr auto enum_integer(E value) noexcept -> detail::enable_if_t> { + return static_cast>(value); +} + +// Returns underlying value from enum value. +template +[[nodiscard]] constexpr auto enum_underlying(E value) noexcept -> detail::enable_if_t> { + return static_cast>(value); +} + +// Obtains index in enum values from enum value. +// Returns optional with index. +template +[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t> { + using D = std::decay_t; + using U = underlying_type_t; + + if constexpr (detail::count_v == 0) { + return {}; // Empty enum. + } else if constexpr (detail::is_sparse_v || detail::is_flags_v) { + return detail::constexpr_switch<&detail::values_v, detail::case_call_t::index>( + [](std::size_t i) { return optional{i}; }, + value, + detail::default_result_type_lambda>); + } else { + const auto v = static_cast(value); + if (v >= detail::min_v && v <= detail::max_v) { + return static_cast(v - detail::min_v); + } + return {}; // Invalid value or out of range. + } +} + +// Obtains index in enum values from static storage enum variable. +template +[[nodiscard]] constexpr auto enum_index() noexcept -> detail::enable_if_t { + constexpr auto index = enum_index>(V); + static_assert(index, "magic_enum::enum_index enum value does not have a index."); + + return *index; +} + +// Returns name from static storage enum variable. +// This version is much lighter on the compile times and is not restricted to the enum_range limitation. +template +[[nodiscard]] constexpr auto enum_name() noexcept -> detail::enable_if_t { + constexpr string_view name = detail::enum_name_v, V>; + static_assert(!name.empty(), "magic_enum::enum_name enum value does not have a name."); + + return name; +} + +// Returns name from enum value. +// If enum value does not have name or value out of range, returns empty string. +template +[[nodiscard]] constexpr auto enum_name(E value) noexcept -> detail::enable_if_t { + using D = std::decay_t; + + if (const auto i = enum_index(value)) { + return detail::names_v[*i]; + } + return {}; +} + +// Returns name from enum-flags value. +// If enum-flags value does not have name or value out of range, returns empty string. +template +[[nodiscard]] auto enum_flags_name(E value) -> detail::enable_if_t { + using D = std::decay_t; + using U = underlying_type_t; + + if constexpr (detail::is_flags_v) { + string name; + auto check_value = U{0}; + for (std::size_t i = 0; i < detail::count_v; ++i) { + if (const auto v = static_cast(enum_value(i)); (static_cast(value) & v) != 0) { + check_value |= v; + const auto n = detail::names_v[i]; + if (!name.empty()) { + name.append(1, '|'); + } + name.append(n.data(), n.size()); + } + } + + if (check_value != 0 && check_value == static_cast(value)) { + return name; + } + + return {}; // Invalid value or out of range. + } else { + return string{enum_name(value)}; + } +} + +// Returns std::array with names, sorted by enum value. +template +[[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_t> { + return detail::names_v>; +} + +// Returns std::array with pairs (value, name), sorted by enum value. +template +[[nodiscard]] constexpr auto enum_entries() noexcept -> detail::enable_if_t> { + return detail::entries_v>; +} + +// Allows you to write magic_enum::enum_cast("bar", magic_enum::case_insensitive); +inline constexpr auto case_insensitive = detail::case_insensitive{}; + +// Obtains enum value from integer value. +// Returns optional with enum value. +template +[[nodiscard]] constexpr auto enum_cast(underlying_type_t value) noexcept -> detail::enable_if_t>> { + using D = std::decay_t; + using U = underlying_type_t; + + if constexpr (detail::count_v == 0) { + return {}; // Empty enum. + } else if constexpr (detail::is_sparse_v) { + if constexpr (detail::is_flags_v) { + constexpr auto count = detail::count_v; + auto check_value = U{0}; + for (std::size_t i = 0; i < count; ++i) { + if (const auto v = static_cast(enum_value(i)); (value & v) != 0) { + check_value |= v; + } + } + + if (check_value != 0 && check_value == value) { + return static_cast(value); + } + return {}; // Invalid value or out of range. + } else { + return detail::constexpr_switch<&detail::values_v, detail::case_call_t::value>( + [](D v) { return optional{v}; }, + static_cast(value), + detail::default_result_type_lambda>); + } + } else { + constexpr auto min = detail::min_v; + constexpr auto max = detail::is_flags_v ? detail::values_ors() : detail::max_v; + + if (value >= min && value <= max) { + return static_cast(value); + } + return {}; // Invalid value or out of range. + } +} + +// Obtains enum value from name. +// Returns optional with enum value. +template > +[[nodiscard]] constexpr auto enum_cast(string_view value, [[maybe_unused]] BinaryPredicate&& p = {}) noexcept(detail::is_nothrow_invocable()) -> detail::enable_if_t>, BinaryPredicate> { + static_assert(std::is_invocable_r_v, "magic_enum::enum_cast requires bool(char, char) invocable predicate."); + using D = std::decay_t; + using U = underlying_type_t; + + if constexpr (detail::count_v == 0) { + return {}; // Empty enum. + } else if constexpr (detail::is_flags_v) { + auto result = U{0}; + while (!value.empty()) { + const auto d = detail::find(value, '|'); + const auto s = (d == string_view::npos) ? value : value.substr(0, d); + auto f = U{0}; + for (std::size_t i = 0; i < detail::count_v; ++i) { + if (detail::cmp_equal(s, detail::names_v[i], p)) { + f = static_cast(enum_value(i)); + result |= f; + break; + } + } + if (f == U{0}) { + return {}; // Invalid value or out of range. + } + value.remove_prefix((d == string_view::npos) ? value.size() : d + 1); + } + + if (result != U{0}) { + return static_cast(result); + } + return {}; // Invalid value or out of range. + } else if constexpr (detail::count_v > 0) { + if constexpr (detail::is_default_predicate()) { + return detail::constexpr_switch<&detail::names_v, detail::case_call_t::index>( + [](std::size_t i) { return optional{detail::values_v[i]}; }, + value, + detail::default_result_type_lambda>, + [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); }); + } else { + for (std::size_t i = 0; i < detail::count_v; ++i) { + if (detail::cmp_equal(value, detail::names_v[i], p)) { + return enum_value(i); + } + } + return {}; // Invalid value or out of range. + } + } +} + +// Checks whether enum contains enumerator with such enum value. +template +[[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_t { + using D = std::decay_t; + using U = underlying_type_t; + + return static_cast(enum_cast(static_cast(value))); +} + +// Checks whether enum contains enumerator with such integer value. +template +[[nodiscard]] constexpr auto enum_contains(underlying_type_t value) noexcept -> detail::enable_if_t { + using D = std::decay_t; + + return static_cast(enum_cast(value)); +} + +// Checks whether enum contains enumerator with such name. +template > +[[nodiscard]] constexpr auto enum_contains(string_view value, BinaryPredicate&& p = {}) noexcept(detail::is_nothrow_invocable()) -> detail::enable_if_t { + static_assert(std::is_invocable_r_v, "magic_enum::enum_contains requires bool(char, char) invocable predicate."); + using D = std::decay_t; + + return static_cast(enum_cast(value, std::forward(p))); +} + +template +constexpr auto enum_switch(Lambda&& lambda, E value) -> detail::enable_if_t { + using D = std::decay_t; + + return detail::constexpr_switch<&detail::values_v, detail::case_call_t::value>( + std::forward(lambda), + value, + detail::default_result_type_lambda); +} + +template +constexpr auto enum_switch(Lambda&& lambda, E value, Result&& result) -> detail::enable_if_t { + using D = std::decay_t; + + return detail::constexpr_switch<&detail::values_v, detail::case_call_t::value>( + std::forward(lambda), + value, + [&result] { return std::forward(result); }); +} + +template , typename Lambda> +constexpr auto enum_switch(Lambda&& lambda, string_view name, BinaryPredicate&& p = {}) -> detail::enable_if_t { + static_assert(std::is_invocable_r_v, "magic_enum::enum_switch requires bool(char, char) invocable predicate."); + using D = std::decay_t; + + if (const auto v = enum_cast(name, std::forward(p))) { + return enum_switch(std::forward(lambda), *v); + } + return detail::default_result_type_lambda(); +} + +template , typename Lambda> +constexpr auto enum_switch(Lambda&& lambda, string_view name, Result&& result, BinaryPredicate&& p = {}) -> detail::enable_if_t { + static_assert(std::is_invocable_r_v, "magic_enum::enum_switch requires bool(char, char) invocable predicate."); + using D = std::decay_t; + + if (const auto v = enum_cast(name, std::forward(p))) { + return enum_switch(std::forward(lambda), *v, std::forward(result)); + } + return std::forward(result); +} + +template +constexpr auto enum_switch(Lambda&& lambda, underlying_type_t value) -> detail::enable_if_t { + using D = std::decay_t; + + if (const auto v = enum_cast(value)) { + return enum_switch(std::forward(lambda), *v); + } + return detail::default_result_type_lambda(); +} + +template +constexpr auto enum_switch(Lambda&& lambda, underlying_type_t value, Result&& result) -> detail::enable_if_t { + using D = std::decay_t; + + if (const auto v = enum_cast(value)) { + return enum_switch(std::forward(lambda), *v, std::forward(result)); + } + return std::forward(result); +} + +template +constexpr auto enum_for_each(Lambda&& lambda) { + using D = std::decay_t; + static_assert(std::is_enum_v, "magic_enum::enum_for_each requires enum type."); + + return detail::for_each(std::forward(lambda), std::make_index_sequence>{}); +} + +namespace ostream_operators { + +template = 0> +std::basic_ostream& operator<<(std::basic_ostream& os, E value) { + using D = std::decay_t; + using U = underlying_type_t; + + if constexpr (detail::supported::value) { + if (const auto name = enum_flags_name(value); !name.empty()) { + for (const auto c : name) { + os.put(c); + } + return os; + } + } + return (os << static_cast(value)); +} + +template = 0> +std::basic_ostream& operator<<(std::basic_ostream& os, optional value) { + return value ? (os << *value) : os; +} + +} // namespace magic_enum::ostream_operators + +namespace istream_operators { + +template = 0> +std::basic_istream& operator>>(std::basic_istream& is, E& value) { + using D = std::decay_t; + + std::basic_string s; + is >> s; + if (const auto v = enum_cast(s)) { + value = *v; + } else { + is.setstate(std::basic_ios::failbit); + } + return is; +} + +} // namespace magic_enum::istream_operators + +namespace iostream_operators { + +using namespace ostream_operators; +using namespace istream_operators; + +} // namespace magic_enum::iostream_operators + +namespace bitwise_operators { + +template = 0> +constexpr E operator~(E rhs) noexcept { + return static_cast(~static_cast>(rhs)); +} + +template = 0> +constexpr E operator|(E lhs, E rhs) noexcept { + return static_cast(static_cast>(lhs) | static_cast>(rhs)); +} + +template = 0> +constexpr E operator&(E lhs, E rhs) noexcept { + return static_cast(static_cast>(lhs) & static_cast>(rhs)); +} + +template = 0> +constexpr E operator^(E lhs, E rhs) noexcept { + return static_cast(static_cast>(lhs) ^ static_cast>(rhs)); +} + +template = 0> +constexpr E& operator|=(E& lhs, E rhs) noexcept { + return lhs = (lhs | rhs); +} + +template = 0> +constexpr E& operator&=(E& lhs, E rhs) noexcept { + return lhs = (lhs & rhs); +} + +template = 0> +constexpr E& operator^=(E& lhs, E rhs) noexcept { + return lhs = (lhs ^ rhs); +} + +} // namespace magic_enum::bitwise_operators + +} // namespace magic_enum + +#if defined(__clang__) +# pragma clang diagnostic pop +#elif defined(__GNUC__) +# pragma GCC diagnostic pop +#elif defined(_MSC_VER) +# pragma warning(pop) +#endif + +#endif // NEARGYE_MAGIC_ENUM_HPP diff --git a/Utilities/safe_ptr.h b/Utilities/safe_ptr.h index 4cfaf44a..5ea9753d 100644 --- a/Utilities/safe_ptr.h +++ b/Utilities/safe_ptr.h @@ -52,3 +52,15 @@ public: return _ptr; } }; + +template +bool operator==(const safe_ptr& ptr, nullptr_t) +{ + return !(bool)ptr; +} + +template +bool operator!=(const safe_ptr& ptr, nullptr_t) +{ + return (bool)ptr; +} \ No newline at end of file