#[macro_use]
mod macros;
pub mod common;
pub mod crs;
pub mod cs;
pub mod datum;
pub mod number;
pub mod operation;
pub mod validate;
use std::{fmt, str::FromStr};
use serde::{Deserialize, Serialize};
use crate::{
crs::Crs,
datum::{Datum, DatumEnsemble, Ellipsoid, PrimeMeridian},
number::Number,
operation::{ConcatenatedOperation, SingleOperation},
validate::{Validate, ValidationError},
};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CoordinateMetadataType {
CoordinateMetadata,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CoordinateMetadata {
#[serde(rename = "$schema", skip_serializing_if = "Option::is_none")]
pub schema: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub r#type: Option<CoordinateMetadataType>,
pub crs: Crs,
#[serde(rename = "coordinateEpoch", skip_serializing_if = "Option::is_none")]
pub coordinate_epoch: Option<Number>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ProjJson {
Crs(Crs),
Datum(Box<Datum>),
DatumEnsemble(Box<DatumEnsemble>),
Ellipsoid(Box<Ellipsoid>),
PrimeMeridian(Box<PrimeMeridian>),
SingleOperation(SingleOperation),
ConcatenatedOperation(Box<ConcatenatedOperation>),
CoordinateMetadata(Box<CoordinateMetadata>),
}
#[derive(Debug)]
pub enum ProjJsonError {
Json(serde_json::Error),
Invalid(ValidationError),
}
impl fmt::Display for ProjJsonError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
ProjJsonError::Json(e) => e.fmt(f),
ProjJsonError::Invalid(e) => e.fmt(f),
}
}
}
impl std::error::Error for ProjJsonError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
ProjJsonError::Json(e) => Some(e),
ProjJsonError::Invalid(e) => Some(e),
}
}
}
impl From<serde_json::Error> for ProjJsonError {
fn from(e: serde_json::Error) -> Self {
ProjJsonError::Json(e)
}
}
impl From<ValidationError> for ProjJsonError {
fn from(e: ValidationError) -> Self {
ProjJsonError::Invalid(e)
}
}
impl FromStr for ProjJson {
type Err = ProjJsonError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let doc: ProjJson = serde_json::from_str(s)?;
doc.validate()?;
Ok(doc)
}
}
impl fmt::Display for ProjJson {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let json = if f.alternate() {
serde_json::to_string_pretty(self)
} else {
serde_json::to_string(self)
};
f.write_str(&json.map_err(|_| fmt::Error)?)
}
}