U19 Bundesliga 1st Group Stage Group E stats & predictions

(&mut self, directory: P) where P : AsRef, { let path = directory.as_ref(); let mut dir = std::fs::read_dir(path).unwrap(); while let Some(entry) = dir.next() { let entry = entry.unwrap(); let path = entry.path(); if path.extension().and_then(|ext| ext.to_str()) == Some("json") { self.load_file(path); } } } /// Reads `path` as a configuration file. pub fn load_file

(&mut self, path: P) where P : AsRef, { let file = File::open(path).unwrap(); let reader = BufReader::new(file); let config = serde_json::from_reader(reader).unwrap(); self.configs.insert(config.name.clone(), config); } /// Returns true if there exists at least one configuration named `name`. pub fn exists(&self, name: &str) -> bool { self.configs.contains_key(name) } /// Returns an iterator over all configurations. pub fn iter(&self) -> impl Iterator{ self.configs.values() } } <|file_sep|># BaseMod BaseMod is an extensible modding framework for tabletop RPGs. ## Overview BaseMod is an open-source framework for writing mods that can be used alongside [Base](https://github.com/jamesolivermiller/base) -- an open-source, cross-platform app that makes it easy to manage tabletop RPG campaigns. This crate provides everything needed to write your own modules that can be loaded into Base. ## Example rust fn main() { } ## License Licensed under either of * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0) * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT) at your option. ### Contribution Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you shall be dual licensed as above, without any additional terms or conditions. <|repo_name|>jamesolivermiller/basemod<|file_sep|>/src/game.rs use serde::{Deserialize}; /// Represents a game engine. #[derive(Debug)] pub struct GameEngine; /// Represents an instance of `GameEngine`. #[derive(Debug)] pub struct GameInstance; /// Represents game data. #[derive(Debug)] pub struct GameData; /// Represents configuration data. #[derive(Debug)] pub struct GameConfig; /// Represents persistent data associated with `GameInstance`. #[derive(Debug)] pub struct GameState; /// Represents transient data associated with `GameInstance`. #[derive(Debug)] pub struct GameContext; /// Represents game storage. #[derive(Debug)] pub struct GameStorage; /// Represents version information about `GameEngine`. #[derive(Debug)] pub struct GameVersion; /// Represents version information about `GameInstance`. #[derive(Debug)] pub struct InstanceVersion; <|repo_name|>jamesolivermiller/basemod<|file_sep|>/src/module.rs use serde::{Deserialize}; use std::path::{PathBuf}; /// Represents module metadata. #[derive(Debug)] pub struct ModuleMetadata { /// The name of this module. pub name: String, /// The version number of this module. pub version: String, /// The description of this module. pub description: Option, } impl ModuleMetadata { /// Creates new module metadata from a TOML-formatted string. /// /// # Example /// /// /// # use basemod::module::ModuleMetadata; /// /// // create metadata from TOML-formatted string /// let metadata = ModuleMetadata::from_toml_string( /// r#" /// name = "my-module" /// version = "0" /// description = "My cool new module." /// "#); /// /// assert_eq!(metadata.name(), "my-module"); /// /// assert_eq!(metadata.version(), "0"); /// /// assert_eq!(metadata.description(), Some("My cool new module.")); /// /// pub fn from_toml_string(s : &str) -> Self { let mut s : String = s.to_owned(); s.push_str("n"); Self::from_toml_str(&mut s.as_bytes()) .expect("invalid TOML") } // Create new module metadata from TOML-formatted bytes. // // # Example // // // # use basemod::module::ModuleMetadata; // // // create metadata from TOML-formatted string // let metadata = ModuleMetadata::from_toml_str( // b"name = "my-module"nversion = "0"ndescription = "My cool new module."" // ); // // assert_eq!(metadata.name(), "my-module"); // // assert_eq!(metadata.version(), "0"); // // assert_eq!(metadata.description(), Some("My cool new module.")); // // pub fn from_toml_str(s : &[u8]) -> Result{ Self::deserialize(toml::Deserializer::new(s)) } } impl<'de > serde::Deserialize<'de > for ModuleMetadata{ fn deserialize(deserializer : D ) -> Result where D : serde :: Deserializer<'de > { #[derive(Deserialize)]struct Inner{ name:String, version:String, description : Option, }; let inner : Inner = Deserialize :: deserialize(deserializer)?; Ok(ModuleMetadata{ name : inner.name, version : inner.version, description : inner.description, }) } } impl ModuleMetadata{ pub fn name(&self) -> &str{ &self.name } pub fn version(&self) -> &str{ &self.version } pub fn description(&self) -> Option<&str>{ self.description.as_deref() } } /// Represents a module implementation. /// /// # Example /// /// rust,no_run /// /// use basemod::{ /// game::{GameInstance}, /// helpers::{init_module}, /// module::{Module}, /// }; /// /// #[init_module] /// /// pub struct MyModule {} /// /// /// impl Module for MyModule{ /// /// type InstanceType = MyInstance; /// /// fn create_instance(&self , _engine : &GameInstance) -> Self :: InstanceType{ /// ///