Skip to content

Commit 86d63a2

Browse files
ijlijl
committed
Remove compact_str, simplify dict sorting
1 parent d54f450 commit 86d63a2

File tree

3 files changed

+35
-68
lines changed

3 files changed

+35
-68
lines changed

‎Cargo.lock‎

Lines changed: 0 additions & 37 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎Cargo.toml‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,6 @@ optimize = []
4949
[dependencies]
5050
associative-cache = { version = "2", default-features = false }
5151
bytecount = { version = "^0.6.7", default-features = false, features = ["runtime-dispatch-simd"] }
52-
compact_str = { version = "0.9", default-features = false, features = ["serde"] }
5352
encoding_rs = { version = "0.8", default-features = false }
5453
half = { version = "2", default-features = false, features = ["std"] }
5554
itoa = { version = "1", default-features = false }

‎src/serialize/per_type/dict.rs‎

Lines changed: 35 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,6 @@ use crate::serialize::state::SerializerState;
1616
use crate::str::{PyStr, PyStrSubclass};
1717
use crate::typeref::{STR_TYPE, TRUE, VALUE_STR};
1818
use crate::util::isize_to_usize;
19-
use compact_str::CompactString;
2019
use core::ptr::NonNull;
2120
use serde::ser::{Serialize, SerializeMap, Serializer};
2221
use smallvec::SmallVec;
@@ -297,7 +296,7 @@ impl Serialize for DictSortedKey {
297296
items.push((key_as_str, value));
298297
}
299298

300-
items.sort_unstable_by(|a, b| a.0.cmp(b.0));
299+
sort_dict_items(&mut items);
301300

