elemental-driver 0.2.0

Driver library for Elemental, providing implementations for interacting with different modloaders and game versions.
Documentation
use crate::error::Result;
use async_trait::async_trait;
use elemental_core::minecraft::MinecraftVersionId;
use elemental_schema::{fabric::ProfileJson, mojang::piston::PistonMetaData};

use crate::{
    driver::{DriverDescriptor, InstalledDriver},
    drivers::{
        fabric::{
            flavors::flavor_spec,
            source::{FabricEndpointOverrides, FabricEndpoints, FabricFlavor, FabricSource},
        },
        vanilla::source::VanillaSource,
    },
    families::version_json::{
        ProfiledVersionJsonDriver, ProfiledVersionJsonFamily, ProfiledVersionJsonFamilyExt,
        VanillaFallbackRemoteResolver,
    },
    loader_version::LoaderVersionId,
};

#[derive(Debug, Clone)]
pub struct FabricDriverFamily {
    flavor: FabricFlavor,
}

impl FabricDriverFamily {
    pub fn new(flavor: FabricFlavor) -> Self {
        Self { flavor }
    }

    fn flavor(&self) -> &FabricFlavor {
        &self.flavor
    }

    pub fn new_driver_with_overrides(
        &self,
        overrides: FabricEndpointOverrides,
    ) -> Result<FabricDriver> {
        Ok(self
            .clone()
            .build_driver(FabricSource::new(FabricEndpoints::with_endpoint_overrides(
                overrides,
            )?)))
    }
}

#[async_trait(?Send)]
impl ProfiledVersionJsonFamily for FabricDriverFamily {
    type Source = FabricSource;
    type RemoteResolver = super::prepared::FabricRemoteResolver;

    fn descriptor(&self) -> DriverDescriptor {
        flavor_spec(self.flavor()).descriptor()
    }

    fn default_source(&self) -> Result<Self::Source> {
        Ok(FabricSource::new(FabricEndpoints::for_flavor(
            self.flavor.clone(),
        )?))
    }

    fn remote_resolver(
        &self,
        vanilla_source: &VanillaSource,
        source: &Self::Source,
    ) -> Self::RemoteResolver {
        VanillaFallbackRemoteResolver::new(
            "fabric",
            vanilla_source.endpoints().clone(),
            source.endpoints().clone(),
        )
    }

    async fn profile(
        &self,
        source: &Self::Source,
        game_version: &MinecraftVersionId,
        loader_version: &LoaderVersionId,
    ) -> Result<ProfileJson> {
        source
            .profile_json(game_version.as_str(), loader_version.as_str())
            .await
    }

    fn merge_profile(
        &self,
        base_metadata: PistonMetaData,
        profile: ProfileJson,
    ) -> Result<PistonMetaData> {
        flavor_spec(self.flavor()).merge_profile(base_metadata, profile)
    }

    fn local_metadata_needs_refresh(
        &self,
        metadata: &PistonMetaData,
        game_version: &MinecraftVersionId,
        loader_version: &LoaderVersionId,
    ) -> bool {
        flavor_spec(self.flavor()).local_metadata_needs_refresh(
            metadata,
            game_version,
            loader_version,
        )
    }

    fn inspect_installed(&self, metadata: &PistonMetaData) -> Option<InstalledDriver> {
        let flavor = flavor_spec(self.flavor());
        let driver_version = flavor.inspect_driver_version(metadata)?;

        Some(InstalledDriver::version_json(
            flavor.descriptor(),
            metadata,
            Some(driver_version),
        ))
    }
}

pub type FabricDriver = ProfiledVersionJsonDriver<FabricDriverFamily>;