cityjson 0.7.1

Types and accessor methods for representing semantic 3D city models in Rust, implementing the CityJSON specifications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

#![doc = include_str!("../README.md")]
pub(crate) mod backend;
mod cityjson;
pub mod error;
pub mod query;
pub mod raw;
pub mod relational;
pub mod resources;
pub mod symbols;
pub mod v2_0;

pub mod prelude {
    pub use super::{CityJSON, CityJSONVersion, CityModelType};
    pub use crate::error::{Error, Result};
    pub use crate::resources::{
        handles::{
            CityObjectHandle, GeometryHandle, GeometryTemplateHandle, MaterialHandle,
            SemanticHandle, TextureHandle,
        },
        mapping::{materials::MaterialMap, semantics::SemanticMap, textures::TextureMap},
        storage::{BorrowedStringStorage, OwnedStringStorage, StringStorage},
    };
}

use crate::error::{Error, Result};
use crate::resources::storage::StringStorage;
use crate::v2_0::VertexRef;
use std::fmt;

/// Whether a [`CityModel`](v2_0::citymodel::CityModel) is a full `CityJSON` document or a
/// single-feature `CityJSONFeature` (used for streaming and tiling).
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum CityModelType {
    #[default]
    CityJSON,
    CityJSONFeature,
}

impl fmt::Display for CityModelType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self {
            CityModelType::CityJSON => {
                write!(f, "CityJSON")
            }
            CityModelType::CityJSONFeature => {
                write!(f, "CityJSONFeature")
            }
        }
    }
}

impl CityModelType {
    fn _from_str(value: &str) -> error::Result<CityModelType> {
        match value {
            "CityJSON" => Ok(CityModelType::CityJSON),
            "CityJSONFeature" => Ok(CityModelType::CityJSONFeature),
            _ => Err(Error::UnsupportedVersion(
                value.to_string(),
                "CityJSON, CityJSONFeature".to_string(),
            )),
        }
    }
}

impl TryFrom<&str> for CityModelType {
    type Error = Error;

    fn try_from(value: &str) -> Result<Self> {
        CityModelType::_from_str(value)
    }
}

impl TryFrom<String> for CityModelType {
    type Error = Error;

    fn try_from(value: String) -> Result<Self> {
        CityModelType::_from_str(value.as_ref())
    }
}

/// Supported `CityJSON` spec versions. Currently only v2.0.
#[repr(C)]
#[derive(Debug, Default, PartialEq, Eq, Copy, Clone, Hash, PartialOrd, Ord)]
#[non_exhaustive]
pub enum CityJSONVersion {
    #[default]
    V2_0,
}

impl CityJSONVersion {
    fn _from_str(value: &str) -> error::Result<CityJSONVersion> {
        match value {
            "2.0" | "2.0.0" | "2.0.1" => Ok(CityJSONVersion::V2_0),
            _ => Err(Error::UnsupportedVersion(
                value.to_string(),
                "2.0, 2.0.0, 2.0.1".to_string(),
            )),
        }
    }
}

impl fmt::Display for CityJSONVersion {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self {
            CityJSONVersion::V2_0 => {
                write!(f, "2.0")
            }
        }
    }
}

impl TryFrom<&str> for CityJSONVersion {
    type Error = Error;

    fn try_from(value: &str) -> Result<Self> {
        CityJSONVersion::_from_str(value)
    }
}

impl TryFrom<String> for CityJSONVersion {
    type Error = Error;

    fn try_from(value: String) -> Result<Self> {
        CityJSONVersion::_from_str(value.as_ref())
    }
}

#[derive(Debug)]
#[non_exhaustive]
pub enum CityJSON<VR: VertexRef, SS: StringStorage> {
    V2_0(v2_0::CityModel<VR, SS>),
}

fn format_option<T: std::fmt::Display>(option: Option<&T>) -> String {
    option.map_or_else(|| "None".to_string(), std::string::ToString::to_string)
}