302301
let mut map = serializer.serialize_map(None).unwrap();
303302
for (key, val) in items.iter() {
@@ -310,105 +309,105 @@ impl Serialize for DictSortedKey {
310309
}
311310

312311
#[inline(never)]
313-
fn non_str_str(key: *mut pyo3_ffi::PyObject) -> Result<CompactString, SerializeError> {
312+
fn non_str_str(key: *mut pyo3_ffi::PyObject) -> Result<String, SerializeError> {
314313
// because of ObType::Enum
315314
let uni = unsafe { PyStr::from_ptr_unchecked(key).to_str() };
316315
if unlikely!(uni.is_none()) {
317316
Err(SerializeError::InvalidStr)
318317
} else {
319-
Ok(CompactString::from(uni.unwrap()))
318+
Ok(String::from(uni.unwrap()))
320319
}
321320
}
322321

323322
#[cold]
324323
#[inline(never)]
325-
fn non_str_str_subclass(key: *mut pyo3_ffi::PyObject) -> Result<CompactString, SerializeError> {
324+
fn non_str_str_subclass(key: *mut pyo3_ffi::PyObject) -> Result<String, SerializeError> {
326325
let uni = unsafe { PyStrSubclass::from_ptr_unchecked(key).to_str() };
327326
if unlikely!(uni.is_none()) {
328327
Err(SerializeError::InvalidStr)
329328
} else {
330-
Ok(CompactString::from(uni.unwrap()))
329+
Ok(String::from(uni.unwrap()))
331330
}
332331
}
333332

334333
#[allow(clippy::unnecessary_wraps)]
335334
#[inline(never)]
336-
fn non_str_date(key: *mut pyo3_ffi::PyObject) -> Result<CompactString, SerializeError> {
335+
fn non_str_date(key: *mut pyo3_ffi::PyObject) -> Result<String, SerializeError> {
337336
let mut buf = SmallFixedBuffer::new();
338337
Date::new(key).write_buf(&mut buf);
339338
let key_as_str = str_from_slice!(buf.as_ptr(), buf.len());
340-
Ok(CompactString::from(key_as_str))
339+
Ok(String::from(key_as_str))
341340
}
342341

343342
#[inline(never)]
344343
fn non_str_datetime(
345344
key: *mut pyo3_ffi::PyObject,
346345
opts: crate::opt::Opt,
347-
) -> Result<CompactString, SerializeError> {
346+
) -> Result<String, SerializeError> {
348347
let mut buf = SmallFixedBuffer::new();
349348
let dt = DateTime::new(key, opts);
350349
if dt.write_buf(&mut buf, opts).is_err() {
351350
return Err(SerializeError::DatetimeLibraryUnsupported);
352351
}
353352
let key_as_str = str_from_slice!(buf.as_ptr(), buf.len());
354-
Ok(CompactString::from(key_as_str))
353+
Ok(String::from(key_as_str))
355354
}
356355

357356
#[cold]
358357
#[inline(never)]
359358
fn non_str_time(
360359
key: *mut pyo3_ffi::PyObject,
361360
opts: crate::opt::Opt,
362-
) -> Result<CompactString, SerializeError> {
361+
) -> Result<String, SerializeError> {
363362
let mut buf = SmallFixedBuffer::new();
364363
let time = Time::new(key, opts);
365364
if time.write_buf(&mut buf).is_err() {
366365
return Err(SerializeError::TimeHasTzinfo);
367366
}
368367
let key_as_str = str_from_slice!(buf.as_ptr(), buf.len());
369-
Ok(CompactString::from(key_as_str))
368+
Ok(String::from(key_as_str))
370369
}
371370

372371
#[allow(clippy::unnecessary_wraps)]
373372
#[inline(never)]
374-
fn non_str_uuid(key: *mut pyo3_ffi::PyObject) -> Result<CompactString, SerializeError> {
373+
fn non_str_uuid(key: *mut pyo3_ffi::PyObject) -> Result<String, SerializeError> {
375374
let mut buf = SmallFixedBuffer::new();
376375
UUID::new(key).write_buf(&mut buf);
377376
let key_as_str = str_from_slice!(buf.as_ptr(), buf.len());
378-
Ok(CompactString::from(key_as_str))
377+
Ok(String::from(key_as_str))
379378
}
380379

381380
#[allow(clippy::unnecessary_wraps)]
382381
#[cold]
383382
#[inline(never)]
384-
fn non_str_float(key: *mut pyo3_ffi::PyObject) -> Result<CompactString, SerializeError> {
383+
fn non_str_float(key: *mut pyo3_ffi::PyObject) -> Result<String, SerializeError> {
385384
let val = ffi!(PyFloat_AS_DOUBLE(key));
386385
if !val.is_finite() {
387-
Ok(CompactString::const_new("null"))
386+
Ok(String::from("null"))
388387
} else {
389-
Ok(CompactString::from(ryu::Buffer::new().format_finite(val)))
388+
Ok(String::from(ryu::Buffer::new().format_finite(val)))
390389
}
391390
}
392391

393392
#[allow(clippy::unnecessary_wraps)]
394393
#[inline(never)]
395-
fn non_str_int(key: *mut pyo3_ffi::PyObject) -> Result<CompactString, SerializeError> {
394+
fn non_str_int(key: *mut pyo3_ffi::PyObject) -> Result<String, SerializeError> {
396395
let ival = ffi!(PyLong_AsLongLong(key));
397396
if unlikely!(ival == -1 && !ffi!(PyErr_Occurred()).is_null()) {
398397
ffi!(PyErr_Clear());
399398
let uval = ffi!(PyLong_AsUnsignedLongLong(key));
400399
if unlikely!(uval == u64::MAX && !ffi!(PyErr_Occurred()).is_null()) {
401400
return Err(SerializeError::DictIntegerKey64Bit);
402401
}
403-
Ok(CompactString::from(itoa::Buffer::new().format(uval)))
402+
Ok(String::from(itoa::Buffer::new().format(uval)))
404403
} else {
405-
Ok(CompactString::from(itoa::Buffer::new().format(ival)))
404+
Ok(String::from(itoa::Buffer::new().format(ival)))
406405
}
407406
}
408407

409408
#[inline(never)]
410-
fn sort_non_str_dict_items(items: &mut SmallVec<[(CompactString, *mut pyo3_ffi::PyObject); 8]>) {
411-
items.sort_unstable_by(|a, b| a.0.cmp(&b.0));
409+
fn sort_dict_items(items: &mut SmallVec<[(&str, *mut pyo3_ffi::PyObject); 8]>) {
410+
items.sort_unstable_by(|a, b| a.0.cmp(b.0));
412411
}
413412

414413
pub(crate) struct DictNonStrKey {
@@ -421,14 +420,14 @@ impl DictNonStrKey {
421420
fn pyobject_to_string(
422421
key: *mut pyo3_ffi::PyObject,
423422
opts: crate::opt::Opt,
424-
) -> Result<CompactString, SerializeError> {
423+
) -> Result<String, SerializeError> {
425424
match pyobject_to_obtype(key, opts) {
426-
ObType::None => Ok(CompactString::const_new("null")),
425+
ObType::None => Ok(String::from("null")),
427426
ObType::Bool => {
428427
if unsafe { core::ptr::eq(key, TRUE) } {
429-
Ok(CompactString::const_new("true"))
428+
Ok(String::from("true"))
430429
} else {
431-
Ok(CompactString::const_new("false"))
430+
Ok(String::from("false"))
432431
}
433432
}
434433
ObType::Int => non_str_int(key),
@@ -475,7 +474,7 @@ impl Serialize for DictNonStrKey {
475474
let len = isize_to_usize(ffi!(Py_SIZE(self.ptr)));
476475
assume!(len > 0);
477476

478-
let mut items: SmallVec<[(CompactString, *mut pyo3_ffi::PyObject); 8]> =
477+
let mut items: SmallVec<[(String, *mut pyo3_ffi::PyObject); 8]> =
479478
SmallVec::with_capacity(len);
480479

481480
for _ in 0..len {
@@ -487,7 +486,7 @@ impl Serialize for DictNonStrKey {
487486
if is_type!(ob_type!(key), STR_TYPE) {
488487
match unsafe { PyStr::from_ptr_unchecked(key).to_str() } {
489488
Some(uni) => {
490-
items.push((CompactString::from(uni), value));
489+
items.push((String::from(uni), value));
491490
}
492491
None => err!(SerializeError::InvalidStr),
493492
}
@@ -499,12 +498,18 @@ impl Serialize for DictNonStrKey {
499498
}
500499
}
501500

501+
let mut items_as_str: SmallVec<[(&str, *mut pyo3_ffi::PyObject); 8]> =
502+
SmallVec::with_capacity(len);
503+
items
504+
.iter()
505+
.for_each(|(key, val)| items_as_str.push(((*key).as_str(), *val)));
506+
502507
if opt_enabled!(opts, SORT_KEYS) {
503-
sort_non_str_dict_items(&mut items);
508+
sort_dict_items(&mut items_as_str);
504509
}
505510

506511
let mut map = serializer.serialize_map(None).unwrap();
507-
for (key, val) in items.iter() {
512+
for (key, val) in items_as_str.iter() {
508513
let pyvalue = PyObjectSerializer::new(*val, self.state, self.default);
509514
map.serialize_key(key).unwrap();
510515
map.serialize_value(&pyvalue)?;

0 commit comments

Comments
 (0)