Rust naar XML Converter
Plak Rust structs of een struct literal. Krijg schone XML terug.
Wat deze tool doet
Als je ooit met de hand XML hebt moeten schrijven die een Rust-struct spiegelt — voor een SOAP-client in een integratieservice, een systeemconfiguratiebestand of een testfixture — weet je hoeveel kopiëren en plakken daarbij komt kijken. Plak de Rust hier en je krijgt in één keer goed gevormde XML terug. Een enkele struct, een bestand met meerdere structs en enums, of een gevulde let order = Order { ... }; literal — zelfde resultaat: een volledig XML-document waarin elk veld behouden blijft.
Dit is geen stomme string-vervanging. De converter weet hoe Rust daadwerkelijk serialiseert via serde — ongeveer zoals serde-xml-rs of quick-xml het zouden uitvoeren. f64 en f32 komen eruit als gewone numerieke tekst, String-waarden worden XML-escaped, een Option<T> met None wordt een leeg element (of wordt overgeslagen als #[serde(skip_serializing_if = "Option::is_none")] is gezet), en Vec<T> volgt een consistente containervorm — elke Vec wordt een wrapper-element met één kind per item, vernoemd naar het elementtype.
Serde-attributen worden gehonoreerd. #[serde(rename = "x")] op een veld hernoemt het element in de output, #[serde(rename = "x")] op de struct hernoemt de omhullende root, #[serde(skip)] gooit het veld weg, en #[serde(flatten)] trekt een geneste struct een niveau omhoog. Enums komen eruit met de standaard tagging-regels van serde — standaard externally tagged, adjacently of internally tagged als je #[serde(tag = "...")] instelt. Wil je de diepgaande versie, dan is The Rust Book een stevig startpunt voor ownership en het onderliggende typesysteem.
Hoe je het gebruikt
Drie stappen. Werkt hetzelfde of je nu een struct van vijf regels of een hele module plakt.
Plak je Rust (of probeer het voorbeeld)
Gooi je Rust zoals het is in de editor links. Een struct, een enum, een gevulde struct literal, of een bestand met meerdere types — allemaal prima. Klik op Voorbeeld laden als je eerst een realistisch voorbeeld wilt zien.
Je hoeft geen use-statements te verwijderen, geen derive-macros weg te halen, of lifetime-annotaties op te ruimen. Laat de code staan zoals rustfmt hem heeft achtergelaten. Gewoon plakken.
Klik op Converteren
Klik op de groene Converteren-knop. De tool leest de Rust, behoudt elke struct en elk veld, en bouwt de XML in één pass. Tijdens het draaien zie je een korte laadindicator.
Kopieer de XML
Het rechterpaneel vult zich met ingesprongen, goed gevormde XML die elke standaardconforme XML-parser accepteert. Kopieer het rechtstreeks in je SOAP-request, config-bestand of test-fixture.
Wanneer dit echt handig is
SOAP-integratie op systeemniveau
Rust-services staan vaak naast legacy-systemen die nog steeds SOAP spreken. Plak je request-struct, pak de XML-body, test het in SoapUI voordat je de HTTP-client aansluit — sneller dan de envelope met de hand schrijven. Combineer met een crate van <a href="https://crates.io/" target="_blank" rel="noopener">crates.io</a> zoals <code>reqwest</code> voor het transport.
Config-bestanden voor services en daemons
Een settings-struct met 30+ velden wordt een direct bewerkbare XML-template. Geen handgeschreven boilerplate, geen vergeten velden als de struct groeit.
Seed voor testfixtures
Zet een gevulde <code>let order = Order { ... };</code> uit een unit-test om in een XML-seedbestand voor integratietests, mock servers of legacy-systemen die je niet bezit.
Docs synchroon houden
Genereer XML-voorbeelden voor een README, crate-docs of XSD-gebaseerde schemadocumentatie direct vanuit je echte structs, zodat de docs overeenkomen met de code in plaats van af te drijven.
Veelgestelde vragen
Kan ik meerdere structs tegelijk plakken?
Ja — plak een hele module. Elke top-level struct of enum komt erdoor met geneste types uitgevouwen en standaardwaarden ingevuld. Er wordt niets stilzwijgend weggelaten.
Respecteert het #[serde(rename)] en #[serde(skip)]?
Ja. #[serde(rename = "x")] op een veld hernoemt het XML-element, #[serde(rename = "x")] op de struct hernoemt de omhullende root, #[serde(skip)] gooit het veld volledig weg, en #[serde(flatten)] trekt een geneste struct een niveau omhoog. #[serde(rename_all = "PascalCase")] wordt toegepast op elk veld in de struct. Dat komt overeen met wat serde daadwerkelijk doet tijdens runtime.
Hoe gaat het om met Option<T> en skip_serializing_if?
Een None-waarde wordt standaard een leeg element — zo blijft de vorm consistent en blijven XSD-schema's valideren. Heeft het veld #[serde(skip_serializing_if = "Option::is_none")], dan worden None-waarden volledig weggelaten. Some(x) wordt altijd als x zelf geserialiseerd.
En enums, Vec en HashMap?
Enums zijn standaard externally-tagged (<VariantName>...</VariantName>); voeg #[serde(tag = "type")] toe om naar internally-tagged te schakelen. Vec<T> wordt een containerelement met één kind per item, vernoemd naar het elementtype — een Vec<OrderItem> items wordt <items><OrderItem/><OrderItem/></items>. HashMap<K,V> wordt een container van <Entry><Key/><Value/></Entry>.
Wordt mijn code opgeslagen?
Je code wordt naar de backend gestuurd voor de conversie en wordt niet bewaard — we loggen de payload niet. Zoals altijd bij online tools: als de code echt gevoelig is, kijk er dan even naar voor je plakt.
Wat als de Rust lifetimes, traits of unsafe-blokken heeft?
Lifetime-annotaties worden voor XML-doeleinden gestript — ze beïnvloeden de runtime-waarde niet. Trait-definities beschrijven vorm, geen inhoud, dus die leveren niet rechtstreeks XML op; de implementerende structs wel. Unsafe-blokken worden genegeerd omdat het uitvoeringsconstructen zijn. Heeft de code syntaxisfouten, fix dan eerst de voor de hand liggende — de parser is tolerant, maar geen gedachtenlezer.
Andere tools die je misschien nodig hebt
Rust naar XML is een stukje van de puzzel. Deze passen daar goed bij: