use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ObjectType {
Galaxy,
PlanetaryNebula,
EmissionNebula,
ReflectionNebula,
DarkNebula,
OpenCluster,
GlobularCluster,
SupernovaRemnant,
GalaxyCluster,
DoubleStar,
Asterism,
Other,
}
impl ObjectType {
#[must_use]
pub fn as_wire(self) -> &'static str {
match self {
Self::Galaxy => "galaxy",
Self::PlanetaryNebula => "planetary_nebula",
Self::EmissionNebula => "emission_nebula",
Self::ReflectionNebula => "reflection_nebula",
Self::DarkNebula => "dark_nebula",
Self::OpenCluster => "open_cluster",
Self::GlobularCluster => "globular_cluster",
Self::SupernovaRemnant => "supernova_remnant",
Self::GalaxyCluster => "galaxy_cluster",
Self::DoubleStar => "double_star",
Self::Asterism => "asterism",
Self::Other => "other",
}
}
#[must_use]
pub fn from_wire(s: &str) -> Self {
match s {
"galaxy" => Self::Galaxy,
"planetary_nebula" => Self::PlanetaryNebula,
"emission_nebula" => Self::EmissionNebula,
"reflection_nebula" => Self::ReflectionNebula,
"dark_nebula" => Self::DarkNebula,
"open_cluster" => Self::OpenCluster,
"globular_cluster" => Self::GlobularCluster,
"supernova_remnant" => Self::SupernovaRemnant,
"galaxy_cluster" => Self::GalaxyCluster,
"double_star" => Self::DoubleStar,
"asterism" => Self::Asterism,
_ => Self::Other,
}
}
}
#[must_use]
pub fn map_otype(otype: &str) -> ObjectType {
match otype.trim() {
"G" | "GiC" | "GiG" | "GiP" | "IG" | "PaG" | "AGN" | "SBG" | "rG" | "LSB" | "AG?"
| "EmG" | "BiC" | "H2G" | "Sy1" | "Sy2" | "SyG" | "Galaxy" => ObjectType::Galaxy,
"PN" | "PN?" | "pA*" | "PlanetaryNebula" => ObjectType::PlanetaryNebula,
"HII" | "EmO" | "ISM" | "RNe?" | "EmissionNebula" => ObjectType::EmissionNebula,
"RNe" | "ReflectionNebula" => ObjectType::ReflectionNebula,
"DNe" | "MoC" | "glb" | "cor" | "GNe" | "DarkNebula" => ObjectType::DarkNebula,
"OpC" | "Cl*" | "As*" | "OpenCluster" => ObjectType::OpenCluster,
"GlC" | "GlobularCluster" => ObjectType::GlobularCluster,
"SNR" | "SNR?" | "SuperNovaRemnant" | "SupernovaRemnant" => ObjectType::SupernovaRemnant,
"ClG" | "GrG" | "CGG" | "SCG" | "GalaxyCluster" => ObjectType::GalaxyCluster,
"**" | "**?" | "EB*" | "SB*" | "DoubleStar" => ObjectType::DoubleStar,
"Asterism" => ObjectType::Asterism,
_ => ObjectType::Other,
}
}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TargetSource {
Seed,
Resolved,
#[serde(rename = "user-override")]
UserOverride,
}
impl TargetSource {
#[must_use]
pub fn as_wire(self) -> &'static str {
match self {
Self::Seed => "seed",
Self::Resolved => "resolved",
Self::UserOverride => "user-override",
}
}
#[must_use]
pub fn from_wire(s: &str) -> Option<Self> {
match s {
"seed" => Some(Self::Seed),
"resolved" => Some(Self::Resolved),
"user-override" => Some(Self::UserOverride),
_ => None,
}
}
#[must_use]
pub fn precedence(self) -> u8 {
match self {
Self::Seed => 0,
Self::Resolved => 1,
Self::UserOverride => 2,
}
}
#[must_use]
pub fn may_overwrite(self, existing: Self) -> bool {
self.precedence() >= existing.precedence()
}
}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AliasKind {
Designation,
CommonName,
User,
}
impl AliasKind {
#[must_use]
pub fn as_wire(self) -> &'static str {
match self {
Self::Designation => "designation",
Self::CommonName => "common_name",
Self::User => "user",
}
}
#[must_use]
pub fn from_wire(s: &str) -> Self {
match s {
"common_name" => Self::CommonName,
"user" => Self::User,
_ => Self::Designation,
}
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct ResolvedAlias {
pub alias: String,
pub normalized: String,
pub kind: AliasKind,
}
impl ResolvedAlias {
#[must_use]
pub fn new(alias: impl Into<String>, kind: AliasKind) -> Self {
let alias = alias.into();
let normalized = crate::normalize::normalize(&alias);
Self { alias, normalized, kind }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ResolvedIdentity {
pub simbad_oid: Option<i64>,
pub primary_designation: String,
pub common_name: Option<String>,
pub object_type: ObjectType,
pub otype_raw: String,
pub ra_deg: f64,
pub dec_deg: f64,
pub v_mag: Option<f64>,
pub aliases: Vec<ResolvedAlias>,
pub source: TargetSource,
}
impl ResolvedIdentity {
pub fn position(&self) -> skymath::Result<skymath::Equatorial> {
skymath::Equatorial::j2000(
skymath::Angle::from_degrees(self.ra_deg),
skymath::Angle::from_degrees(self.dec_deg),
)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PositionMatch {
pub identity: ResolvedIdentity,
pub separation_deg: f64,
}
impl PositionMatch {
pub fn position(&self) -> skymath::Result<skymath::Equatorial> {
self.identity.position()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn map_otype_maps_known_codes() {
assert_eq!(map_otype("G"), ObjectType::Galaxy);
assert_eq!(map_otype("PN"), ObjectType::PlanetaryNebula);
assert_eq!(map_otype("HII"), ObjectType::EmissionNebula);
assert_eq!(map_otype("RNe"), ObjectType::ReflectionNebula);
assert_eq!(map_otype("DNe"), ObjectType::DarkNebula);
assert_eq!(map_otype("OpC"), ObjectType::OpenCluster);
assert_eq!(map_otype("GlC"), ObjectType::GlobularCluster);
assert_eq!(map_otype("SNR"), ObjectType::SupernovaRemnant);
assert_eq!(map_otype("ClG"), ObjectType::GalaxyCluster);
assert_eq!(map_otype("**"), ObjectType::DoubleStar);
assert_eq!(map_otype("Asterism"), ObjectType::Asterism);
}
#[test]
fn map_otype_covers_full_otype_vocabulary() {
use ObjectType as OT;
let cases: &[(&str, ObjectType)] = &[
("G", OT::Galaxy),
("GiC", OT::Galaxy),
("GiG", OT::Galaxy),
("GiP", OT::Galaxy),
("IG", OT::Galaxy),
("PaG", OT::Galaxy),
("AGN", OT::Galaxy),
("SBG", OT::Galaxy),
("rG", OT::Galaxy),
("LSB", OT::Galaxy),
("AG?", OT::Galaxy),
("EmG", OT::Galaxy),
("BiC", OT::Galaxy),
("H2G", OT::Galaxy),
("Sy1", OT::Galaxy),
("Sy2", OT::Galaxy),
("SyG", OT::Galaxy),
("Galaxy", OT::Galaxy),
("PN", OT::PlanetaryNebula),
("PN?", OT::PlanetaryNebula),
("pA*", OT::PlanetaryNebula),
("PlanetaryNebula", OT::PlanetaryNebula),
("HII", OT::EmissionNebula),
("EmO", OT::EmissionNebula),
("ISM", OT::EmissionNebula),
("RNe?", OT::EmissionNebula),
("EmissionNebula", OT::EmissionNebula),
("RNe", OT::ReflectionNebula),
("ReflectionNebula", OT::ReflectionNebula),
("DNe", OT::DarkNebula),
("MoC", OT::DarkNebula),
("glb", OT::DarkNebula),
("cor", OT::DarkNebula),
("GNe", OT::DarkNebula),
("DarkNebula", OT::DarkNebula),
("OpC", OT::OpenCluster),
("Cl*", OT::OpenCluster),
("As*", OT::OpenCluster),
("OpenCluster", OT::OpenCluster),
("GlC", OT::GlobularCluster),
("GlobularCluster", OT::GlobularCluster),
("SNR", OT::SupernovaRemnant),
("SNR?", OT::SupernovaRemnant),
("SuperNovaRemnant", OT::SupernovaRemnant),
("SupernovaRemnant", OT::SupernovaRemnant),
("ClG", OT::GalaxyCluster),
("GrG", OT::GalaxyCluster),
("CGG", OT::GalaxyCluster),
("SCG", OT::GalaxyCluster),
("GalaxyCluster", OT::GalaxyCluster),
("**", OT::DoubleStar),
("**?", OT::DoubleStar),
("EB*", OT::DoubleStar),
("SB*", OT::DoubleStar),
("DoubleStar", OT::DoubleStar),
("Asterism", OT::Asterism),
];
for (code, want) in cases {
assert_eq!(map_otype(code), *want, "otype code {code:?} should map to {want:?}");
}
}
#[test]
fn map_otype_unknown_is_other() {
assert_eq!(map_otype("ZZZ"), ObjectType::Other);
assert_eq!(map_otype(""), ObjectType::Other);
assert_eq!(map_otype("Star"), ObjectType::Other);
}
#[test]
fn map_otype_trims_whitespace() {
assert_eq!(map_otype(" G "), ObjectType::Galaxy);
}
#[test]
fn object_type_serializes_snake_case() {
assert_eq!(
serde_json::to_string(&ObjectType::PlanetaryNebula).unwrap(),
"\"planetary_nebula\""
);
assert_eq!(
serde_json::to_string(&ObjectType::GalaxyCluster).unwrap(),
"\"galaxy_cluster\""
);
assert_eq!(serde_json::to_string(&ObjectType::Other).unwrap(), "\"other\"");
}
#[test]
fn object_type_wire_round_trips() {
for ot in [
ObjectType::Galaxy,
ObjectType::PlanetaryNebula,
ObjectType::EmissionNebula,
ObjectType::ReflectionNebula,
ObjectType::DarkNebula,
ObjectType::OpenCluster,
ObjectType::GlobularCluster,
ObjectType::SupernovaRemnant,
ObjectType::GalaxyCluster,
ObjectType::DoubleStar,
ObjectType::Asterism,
ObjectType::Other,
] {
assert_eq!(ObjectType::from_wire(ot.as_wire()), ot);
}
assert_eq!(ObjectType::from_wire("bogus"), ObjectType::Other);
}
#[test]
fn target_source_user_override_is_hyphenated() {
assert_eq!(
serde_json::to_string(&TargetSource::UserOverride).unwrap(),
"\"user-override\""
);
assert_eq!(serde_json::to_string(&TargetSource::Seed).unwrap(), "\"seed\"");
assert_eq!(serde_json::to_string(&TargetSource::Resolved).unwrap(), "\"resolved\"");
assert_eq!(
serde_json::from_str::<TargetSource>("\"user-override\"").unwrap(),
TargetSource::UserOverride
);
}
#[test]
fn target_source_wire_round_trips() {
for src in [TargetSource::Seed, TargetSource::Resolved, TargetSource::UserOverride] {
assert_eq!(TargetSource::from_wire(src.as_wire()), Some(src));
}
assert_eq!(TargetSource::from_wire("bogus"), None);
}
#[test]
fn target_source_precedence_and_overwrite() {
assert!(TargetSource::Seed.precedence() < TargetSource::Resolved.precedence());
assert!(TargetSource::Resolved.precedence() < TargetSource::UserOverride.precedence());
assert!(TargetSource::Resolved.may_overwrite(TargetSource::Seed));
assert!(TargetSource::Resolved.may_overwrite(TargetSource::Resolved));
assert!(TargetSource::UserOverride.may_overwrite(TargetSource::Resolved));
assert!(!TargetSource::Seed.may_overwrite(TargetSource::UserOverride));
assert!(!TargetSource::Resolved.may_overwrite(TargetSource::UserOverride));
}
#[test]
fn alias_kind_wire_round_trips() {
for kind in [AliasKind::Designation, AliasKind::CommonName, AliasKind::User] {
assert_eq!(AliasKind::from_wire(kind.as_wire()), kind);
}
assert_eq!(AliasKind::from_wire("bogus"), AliasKind::Designation);
}
#[test]
fn resolved_alias_computes_normalized_form() {
let alias = ResolvedAlias::new("M31", AliasKind::Designation);
assert_eq!(alias.alias, "M31");
assert_eq!(alias.normalized, "m 31");
}
}