pub struct SimbadResolver<R: Resolver> { /* private fields */ }Expand description
The cache-first resolver facade.
Generic over any Resolver backend (TAP, Sesame, offline, fake); the cache
backend is chosen at construction via CacheBackend and type-erased, so
the facade type does not carry it.
This example uses crate::OfflineResolver and seeds the cache directly, so
it runs without a network call — the cache-first lookup below never reaches
the resolver.
use simbad_resolver::{
AliasKind, CacheBackend, OfflineResolver, ObjectType, Resolution, ResolvedAlias,
ResolvedIdentity, ResolverConfig, SimbadResolver, TargetSource,
};
let config = ResolverConfig::new("guide.example");
let namespace = config.namespace;
let facade = SimbadResolver::new(OfflineResolver, CacheBackend::InMemory, config)?;
let m31 = ResolvedIdentity {
simbad_oid: Some(1_575_544),
primary_designation: "M 31".to_owned(),
common_name: Some("Andromeda Galaxy".to_owned()),
object_type: ObjectType::Galaxy,
otype_raw: "G".to_owned(),
ra_deg: 10.684_708,
dec_deg: 41.268_75,
v_mag: Some(3.44),
aliases: vec![ResolvedAlias::new("M 31", AliasKind::Designation)],
source: TargetSource::Seed,
};
facade.cache().upsert(&m31, &namespace).await?;
match facade.resolve("M31").await? {
Resolution::Resolved(target) => assert_eq!(target.primary_designation, "M 31"),
Resolution::Unresolved { .. } => unreachable!("seeded above"),
}Implementations§
Source§impl<R: Resolver> SimbadResolver<R>
impl<R: Resolver> SimbadResolver<R>
Sourcepub fn new(
resolver: R,
cache: CacheBackend,
config: ResolverConfig,
) -> Result<Self, Error>
pub fn new( resolver: R, cache: CacheBackend, config: ResolverConfig, ) -> Result<Self, Error>
Construct a facade from a resolver, a CacheBackend, and config.
§Errors
Returns Error if a built-in (CacheBackend::InMemory /
CacheBackend::File) store cannot be opened or initialised.
CacheBackend::Custom never fails here.
use simbad_resolver::{CacheBackend, OfflineResolver, ResolverConfig, SimbadResolver};
let facade = SimbadResolver::new(
OfflineResolver,
CacheBackend::InMemory,
ResolverConfig::new("my-app.targets"),
)?;Sourcepub fn cache(&self) -> &dyn Cache
pub fn cache(&self) -> &dyn Cache
Borrow the underlying cache (e.g. for seeding or enumeration).
use simbad_resolver::{CacheBackend, OfflineResolver, ResolverConfig, SimbadResolver};
let facade =
SimbadResolver::new(OfflineResolver, CacheBackend::InMemory, ResolverConfig::new("x"))?;
assert!(facade.cache().list().await?.is_empty(), "freshly constructed cache is empty");Sourcepub fn resolver(&self) -> &R
pub fn resolver(&self) -> &R
Borrow the underlying resolver (e.g. to inspect a fake’s call count in tests).
use simbad_resolver::{CacheBackend, OfflineResolver, ResolverConfig, SimbadResolver};
let facade =
SimbadResolver::new(OfflineResolver, CacheBackend::InMemory, ResolverConfig::new("x"))?;
let _resolver: &OfflineResolver = facade.resolver();Sourcepub async fn search(
&self,
query: &str,
limit: usize,
) -> Result<Vec<SearchHit>, Error>
pub async fn search( &self, query: &str, limit: usize, ) -> Result<Vec<SearchHit>, Error>
Local, network-free typeahead search over cached aliases.
Returns exact/prefix/substring matches (see Cache::search). When fuzzy
matching is enabled via ResolverConfig::with_fuzzy and fewer than
limit of those are found, the remaining slots are filled with token-set
similarity matches (crate::RANK_FUZZY), best score first. This fuzzy
matching does not affect Self::resolve, which stays exact-normalized.
This example seeds the cache directly (no resolver call needed) then searches it — see the guide for the full walkthrough.
use simbad_resolver::{
AliasKind, CacheBackend, ObjectType, OfflineResolver, ResolvedAlias, ResolvedIdentity,
ResolverConfig, SimbadResolver, TargetSource,
};
let config = ResolverConfig::new("example");
let namespace = config.namespace;
let facade = SimbadResolver::new(OfflineResolver, CacheBackend::InMemory, config)?;
let m31 = ResolvedIdentity {
simbad_oid: Some(1_575_544),
primary_designation: "M 31".to_owned(),
common_name: None,
object_type: ObjectType::Galaxy,
otype_raw: "G".to_owned(),
ra_deg: 10.684_708,
dec_deg: 41.268_75,
v_mag: Some(3.44),
aliases: vec![ResolvedAlias::new("M 31", AliasKind::Designation)],
source: TargetSource::Seed,
};
facade.cache().upsert(&m31, &namespace).await?;
let hits = facade.search("M 3", 5).await?; // prefix match
assert_eq!(hits[0].target.primary_designation, "M 31");Sourcepub async fn resolve(&self, query: &str) -> Result<Resolution, Error>
pub async fn resolve(&self, query: &str) -> Result<Resolution, Error>
Cache-first resolve. On a cache miss and when online is enabled, consult
the resolver, persist the result, and return it; otherwise return a typed
Resolution::Unresolved. Caldwell designations (C n) are translated
to their standard designation first and the original C n bound as an
alias.
See the struct-level example for a seeded, network-free
walkthrough, or crate::guide for the full task-oriented guide.
use simbad_resolver::{CacheBackend, OfflineResolver, Resolution, ResolverConfig, SimbadResolver};
let facade =
SimbadResolver::new(OfflineResolver, CacheBackend::InMemory, ResolverConfig::new("x"))?;
// Nothing cached and no network reachable (`OfflineResolver`): unresolved, not an error.
match facade.resolve("M31").await? {
Resolution::Resolved(_) => unreachable!("cache is empty"),
Resolution::Unresolved { query, .. } => assert_eq!(query, "M31"),
}Sourcepub async fn apply_override(
&self,
target_id: Uuid,
alias: &str,
) -> Result<Option<CachedTarget>, Error>
pub async fn apply_override( &self, target_id: Uuid, alias: &str, ) -> Result<Option<CachedTarget>, Error>
Bind a chosen canonical target as an authoritative user override, adding
alias and making the row sticky (source = user-override). Returns the
updated target, or None if target_id is unknown.
See crate::guide for a full “pin a target” walkthrough.
use simbad_resolver::{
AliasKind, CacheBackend, ObjectType, OfflineResolver, ResolvedAlias, ResolvedIdentity,
ResolverConfig, SimbadResolver, TargetSource,
};
let config = ResolverConfig::new("example");
let namespace = config.namespace;
let facade = SimbadResolver::new(OfflineResolver, CacheBackend::InMemory, config)?;
let m31 = ResolvedIdentity {
simbad_oid: Some(1_575_544),
primary_designation: "M 31".to_owned(),
common_name: None,
object_type: ObjectType::Galaxy,
otype_raw: "G".to_owned(),
ra_deg: 10.684_708,
dec_deg: 41.268_75,
v_mag: Some(3.44),
aliases: vec![ResolvedAlias::new("M 31", AliasKind::Designation)],
source: TargetSource::Seed,
};
let (id, _) = facade.cache().upsert(&m31, &namespace).await?;
let pinned = facade.apply_override(id, "My Andromeda").await?.expect("id is known");
assert_eq!(pinned.source, TargetSource::UserOverride);
assert!(pinned.aliases.iter().any(|a| a.alias == "My Andromeda"));