Skip to content

Commit efde125

Browse files
WaridleyWaridley
committed
refactor VariantVisitor::visit_map for readability
1 parent 8b1dc41 commit efde125

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

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

24212451
godot_test!(

0 commit comments

Comments
 (0)