Struct FilePlayerDataStorage 

struct FilePlayerDataStorage {
    save_root: PathBuf,
    file_locks: SyncMutex<FxHashMap<PathBuf, Arc<AsyncMutex<()>>>>,
}

Fields

save_root: PathBuf

file_locks: SyncMutex<FxHashMap<PathBuf, Arc<AsyncMutex<()>>>>

Implementations

impl FilePlayerDataStorage

async fn new(save_root: PathBuf) -> Result<Self>

async fn save_domain(&self, domain: &str, player: &Player) -> Result<()>

async fn save_domain_data( &self, domain: &str, uuid: Uuid, data: &PersistentPlayerData, ) -> Result<()>

async fn load_domain( &self, domain: &str, uuid: Uuid, ) -> Result<Option<PersistentPlayerData>>

async fn load_global(&self, uuid: Uuid) -> Result<Option<GlobalPlayerData>>

async fn load_permission_subjects(&self) -> Result<PermissionSubjectIndex>

async fn load_known_players(&self) -> Result<KnownPlayers>

async fn read_known_players_file_locked(path: &Path) -> Result<KnownPlayers>

async fn save_known_players_if_current( &self, players: &KnownPlayers, is_current: impl FnOnce() -> bool + Send, ) -> Result<bool>

async fn save_global(&self, uuid: Uuid, data: &GlobalPlayerData) -> Result<()>

async fn save_permission_subjects( &self, subjects: &PermissionSubjectIndex, ) -> Result<()>

async fn load_player_permissions_file(&self) -> Result<PlayerPermissionsFile>

async fn read_player_permissions_file_locked( &self, path: &Path, ) -> Result<PlayerPermissionsFile>

async fn write_player_permissions_file_locked( &self, path: &Path, file: &PlayerPermissionsFile, ) -> Result<()>

fn global_dir(&self) -> PathBuf

fn global_players_dir(&self) -> PathBuf

fn player_permissions_file(&self) -> PathBuf

fn known_players_file(&self) -> PathBuf

fn domain_players_dir(&self, domain: &str) -> PathBuf

fn player_file(players_dir: &Path, uuid: Uuid) -> PathBuf

fn file_lock(&self, path: &Path) -> Arc<AsyncMutex<()>>

async fn write_atomic( &self, players_dir: &Path, uuid: Uuid, bytes: Vec<u8>, ) -> Result<()>

async fn write_atomic_path_locked( final_path: &Path, bytes: Vec<u8>, ) -> Result<()>

fn atomic_temp_path(path: &Path) -> PathBuf

fn atomic_backup_path(path: &Path) -> PathBuf

async fn recover_missing_atomic_path_locked(final_path: &Path) -> Result<bool>

async fn write_synced_file(path: &Path, bytes: &[u8]) -> Result<()>

async fn copy_synced_file(source: &Path, destination: &Path) -> Result<()>

async fn sync_parent(parent: &Path) -> Result<()>