Enum SemanticSurfaceType 

pub enum SemanticSurfaceType {
    Known(KnownSemanticSurfaceType),
    Extension(String),
}

The type member of a Semantic Object (§ 3.3 Semantics of geometric primitives).

Known covers the surface types above. Any other value is a CityJSON Extension semantic surface, which the spec requires to start with "+" (eg "+ThermalSurface", § 8.5); Extension carries that string verbatim so it round-trips byte for byte.

This nests the known names inside their own unit-only enum rather than mixing unit variants with Extension(String) directly in one flat #[serde(untagged)] enum – see crate::CityObjectType’s doc comment for why a flat mix cannot round-trip (a unit variant under untagged (de)serializes as null, not its name; this was verified empirically while building CityObjectType, which has the identical shape).

Match on the value, not on a reference

Each known name is also available flat, as an associated const (eg SemanticSurfaceType::RoofSurface) – see the impl block below for the full list. They are consts, not variants, and that distinction bites exactly once, silently:

match *t {
    SemanticSurfaceType::RoofSurface => { /* .. */ }
    SemanticSurfaceType::Extension(ref s) => { let _ = s; }
    _ => {}
}

Note the *. match t where t: &SemanticSurfaceType, or match &t, is E0308 (“mismatched types”), and rustc’s fix-it suggests renaming the arm to a fresh binding – which compiles, and silently turns that arm into a catch-all matching everything, because RoofSurface in pattern position reads as a new irrefutable binding rather than as the constant. The _ arm is still required: Known and Extension are the real variants, so the known names alone are not exhaustive.

Variants

Known(KnownSemanticSurfaceType)

Extension(String)

Not a core CityJSON semantic surface type: a CityJSON Extension surface type, always spelled with a leading "+".

Implementations

impl SemanticSurfaceType

Flat, spec-spelling access to each known variant (eg SemanticSurfaceType::RoofSurface); see crate::CityObjectType’s equivalent block for why these are associated consts rather than enum variants – and, on SemanticSurfaceType, for why they must be matched on a value rather than on a reference.

pub const RoofSurface: SemanticSurfaceType

pub const GroundSurface: SemanticSurfaceType

pub const WallSurface: SemanticSurfaceType

pub const ClosureSurface: SemanticSurfaceType

pub const OuterCeilingSurface: SemanticSurfaceType

pub const OuterFloorSurface: SemanticSurfaceType

pub const Window: SemanticSurfaceType

pub const Door: SemanticSurfaceType

pub const InteriorWallSurface: SemanticSurfaceType

pub const CeilingSurface: SemanticSurfaceType

pub const FloorSurface: SemanticSurfaceType

pub const WaterSurface: SemanticSurfaceType

pub const WaterGroundSurface: SemanticSurfaceType

pub const WaterClosureSurface: SemanticSurfaceType

pub const TrafficArea: SemanticSurfaceType

pub const AuxiliaryTrafficArea: SemanticSurfaceType

pub const TransportationMarking: SemanticSurfaceType

pub const TransportationHole: SemanticSurfaceType

Trait Implementations

impl Clone for SemanticSurfaceType

fn clone(&self) -> SemanticSurfaceType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SemanticSurfaceType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SemanticSurfaceType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SemanticSurfaceType

impl Hash for SemanticSurfaceType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SemanticSurfaceType

fn eq(&self, other: &SemanticSurfaceType) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for SemanticSurfaceType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SemanticSurfaceType