Skip to content

Commit dcf0939

Browse files
WaridleyWaridley
committed
refactor VariantVisitor::visit_map for readability
1 parent 070acea commit dcf0939

File tree

1 file changed

+177
-147
lines changed

1 file changed

+177
-147
lines changed

‎gdnative-core/src/core_types/variant.rs

Lines changed: 177 additions & 147 deletions
Original file line numberDiff line numberDiff line change
@@ -2189,7 +2189,7 @@ pub mod serde {
21892189
{
21902190
if v == "Nil" {
21912191
//`VariantDispatch::Nil` could be represented as the string "Nil"
2192-
return Ok(Variant::new())
2192+
return Ok(Variant::new());
21932193
}
21942194
Ok(v.to_variant())
21952195
}
@@ -2224,14 +2224,14 @@ pub mod serde {
22242224
{
22252225
Ok(().to_variant())
22262226
}
2227-
2227+
22282228
fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
22292229
where
22302230
D: Deserializer<'de>,
22312231
{
22322232
deserializer.deserialize_any(VariantVisitor)
22332233
}
2234-
2234+
22352235
fn visit_seq<A>(self, seq: A) -> Result<Self::Value, <A as SeqAccess<'de>>::Error>
22362236
where
22372237
A: SeqAccess<'de>,
@@ -2241,7 +2241,7 @@ pub mod serde {
22412241
.visit_seq(seq)
22422242
.map(VariantArray::<Unique>::owned_to_variant)
22432243
}
2244-
2244+
22452245
fn visit_map<A>(self, map: A) -> Result<Self::Value, <A as MapAccess<'de>>::Error>
22462246
where
22472247
A: MapAccess<'de>,
@@ -2250,157 +2250,26 @@ pub mod serde {
22502250
let len = dict.len();
22512251
if len == 1 {
22522252
let (key, value) = dict.iter().next().unwrap();
2253-
if let Some(s) = key.try_to_string() {
2254-
if s == value.get_type().name() {
2255-
return Ok(value);
2256-
} else if s == "elements" {
2257-
match value.dispatch() {
2258-
VariantDispatch::Vector3Array(arr) => {
2259-
if arr.len() == 3 {
2260-
return Ok(Basis {
2261-
elements: [arr.get(0), arr.get(1), arr.get(2)],
2262-
}
2263-
.to_variant());
2264-
}
2265-
}
2266-
VariantDispatch::VariantArray(arr) => {
2267-
if arr.len() == 3 {
2268-
if let Some(e0) = arr.get(0).try_to_vector3() {
2269-
if let Some(e1) = arr.get(1).try_to_vector3() {
2270-
if let Some(e2) = arr.get(2).try_to_vector3() {
2271-
return Ok(Basis {
2272-
elements: [e0, e1, e2],
2273-
}
2274-
.to_variant());
2275-
}
2276-
}
2277-
}
2278-
}
2279-
}
2280-
_ => {}
2281-
}
2282-
} else if value.get_type() == ().to_variant().get_type() {
2283-
match &*s {
2284-
"Object" => return Ok(Variant::new()),
2285-
"Rid" => return Ok(Rid::new().to_variant()),
2286-
_ => {}
2287-
}
2288-
} else if let Some(arr) = value.try_to_array() {
2289-
if let Some(s) = s.strip_suffix("Array") {
2290-
match s {
2291-
"Variant" => return Ok(value), //for completeness, should have been handled by first condition
2292-
"Byte" => {
2293-
return Ok(ByteArray::from_variant_array(&arr).to_variant())
2294-
}
2295-
"Int32" => {
2296-
return Ok(Int32Array::from_variant_array(&arr).to_variant())
2297-
}
2298-
"Float32" => {
2299-
return Ok(Float32Array::from_variant_array(&arr).to_variant())
2300-
}
2301-
"Vector2" => {
2302-
return Ok(Vector2Array::from_variant_array(&arr).to_variant())
2303-
}
2304-
"Vector3" => {
2305-
return Ok(Vector3Array::from_variant_array(&arr).to_variant())
2306-
}
2307-
"Color" => {
2308-
return Ok(ColorArray::from_variant_array(&arr).to_variant())
2309-
}
2310-
_ => {}
2311-
}
2312-
}
2253+
if let Some(key) = key.try_to_string() {
2254+
if let Some(v) = string_tagged(&key, value) {
2255+
return Ok(v);
23132256
}
2314-
} else if let Some(i) = key.try_to_i64() {
2315-
if i == value.get_type() as i64 {
2316-
return Ok(value);
2317-
} else if value.get_type() == ().to_variant().get_type() {
2318-
if i == VariantType::Object as i64 {
2319-
return Ok(Variant::new());
2320-
} else if i == VariantType::Rid as i64 {
2321-
return Ok(Rid::new().to_variant());
2322-
}
2323-
} else if let Some(arr) = value.try_to_array() {
2324-
if i == VariantType::ByteArray as i64 {
2325-
return Ok(ByteArray::from_variant_array(&arr).to_variant());
2326-
} else if i == VariantType::Int32Array as i64 {
2327-
return Ok(Int32Array::from_variant_array(&arr).to_variant());
2328-
} else if i == VariantType::Float32Array as i64 {
2329-
return Ok(Float32Array::from_variant_array(&arr).to_variant());
2330-
} else if i == VariantType::Vector2Array as i64 {
2331-
return Ok(Vector2Array::from_variant_array(&arr).to_variant());
2332-
} else if i == VariantType::Vector3Array as i64 {
2333-
return Ok(Vector3Array::from_variant_array(&arr).to_variant());
2334-
} else if i == VariantType::ColorArray as i64 {
2335-
return Ok(ColorArray::from_variant_array(&arr).to_variant());
2336-
}
2257+
} else if let Some(key) = key.try_to_i64() {
2258+
if let Some(v) = int_tagged(key, value) {
2259+
return Ok(v);
23372260
}
23382261
}
23392262
} else if len == 2 {
2340-
if let Some(x) = dict.get("x").try_to_f64() {
2341-
if let Some(y) = dict.get("y").try_to_f64() {
2342-
return Ok(Vector2::new(x as f32, y as f32).to_variant());
2343-
}
2344-
} else {
2345-
if let Some(normal) = dict.get("normal").try_to_vector3() {
2346-
if let Some(d) = dict.get("d").try_to_f64() {
2347-
return Ok(Plane::new(normal, d as f32).to_variant());
2348-
}
2349-
}
2350-
match dict.get("position").dispatch() {
2351-
VariantDispatch::Vector2(position) => {
2352-
if let Some(size) = dict.get("size").try_to_vector2() {
2353-
return Ok(Rect2 { position, size }.to_variant());
2354-
}
2355-
}
2356-
VariantDispatch::Vector3(position) => {
2357-
if let Some(size) = dict.get("size").try_to_vector3() {
2358-
return Ok(Aabb { position, size }.to_variant());
2359-
}
2360-
}
2361-
_ => {}
2362-
}
2263+
if let Some(v) = vec2_plane_rect2_or_aabb(&dict) {
2264+
return Ok(v);
23632265
}
23642266
} else if len == 3 {
2365-
match dict.get("x").dispatch() {
2366-
VariantDispatch::F64(x) => {
2367-
if let Some(y) = dict.get("y").try_to_f64() {
2368-
if let Some(z) = dict.get("z").try_to_f64() {
2369-
return Ok(Vector3::new(x as f32, y as f32, z as f32).to_variant());
2370-
}
2371-
}
2372-
}
2373-
VariantDispatch::Vector2(x) => {
2374-
if let Some(y) = dict.get("y").try_to_vector2() {
2375-
if let Some(origin) = dict.get("origin").try_to_vector2() {
2376-
return Ok(Transform2D { x, y, origin }.to_variant());
2377-
}
2378-
}
2379-
}
2380-
_ => {}
2267+
if let Some(v) = vec3_or_xform2d(&dict) {
2268+
return Ok(v);
23812269
}
23822270
} else if len == 4 {
2383-
if let Some(x) = dict.get("x").try_to_f64() {
2384-
if let Some(y) = dict.get("y").try_to_f64() {
2385-
if let Some(z) = dict.get("z").try_to_f64() {
2386-
if let Some(w) = dict.get("w").try_to_f64() {
2387-
return Ok(
2388-
Quat::new(x as f32, y as f32, z as f32, w as f32).to_variant()
2389-
);
2390-
}
2391-
}
2392-
}
2393-
} else if let Some(r) = dict.get("r").try_to_f64() {
2394-
if let Some(g) = dict.get("g").try_to_f64() {
2395-
if let Some(b) = dict.get("b").try_to_f64() {
2396-
if let Some(a) = dict.get("a").try_to_f64() {
2397-
return Ok(Color::from_rgba(
2398-
r as f32, g as f32, b as f32, a as f32,
2399-
)
2400-
.to_variant());
2401-
}
2402-
}
2403-
}
2271+
if let Some(v) = quat_or_color(&dict) {
2272+
return Ok(v);
24042273
}
24052274
}
24062275

@@ -2417,6 +2286,167 @@ pub mod serde {
24172286
deserializer.deserialize_any(VariantVisitor)
24182287
}
24192288
}
2289+
2290+
fn string_tagged(key: &str, value: Variant) -> Option<Variant> {
2291+
let s = key;
2292+
if s == value.get_type().name() {
2293+
return Some(value);
2294+
} else if s == "elements" {
2295+
match value.dispatch() {
2296+
VariantDispatch::Vector3Array(arr) => {
2297+
if arr.len() == 3 {
2298+
return Some(
2299+
Basis {
2300+
elements: [arr.get(0), arr.get(1), arr.get(2)],
2301+
}
2302+
.to_variant(),
2303+
);
2304+
}
2305+
}
2306+
VariantDispatch::VariantArray(arr) => {
2307+
if arr.len() == 3 {
2308+
if let Some(e0) = arr.get(0).try_to_vector3() {
2309+
if let Some(e1) = arr.get(1).try_to_vector3() {
2310+
if let Some(e2) = arr.get(2).try_to_vector3() {
2311+
return Some(
2312+
Basis {
2313+
elements: [e0, e1, e2],
2314+
}
2315+
.to_variant(),
2316+
);
2317+
}
2318+
}
2319+
}
2320+
}
2321+
}
2322+
_ => {}
2323+
}
2324+
} else if value.get_type() == ().to_variant().get_type() {
2325+
match &*s {
2326+
"Object" => return Some(Variant::new()),
2327+
"Rid" => return Some(Rid::new().to_variant()),
2328+
_ => {}
2329+
}
2330+
} else if let Some(arr) = value.try_to_array() {
2331+
if let Some(s) = s.strip_suffix("Array") {
2332+
match s {
2333+
"Variant" => return Some(value), //for completeness, should have been handled by first condition
2334+
"Byte" => return Some(ByteArray::from_variant_array(&arr).to_variant()),
2335+
"Int32" => return Some(Int32Array::from_variant_array(&arr).to_variant()),
2336+
"Float32" => return Some(Float32Array::from_variant_array(&arr).to_variant()),
2337+
"Vector2" => return Some(Vector2Array::from_variant_array(&arr).to_variant()),
2338+
"Vector3" => return Some(Vector3Array::from_variant_array(&arr).to_variant()),
2339+
"Color" => return Some(ColorArray::from_variant_array(&arr).to_variant()),
2340+
_ => {}
2341+
}
2342+
}
2343+
}
2344+
None
2345+
}
2346+
2347+
fn int_tagged(key: i64, value: Variant) -> Option<Variant> {
2348+
let i = key;
2349+
if i == value.get_type() as i64 {
2350+
return Some(value);
2351+
} else if value.get_type() == ().to_variant().get_type() {
2352+
if i == VariantType::Object as i64 {
2353+
return Some(Variant::new());
2354+
} else if i == VariantType::Rid as i64 {
2355+
return Some(Rid::new().to_variant());
2356+
}
2357+
} else if let Some(arr) = value.try_to_array() {
2358+
if i == VariantType::ByteArray as i64 {
2359+
return Some(ByteArray::from_variant_array(&arr).to_variant());
2360+
} else if i == VariantType::Int32Array as i64 {
2361+
return Some(Int32Array::from_variant_array(&arr).to_variant());
2362+
} else if i == VariantType::Float32Array as i64 {
2363+
return Some(Float32Array::from_variant_array(&arr).to_variant());
2364+
} else if i == VariantType::Vector2Array as i64 {
2365+
return Some(Vector2Array::from_variant_array(&arr).to_variant());
2366+
} else if i == VariantType::Vector3Array as i64 {
2367+
return Some(Vector3Array::from_variant_array(&arr).to_variant());
2368+
} else if i == VariantType::ColorArray as i64 {
2369+
return Some(ColorArray::from_variant_array(&arr).to_variant());
2370+
}
2371+
}
2372+
None
2373+
}
2374+
2375+
fn vec2_plane_rect2_or_aabb(dict: &Dictionary<Unique>) -> Option<Variant> {
2376+
if let Some(x) = get_f64(&dict, "x") {
2377+
if let Some(y) = get_f64(&dict, "y") {
2378+
return Some(Vector2::new(x as f32, y as f32).to_variant());
2379+
}
2380+
} else {
2381+
if let Some(normal) = dict.get("normal").try_to_vector3() {
2382+
if let Some(d) = get_f64(&dict, "d") {
2383+
return Some(Plane::new(normal, d as f32).to_variant());
2384+
}
2385+
}
2386+
match dict.get("position").dispatch() {
2387+
VariantDispatch::Vector2(position) => {
2388+
if let Some(size) = dict.get("size").try_to_vector2() {
2389+
return Some(Rect2 { position, size }.to_variant());
2390+
}
2391+
}
2392+
VariantDispatch::Vector3(position) => {
2393+
if let Some(size) = dict.get("size").try_to_vector3() {
2394+
return Some(Aabb { position, size }.to_variant());
2395+
}
2396+
}
2397+
_ => {}
2398+
}
2399+
}
2400+
None
2401+
}
2402+
2403+
fn vec3_or_xform2d(dict: &Dictionary<Unique>) -> Option<Variant> {
2404+
if let Some(x) = get_f64(&dict, "x") {
2405+
if let Some(y) = get_f64(&dict, "y") {
2406+
if let Some(z) = get_f64(&dict, "z") {
2407+
return Some(Vector3::new(x as f32, y as f32, z as f32).to_variant());
2408+
}
2409+
}
2410+
} else if let Some(x) = dict.get("x").try_to_vector2() {
2411+
if let Some(y) = dict.get("y").try_to_vector2() {
2412+
if let Some(origin) = dict.get("origin").try_to_vector2() {
2413+
return Some(Transform2D { x, y, origin }.to_variant());
2414+
}
2415+
}
2416+
}
2417+
None
2418+
}
2419+
2420+
fn quat_or_color(dict: &Dictionary<Unique>) -> Option<Variant> {
2421+
if let Some(x) = get_f64(&dict, "x") {
2422+
if let Some(y) = get_f64(&dict, "y") {
2423+
if let Some(z) = get_f64(&dict, "z") {
2424+
if let Some(w) = get_f64(&dict, "w") {
2425+
return Some(
2426+
Quat::new(x as f32, y as f32, z as f32, w as f32).to_variant(),
2427+
);
2428+
}
2429+
}
2430+
}
2431+
} else if let Some(r) = get_f64(&dict, "r") {
2432+
if let Some(g) = get_f64(&dict, "g") {
2433+
if let Some(b) = get_f64(&dict, "b") {
2434+
if let Some(a) = get_f64(&dict, "a") {
2435+
return Some(
2436+
Color::from_rgba(r as f32, g as f32, b as f32, a as f32).to_variant(),
2437+
);
2438+
}
2439+
}
2440+
}
2441+
}
2442+
None
2443+
}
2444+
2445+
fn get_f64<Access: ThreadAccess>(dict: &Dictionary<Access>, key: impl ToVariant + ToVariantEq) -> Option<f64> {
2446+
dict
2447+
.try_get(key)
2448+
.and_then(|v| v.try_to_f64().or_else(|| v.try_to_i64().map(|i| i as f64)))
2449+
}
24202450
}
24212451

24222452
godot_test!(

0 commit comments

Comments
 (0)