How to serialize an integer as hexadecimal or binary?

[pastelmind]

I want to serialize certain integer fields of a struct as hex or binary format.

The following struct...

#[derive(Serialize, Deserialize)]
struct Foo {
  dec: u32,
  hex: u32,
  bin: u32,
}

let foo = Foo { dec: 12, hex: 34, bin: 56 };

...would be serialized to:

dec = 12
hex = 0x22
bin = 0b111000

Is this possible?

[epage]

FYI this is more of serde question than toml. Check out the field attributes documented at serde.rs

[pastelmind]

But serde doesn't concern itself with how integers are converted to strings, does it? Serde operates on a higher level.

I'm not interested in what serde-hex does. serde-hex converts integers into string literals:

[my_struct]
hex_field = "0x00010203"

But I want to exercise TOML's native support for hexadecimal and binary integers:

[my_struct]
hex_field = 0x00010203

I examined toml_edit and it appears that all integers (i32, u8, etc.) are converted to i64 during serialization...

toml/crates/toml_edit/src/ser/value.rs

Lines 76 to 109 in 1bfb7d7

	fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
	self.serialize_i64(v as i64)
	}
	fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
	self.serialize_i64(v as i64)
	}
	fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
	self.serialize_i64(v as i64)
	}
	fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
	Ok(v.into())
	}
	fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
	self.serialize_i64(v as i64)
	}
	fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
	self.serialize_i64(v as i64)
	}
	fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
	self.serialize_i64(v as i64)
	}
	fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
	let v: i64 = v
	.try_into()
	.map_err(|_err| Error::OutOfRange(Some("u64")))?;
	self.serialize_i64(v)
	}

...which is encoded as a base-10 integer here:

toml/crates/toml_edit/src/encode.rs

Lines 516 to 520 in 1bfb7d7

	impl ValueRepr for i64 {
	fn to_repr(&self) -> Repr {
	Repr::new_unchecked(self.to_string())
	}
	}

Would it be possible to customize this behavior today? Or would I have to write a custom Visit implementation?

[epage]

Sorry, I missed that you were referring to how TOML renders the number.

serde does not natively pass through custom formatting. Our options

• Have a special wrapper type, like we do with serde_spanned. These are a pain to work with
• Make it a setting on the deserializer that applies to all integers. This feels too niche to support.
• Deserialzie to a toml_edit::Document and apply your own visitor.

I currently suggest the last one when people want to do custom formatting.

That leaves us with where you left off, a way to control what repr gets generated for numbers. The only way to do it today is for you to generate a valid TOML representation, parse it, and put it in the document. This is not ideal. For integers, the two main aspects we'd need to control are the base and the digit separators. Our API options are

• Separate APIs for each. When applying botth, we'd either need to store the format style (would rather not do this) or parse the repr to see what was done and re-generate
• A single format call for integers, taking in a non-exhaustive IntegerFormat
• A single format call for any scalar, taking in a non-exhaustive ScalarFormat. This could then store all the settings for string formatting (see Add a way to customize the literal-ness (single/double quotes) of a string #590), etc

Not too sure what approach I'd like to be taking.

[pastelmind]

Thank you. I feel underqualified to provide an opinion on the matter at the moment. For now, I suppose a custom visitor would have to do.