// Copyright Mozilla Foundation
//
// Licensed under the Apache License (Version 2.0), or the MIT license,
// (the "Licenses") at your option. You may not use this file except in
// compliance with one of the Licenses. You may obtain copies of the
// Licenses at:
//
//
https://www.apache.org/licenses/LICENSE-2.0
//
https://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Licenses is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the Licenses for the specific language governing permissions and
// limitations under the Licenses.
#![no_std]
//! `write16` provides the trait `Write16`, which a UTF-16 analog of the
//! `core::fmt::Write` trait (the sink part—not the formatting part).
#[cfg(feature = "alloc")]
extern crate alloc;
#[cfg(feature = "arrayvec")]
extern crate arrayvec;
#[cfg(feature = "smallvec")]
extern crate smallvec;
/// A UTF-16 sink analogous to `core::fmt::Write`.
pub trait Write16 {
/// Write a slice containing UTF-16 to the sink.
///
/// The implementor of the trait should not validate UTF-16.
/// It's the responsibility of the caller to pass valid
/// UTF-16.
fn write_slice(&mut self, s: &[u16]) -> core::fmt::Result;
/// Write a Unicode scalar value to the sink.
#[inline(always)]
fn write_char(&mut self, c: char) -> core::fmt::Result {
let mut buf = [0u16; 2];
self.write_slice(c.encode_utf16(&mut buf))
}
/// A hint that the caller expects to write `upcoming` UTF-16
/// code units. The implementation must not assume `upcoming`
/// to be exact. The caller may write more or fewer code units
/// using `write_slice()` and `write_char()`. However, the
/// caller should try to give reasonable estimates if it uses
/// this method.
///
/// For `Vec` and `SmallVec`, this maps to `reserve()`.
/// The default implementation does nothing.
#[inline(always)]
fn size_hint(&mut self, upcoming: usize) -> core::fmt::Result {
let _ = upcoming;
Ok(())
}
}
#[cfg(feature = "alloc")]
impl Write16 for alloc::vec::Vec<u16> {
#[inline(always)]
fn write_slice(&mut self, s: &[u16]) -> core::fmt::Result {
self.extend_from_slice(s);
Ok(())
}
#[inline(always)]
fn write_char(&mut self, c: char) -> core::fmt::Result {
if c <= '\u{FFFF}' {
self.push(c as u16);
} else {
let mut buf = [0u16; 2];
let u = u32::from(c);
buf[0] = (0xD7C0 + (u >> 10)) as u16;
buf[1] = (0xDC00 + (u & 0x3FF)) as u16;
self.extend_from_slice(&mut buf);
}
Ok(())
}
#[inline(always)]
fn size_hint(&mut self, upcoming: usize) -> core::fmt::Result {
self.reserve(upcoming);
Ok(())
}
}
#[cfg(feature = "smallvec")]
impl<A: smallvec::Array<Item = u16>> Write16 for smallvec::SmallVec<A> {
#[inline(always)]
fn write_slice(&mut self, s: &[u16]) -> core::fmt::Result {
self.extend_from_slice(s);
Ok(())
}
#[inline(always)]
fn write_char(&mut self, c: char) -> core::fmt::Result {
if c <= '\u{FFFF}' {
self.push(c as u16);
} else {
let mut buf = [0u16; 2];
let u = u32::from(c);
buf[0] = (0xD7C0 + (u >> 10)) as u16;
buf[1] = (0xDC00 + (u & 0x3FF)) as u16;
self.extend_from_slice(&mut buf);
}
Ok(())
}
#[inline(always)]
fn size_hint(&mut self, upcoming: usize) -> core::fmt::Result {
self.reserve(upcoming);
Ok(())
}
}
#[cfg(feature = "arrayvec")]
impl<const CAP: usize> Write16 for arrayvec::ArrayVec<u16, CAP> {
#[inline(always)]
fn write_slice(&mut self, s: &[u16]) -> core::fmt::Result {
if self.try_extend_from_slice(s).is_ok() {
Ok(())
} else {
Err(core::fmt::Error {})
}
}
#[inline(always)]
fn write_char(&mut self, c: char) -> core::fmt::Result {
if c <= '\u{FFFF}' {
if self.try_push(c as u16).is_ok() {
Ok(())
} else {
Err(core::fmt::Error {})
}
} else {
let mut buf = [0u16; 2];
let u = u32::from(c);
buf[0] = (0xD7C0 + (u >> 10)) as u16;
buf[1] = (0xDC00 + (u & 0x3FF)) as u16;
self.write_slice(&mut buf)
}
}
}
#[cfg(test)]
mod tests {
use crate::Write16;
#[cfg(feature = "alloc")]
#[test]
fn test_vec() {
let mut v: alloc::vec::Vec<u16> = alloc::vec::Vec::new();
assert_eq!(v.capacity(), 0);
assert!(v.size_hint(32).is_ok());
assert!(v.capacity() >= 32);
assert_eq!(v.len(), 0);
assert!(v.write_slice([0x0061u16, 0x0062u16].as_slice()).is_ok());
assert_eq!(v.len(), 2);
assert!(v.write_char('☃').is_ok());
assert_eq!(v.len(), 3);
assert!(v.write_char('��').is_ok());
assert_eq!(v.len(), 5);
assert_eq!(
v.as_slice(),
[0x0061u16, 0x0062u16, 0x2603u16, 0xD83Du16, 0xDE0Au16].as_slice()
);
}
#[cfg(feature = "smallvec")]
#[test]
fn test_smallvec() {
let mut v: smallvec::SmallVec<[u16; 2]> = smallvec::SmallVec::new();
assert_eq!(v.capacity(), 2);
assert!(v.size_hint(32).is_ok());
assert!(v.capacity() >= 32);
assert_eq!(v.len(), 0);
assert!(v.write_slice([0x0061u16, 0x0062u16].as_slice()).is_ok());
assert_eq!(v.len(), 2);
assert!(v.write_char('☃').is_ok());
assert_eq!(v.len(), 3);
assert!(v.write_char('��').is_ok());
assert_eq!(v.len(), 5);
assert_eq!(
v.as_slice(),
[0x0061u16, 0x0062u16, 0x2603u16, 0xD83Du16, 0xDE0Au16].as_slice()
);
}
#[cfg(feature = "arrayvec")]
#[test]
fn test_arrayvec() {
let mut v: arrayvec::ArrayVec<u16, 4> = arrayvec::ArrayVec::new();
assert_eq!(v.capacity(), 4);
assert!(v.size_hint(32).is_ok());
assert_eq!(v.capacity(), 4);
assert_eq!(v.len(), 0);
assert!(v.write_char('��').is_ok());
assert_eq!(v.len(), 2);
assert!(v.write_char('☃').is_ok());
assert_eq!(v.len(), 3);
assert!(v.write_char('��').is_err());
assert_eq!(v.len(), 3);
assert_eq!(v.as_slice(), [0xD83Du16, 0xDE0Au16, 0x2603u16].as_slice());
}
}
