use core::{mem, num};
use lexical_util::ascii::{is_valid_ascii, is_valid_letter_slice};
use lexical_util::constants::FormattedSize;
use lexical_util::error::Error;
use lexical_util::format::NumberFormat;
use lexical_util::options::{self, WriteOptions};
use lexical_util::result::Result;
use static_assertions::const_assert;
pub type OptionUsize = Option<num::NonZeroUsize>;
pub type OptionI32 = Option<num::NonZeroI32>;
const_assert!(mem::size_of::<OptionUsize>() == mem::size_of::<usize>());
const_assert!(mem::size_of::<OptionI32>() == mem::size_of::<i32>());
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum RoundMode {
Round,
Truncate,
}
const MAX_SPECIAL_STRING_LENGTH: usize = 50;
const_assert!(MAX_SPECIAL_STRING_LENGTH < f32::FORMATTED_SIZE_DECIMAL);
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OptionsBuilder {
max_significant_digits: OptionUsize,
min_significant_digits: OptionUsize,
positive_exponent_break: OptionI32,
negative_exponent_break: OptionI32,
round_mode: RoundMode,
trim_floats: bool,
exponent: u8,
decimal_point: u8,
nan_string: Option<&'static [u8]>,
inf_string: Option<&'static [u8]>,
}
impl OptionsBuilder {
#[inline(always)]
pub const fn new() -> Self {
Self {
max_significant_digits: None,
min_significant_digits: None,
positive_exponent_break: None,
negative_exponent_break: None,
round_mode: RoundMode::Round,
trim_floats: false,
exponent: b'e',
decimal_point: b'.',
nan_string: Some(b"NaN"),
inf_string: Some(b"inf"),
}
}
#[inline(always)]
pub const fn get_max_significant_digits(&self) -> OptionUsize {
self.max_significant_digits
}
#[inline(always)]
pub const fn get_min_significant_digits(&self) -> OptionUsize {
self.min_significant_digits
}
#[inline(always)]
pub const fn get_positive_exponent_break(&self) -> OptionI32 {
self.positive_exponent_break
}
#[inline(always)]
pub const fn get_negative_exponent_break(&self) -> OptionI32 {
self.negative_exponent_break
}
#[inline(always)]
pub const fn get_round_mode(&self) -> RoundMode {
self.round_mode
}
#[inline(always)]
pub const fn get_trim_floats(&self) -> bool {
self.trim_floats
}
#[inline(always)]
pub const fn get_exponent(&self) -> u8 {
self.exponent
}
#[inline(always)]
pub const fn get_decimal_point(&self) -> u8 {
self.decimal_point
}
#[inline(always)]
pub const fn get_nan_string(&self) -> Option<&'static [u8]> {
self.nan_string
}
#[inline(always)]
pub const fn get_inf_string(&self) -> Option<&'static [u8]> {
self.inf_string
}
#[inline(always)]
pub const fn max_significant_digits(mut self, max_significant_digits: OptionUsize) -> Self {
self.max_significant_digits = max_significant_digits;
self
}
#[inline(always)]
pub const fn min_significant_digits(mut self, min_significant_digits: OptionUsize) -> Self {
self.min_significant_digits = min_significant_digits;
self
}
#[inline(always)]
pub const fn positive_exponent_break(mut self, positive_exponent_break: OptionI32) -> Self {
self.positive_exponent_break = positive_exponent_break;
self
}
#[inline(always)]
pub const fn negative_exponent_break(mut self, negative_exponent_break: OptionI32) -> Self {
self.negative_exponent_break = negative_exponent_break;
self
}
#[inline(always)]
pub const fn round_mode(mut self, round_mode: RoundMode) -> Self {
self.round_mode = round_mode;
self
}
#[inline(always)]
pub const fn trim_floats(mut self, trim_floats: bool) -> Self {
self.trim_floats = trim_floats;
self
}
#[inline(always)]
pub const fn exponent(mut self, exponent: u8) -> Self {
self.exponent = exponent;
self
}
#[inline(always)]
pub const fn decimal_point(mut self, decimal_point: u8) -> Self {
self.decimal_point = decimal_point;
self
}
#[inline(always)]
pub const fn nan_string(mut self, nan_string: Option<&'static [u8]>) -> Self {
self.nan_string = nan_string;
self
}
#[inline(always)]
pub const fn inf_string(mut self, inf_string: Option<&'static [u8]>) -> Self {
self.inf_string = inf_string;
self
}
#[inline(always)]
#[allow(clippy::if_same_then_else, clippy::needless_bool)] pub const fn nan_str_is_valid(&self) -> bool {
if self.nan_string.is_none() {
return true;
}
let nan = unwrap_str(self.nan_string);
let length = nan.len();
if length == 0 || length > MAX_SPECIAL_STRING_LENGTH {
false
} else if !matches!(nan[0], b'N' | b'n') {
false
} else if !is_valid_letter_slice(nan) {
false
} else {
true
}
}
#[inline(always)]
#[allow(clippy::if_same_then_else, clippy::needless_bool)] pub const fn inf_str_is_valid(&self) -> bool {
if self.inf_string.is_none() {
return true;
}
let inf = unwrap_str(self.inf_string);
let length = inf.len();
if length == 0 || length > MAX_SPECIAL_STRING_LENGTH {
false
} else if !matches!(inf[0], b'I' | b'i') {
false
} else if !is_valid_letter_slice(inf) {
false
} else {
true
}
}
#[inline(always)]
#[allow(clippy::if_same_then_else, clippy::needless_bool)] pub const fn is_valid(&self) -> bool {
if !is_valid_ascii(self.exponent) {
false
} else if !is_valid_ascii(self.decimal_point) {
false
} else if !self.nan_str_is_valid() {
false
} else if !self.inf_str_is_valid() {
false
} else {
true
}
}
#[inline(always)]
pub const fn build_unchecked(&self) -> Options {
Options {
max_significant_digits: self.max_significant_digits,
min_significant_digits: self.min_significant_digits,
positive_exponent_break: self.positive_exponent_break,
negative_exponent_break: self.negative_exponent_break,
round_mode: self.round_mode,
trim_floats: self.trim_floats,
exponent: self.exponent,
decimal_point: self.decimal_point,
nan_string: self.nan_string,
inf_string: self.inf_string,
}
}
#[inline(always)]
#[allow(clippy::if_same_then_else)] pub const fn build(&self) -> Result<Options> {
if self.nan_string.is_some() {
let nan = unwrap_str(self.nan_string);
if nan.is_empty() || !matches!(nan[0], b'N' | b'n') {
return Err(Error::InvalidNanString);
} else if !is_valid_letter_slice(nan) {
return Err(Error::InvalidNanString);
} else if nan.len() > MAX_SPECIAL_STRING_LENGTH {
return Err(Error::NanStringTooLong);
}
}
if self.inf_string.is_some() {
let inf = unwrap_str(self.inf_string);
if inf.is_empty() || !matches!(inf[0], b'I' | b'i') {
return Err(Error::InvalidInfString);
} else if !is_valid_letter_slice(inf) {
return Err(Error::InvalidInfString);
} else if inf.len() > MAX_SPECIAL_STRING_LENGTH {
return Err(Error::InfStringTooLong);
}
}
let min_digits = unwrap_or_zero_usize(self.min_significant_digits);
let max_digits = unwrap_or_max_usize(self.max_significant_digits);
if max_digits < min_digits {
Err(Error::InvalidFloatPrecision)
} else if unwrap_or_zero_i32(self.negative_exponent_break) > 0 {
Err(Error::InvalidNegativeExponentBreak)
} else if unwrap_or_zero_i32(self.positive_exponent_break) < 0 {
Err(Error::InvalidPositiveExponentBreak)
} else if !is_valid_ascii(self.exponent) {
Err(Error::InvalidExponentSymbol)
} else if !is_valid_ascii(self.decimal_point) {
Err(Error::InvalidDecimalPoint)
} else {
Ok(self.build_unchecked())
}
}
}
impl Default for OptionsBuilder {
#[inline(always)]
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Options {
max_significant_digits: OptionUsize,
min_significant_digits: OptionUsize,
positive_exponent_break: OptionI32,
negative_exponent_break: OptionI32,
round_mode: RoundMode,
trim_floats: bool,
exponent: u8,
decimal_point: u8,
nan_string: Option<&'static [u8]>,
inf_string: Option<&'static [u8]>,
}
impl Options {
#[inline(always)]
pub const fn new() -> Self {
Self::builder().build_unchecked()
}
#[inline(always)]
#[cfg(feature = "power-of-two")]
pub const fn from_radix(radix: u8) -> Self {
let mut builder = Self::builder();
if radix >= 15 {
builder = builder.exponent(b'^');
}
builder.build_unchecked()
}
#[inline(always)]
pub const fn is_valid(&self) -> bool {
self.rebuild().is_valid()
}
#[inline(always)]
pub const fn max_significant_digits(&self) -> OptionUsize {
self.max_significant_digits
}
#[inline(always)]
pub const fn min_significant_digits(&self) -> OptionUsize {
self.min_significant_digits
}
#[inline(always)]
pub const fn positive_exponent_break(&self) -> OptionI32 {
self.positive_exponent_break
}
#[inline(always)]
pub const fn negative_exponent_break(&self) -> OptionI32 {
self.negative_exponent_break
}
#[inline(always)]
pub const fn round_mode(&self) -> RoundMode {
self.round_mode
}
#[inline(always)]
pub const fn trim_floats(&self) -> bool {
self.trim_floats
}
#[inline(always)]
pub const fn exponent(&self) -> u8 {
self.exponent
}
#[inline(always)]
pub const fn decimal_point(&self) -> u8 {
self.decimal_point
}
#[inline(always)]
pub const fn nan_string(&self) -> Option<&'static [u8]> {
self.nan_string
}
#[inline(always)]
pub const fn inf_string(&self) -> Option<&'static [u8]> {
self.inf_string
}
#[inline(always)]
pub fn set_max_significant_digits(&mut self, max_significant_digits: OptionUsize) {
self.max_significant_digits = max_significant_digits;
}
#[inline(always)]
pub fn set_min_significant_digits(&mut self, min_significant_digits: OptionUsize) {
self.min_significant_digits = min_significant_digits;
}
#[inline(always)]
pub fn set_positive_exponent_break(&mut self, positive_exponent_break: OptionI32) {
self.positive_exponent_break = positive_exponent_break;
}
#[inline(always)]
pub fn set_negative_exponent_break(&mut self, negative_exponent_break: OptionI32) {
self.negative_exponent_break = negative_exponent_break;
}
#[inline(always)]
pub fn set_round_mode(&mut self, round_mode: RoundMode) {
self.round_mode = round_mode;
}
#[inline(always)]
pub fn set_trim_floats(&mut self, trim_floats: bool) {
self.trim_floats = trim_floats;
}
#[inline(always)]
pub fn set_exponent(&mut self, exponent: u8) {
self.exponent = exponent;
}
#[inline(always)]
pub fn set_decimal_point(&mut self, decimal_point: u8) {
self.decimal_point = decimal_point;
}
#[inline(always)]
pub fn set_nan_string(&mut self, nan_string: Option<&'static [u8]>) {
self.nan_string = nan_string;
}
#[inline(always)]
pub fn set_inf_string(&mut self, inf_string: Option<&'static [u8]>) {
self.inf_string = inf_string;
}
#[inline(always)]
pub const fn builder() -> OptionsBuilder {
OptionsBuilder::new()
}
#[inline(always)]
pub const fn rebuild(&self) -> OptionsBuilder {
OptionsBuilder {
max_significant_digits: self.max_significant_digits,
min_significant_digits: self.min_significant_digits,
positive_exponent_break: self.positive_exponent_break,
negative_exponent_break: self.negative_exponent_break,
round_mode: self.round_mode,
trim_floats: self.trim_floats,
exponent: self.exponent,
decimal_point: self.decimal_point,
nan_string: self.nan_string,
inf_string: self.inf_string,
}
}
}
impl Default for Options {
#[inline(always)]
fn default() -> Self {
Self::new()
}
}
impl WriteOptions for Options {
#[inline(always)]
fn is_valid(&self) -> bool {
Self::is_valid(self)
}
#[inline(always)]
fn buffer_size<T: FormattedSize, const FORMAT: u128>(&self) -> usize {
let format = NumberFormat::<{ FORMAT }> {};
let mut count: usize = 2;
if !format.no_exponent_notation() {
let min_exp = self.negative_exponent_break().map_or(-5, |x| x.get());
let max_exp = self.positive_exponent_break().map_or(9, |x| x.get());
let exp = min_exp.abs().max(max_exp) as usize;
if cfg!(feature = "power-of-two") && exp < 13 {
count += 13;
} else if exp < 5 {
count += 5;
} else {
count += exp;
}
} else if cfg!(feature = "power-of-two") {
count += 1075;
} else {
count += 324;
}
let radix = format.radix();
let formatted_digits = if radix == 10 {
28
} else {
64
};
let digits = if let Some(max_digits) = self.max_significant_digits() {
formatted_digits.min(max_digits.get())
} else {
formatted_digits
};
let digits = if let Some(min_digits) = self.min_significant_digits() {
digits.max(min_digits.get())
} else {
formatted_digits
};
count += digits;
count
}
}
macro_rules! unwrap_or_zero {
($name:ident, $opt:ident, $t:ident) => {
#[inline(always)]
const fn $name(option: $opt) -> $t {
match option {
Some(x) => x.get(),
None => 0,
}
}
};
}
unwrap_or_zero!(unwrap_or_zero_usize, OptionUsize, usize);
unwrap_or_zero!(unwrap_or_zero_i32, OptionI32, i32);
#[inline(always)]
const fn unwrap_or_max_usize(option: OptionUsize) -> usize {
match option {
Some(x) => x.get(),
None => usize::MAX,
}
}
#[inline(always)]
const fn unwrap_str(option: Option<&'static [u8]>) -> &'static [u8] {
match option {
Some(x) => x,
None => &[],
}
}
#[rustfmt::skip]
pub const STANDARD: Options = Options::new();
const_assert!(STANDARD.is_valid());
#[rustfmt::skip]
pub const DECIMAL_COMMA: Options = Options::builder()
.decimal_point(b',')
.build_unchecked();
const_assert!(DECIMAL_COMMA.is_valid());
#[rustfmt::skip]
pub const HEX_FLOAT: Options = Options::builder()
.exponent(b'p')
.build_unchecked();
const_assert!(HEX_FLOAT.is_valid());
#[rustfmt::skip]
pub const CARAT_EXPONENT: Options = Options::builder()
.exponent(b'^')
.build_unchecked();
const_assert!(CARAT_EXPONENT.is_valid());
#[rustfmt::skip]
pub const RUST_LITERAL: Options = Options::builder()
.nan_string(options::RUST_LITERAL)
.inf_string(options::RUST_LITERAL)
.build_unchecked();
const_assert!(RUST_LITERAL.is_valid());
#[rustfmt::skip]
pub const PYTHON_LITERAL: Options = Options::builder()
.nan_string(options::PYTHON_LITERAL)
.inf_string(options::PYTHON_LITERAL)
.build_unchecked();
const_assert!(PYTHON_LITERAL.is_valid());
#[rustfmt::skip]
pub const CXX_LITERAL: Options = Options::builder()
.nan_string(options::CXX_LITERAL_NAN)
.inf_string(options::CXX_LITERAL_INF)
.build_unchecked();
const_assert!(CXX_LITERAL.is_valid());
#[rustfmt::skip]
pub const C_LITERAL: Options = Options::builder()
.nan_string(options::C_LITERAL_NAN)
.inf_string(options::C_LITERAL_INF)
.build_unchecked();
const_assert!(CXX_LITERAL.is_valid());
#[rustfmt::skip]
pub const RUBY_LITERAL: Options = Options::builder()
.positive_exponent_break(num::NonZeroI32::new(14))
.negative_exponent_break(num::NonZeroI32::new(-4))
.nan_string(options::RUBY_LITERAL_NAN)
.inf_string(options::RUBY_LITERAL_INF)
.build_unchecked();
const_assert!(RUBY_LITERAL.is_valid());
#[rustfmt::skip]
pub const RUBY_STRING: Options = Options::builder()
.nan_string(options::RUBY_LITERAL_NAN)
.inf_string(options::RUBY_LITERAL_INF)
.build_unchecked();
const_assert!(RUBY_STRING.is_valid());
#[rustfmt::skip]
pub const SWIFT_LITERAL: Options = Options::builder()
.nan_string(options::SWIFT_LITERAL)
.inf_string(options::SWIFT_LITERAL)
.build_unchecked();
const_assert!(SWIFT_LITERAL.is_valid());
#[rustfmt::skip]
pub const GO_LITERAL: Options = Options::builder()
.nan_string(options::GO_LITERAL)
.inf_string(options::GO_LITERAL)
.build_unchecked();
const_assert!(GO_LITERAL.is_valid());
#[rustfmt::skip]
pub const HASKELL_LITERAL: Options = Options::builder()
.nan_string(options::HASKELL_LITERAL)
.inf_string(options::HASKELL_LITERAL)
.build_unchecked();
const_assert!(HASKELL_LITERAL.is_valid());
#[rustfmt::skip]
pub const HASKELL_STRING: Options = Options::builder()
.inf_string(options::HASKELL_STRING_INF)
.build_unchecked();
const_assert!(HASKELL_STRING.is_valid());
#[rustfmt::skip]
pub const JAVASCRIPT_LITERAL: Options = Options::builder()
.inf_string(options::JAVASCRIPT_INF)
.build_unchecked();
const_assert!(JAVASCRIPT_LITERAL.is_valid());
#[rustfmt::skip]
pub const JAVASCRIPT_STRING: Options = Options::builder()
.inf_string(options::JAVASCRIPT_INF)
.build_unchecked();
const_assert!(JAVASCRIPT_STRING.is_valid());
#[rustfmt::skip]
pub const PERL_LITERAL: Options = Options::builder()
.nan_string(options::PERL_LITERAL)
.inf_string(options::PERL_LITERAL)
.build_unchecked();
const_assert!(PERL_LITERAL.is_valid());
#[rustfmt::skip]
pub const PHP_LITERAL: Options = Options::builder()
.nan_string(options::PHP_LITERAL_NAN)
.inf_string(options::PHP_LITERAL_INF)
.build_unchecked();
const_assert!(PHP_LITERAL.is_valid());
#[rustfmt::skip]
pub const JAVA_LITERAL: Options = Options::builder()
.nan_string(options::JAVA_LITERAL)
.inf_string(options::JAVA_LITERAL)
.build_unchecked();
const_assert!(JAVA_LITERAL.is_valid());
#[rustfmt::skip]
pub const JAVA_STRING: Options = Options::builder()
.inf_string(options::JAVA_STRING_INF)
.build_unchecked();
const_assert!(JAVA_STRING.is_valid());
#[rustfmt::skip]
pub const R_LITERAL: Options = Options::builder()
.inf_string(options::R_LITERAL_INF)
.build_unchecked();
const_assert!(R_LITERAL.is_valid());
#[rustfmt::skip]
pub const KOTLIN_LITERAL: Options = Options::builder()
.nan_string(options::KOTLIN_LITERAL)
.inf_string(options::KOTLIN_LITERAL)
.build_unchecked();
const_assert!(KOTLIN_LITERAL.is_valid());
#[rustfmt::skip]
pub const KOTLIN_STRING: Options = Options::builder()
.inf_string(options::KOTLIN_STRING_INF)
.build_unchecked();
const_assert!(KOTLIN_STRING.is_valid());
#[rustfmt::skip]
pub const JULIA_LITERAL: Options = Options::builder()
.inf_string(options::JULIA_LITERAL_INF)
.build_unchecked();
const_assert!(JULIA_LITERAL.is_valid());
#[rustfmt::skip]
pub const CSHARP_LITERAL: Options = Options::builder()
.nan_string(options::CSHARP_LITERAL)
.inf_string(options::CSHARP_LITERAL)
.build_unchecked();
const_assert!(CSHARP_LITERAL.is_valid());
#[rustfmt::skip]
pub const CSHARP_STRING: Options = Options::builder()
.inf_string(options::CSHARP_STRING_INF)
.build_unchecked();
const_assert!(CSHARP_STRING.is_valid());
#[rustfmt::skip]
pub const KAWA_LITERAL: Options = Options::builder()
.nan_string(options::KAWA)
.inf_string(options::KAWA)
.build_unchecked();
const_assert!(KAWA_LITERAL.is_valid());
#[rustfmt::skip]
pub const KAWA_STRING: Options = Options::builder()
.nan_string(options::KAWA)
.inf_string(options::KAWA)
.build_unchecked();
const_assert!(KAWA_STRING.is_valid());
#[rustfmt::skip]
pub const GAMBITC_LITERAL: Options = Options::builder()
.nan_string(options::GAMBITC)
.inf_string(options::GAMBITC)
.build_unchecked();
const_assert!(GAMBITC_LITERAL.is_valid());
#[rustfmt::skip]
pub const GAMBITC_STRING: Options = Options::builder()
.nan_string(options::GAMBITC)
.inf_string(options::GAMBITC)
.build_unchecked();
const_assert!(GAMBITC_STRING.is_valid());
#[rustfmt::skip]
pub const GUILE_LITERAL: Options = Options::builder()
.nan_string(options::GUILE)
.inf_string(options::GUILE)
.build_unchecked();
const_assert!(GUILE_LITERAL.is_valid());
#[rustfmt::skip]
pub const GUILE_STRING: Options = Options::builder()
.nan_string(options::GUILE)
.inf_string(options::GUILE)
.build_unchecked();
const_assert!(GUILE_STRING.is_valid());
#[rustfmt::skip]
pub const CLOJURE_LITERAL: Options = Options::builder()
.nan_string(options::CLOJURE_LITERAL)
.inf_string(options::CLOJURE_LITERAL)
.build_unchecked();
const_assert!(CLOJURE_LITERAL.is_valid());
#[rustfmt::skip]
pub const CLOJURE_STRING: Options = Options::builder()
.inf_string(options::CLOJURE_STRING_INF)
.build_unchecked();
const_assert!(CLOJURE_STRING.is_valid());
#[rustfmt::skip]
pub const ERLANG_LITERAL: Options = Options::builder()
.nan_string(options::ERLANG_LITERAL_NAN)
.build_unchecked();
const_assert!(ERLANG_LITERAL.is_valid());
#[rustfmt::skip]
pub const ERLANG_STRING: Options = Options::builder()
.nan_string(options::ERLANG_STRING)
.inf_string(options::ERLANG_STRING)
.build_unchecked();
const_assert!(ERLANG_STRING.is_valid());
#[rustfmt::skip]
pub const ELM_LITERAL: Options = Options::builder()
.nan_string(options::ELM_LITERAL)
.inf_string(options::ELM_LITERAL)
.build_unchecked();
const_assert!(ELM_LITERAL.is_valid());
#[rustfmt::skip]
pub const ELM_STRING: Options = Options::builder()
.nan_string(options::ELM_STRING_NAN)
.inf_string(options::ELM_STRING_INF)
.build_unchecked();
const_assert!(ELM_STRING.is_valid());
#[rustfmt::skip]
pub const SCALA_LITERAL: Options = Options::builder()
.nan_string(options::SCALA_LITERAL)
.inf_string(options::SCALA_LITERAL)
.build_unchecked();
const_assert!(SCALA_LITERAL.is_valid());
#[rustfmt::skip]
pub const SCALA_STRING: Options = Options::builder()
.inf_string(options::SCALA_STRING_INF)
.build_unchecked();
const_assert!(SCALA_STRING.is_valid());
#[rustfmt::skip]
pub const ELIXIR_LITERAL: Options = Options::builder()
.nan_string(options::ELIXIR)
.inf_string(options::ELIXIR)
.build_unchecked();
const_assert!(ELIXIR_LITERAL.is_valid());
#[rustfmt::skip]
pub const ELIXIR_STRING: Options = Options::builder()
.nan_string(options::ELIXIR)
.inf_string(options::ELIXIR)
.build_unchecked();
const_assert!(ELIXIR_STRING.is_valid());
#[rustfmt::skip]
pub const FORTRAN_LITERAL: Options = Options::builder()
.nan_string(options::FORTRAN_LITERAL)
.inf_string(options::FORTRAN_LITERAL)
.build_unchecked();
const_assert!(FORTRAN_LITERAL.is_valid());
#[rustfmt::skip]
pub const D_LITERAL: Options = Options::builder()
.nan_string(options::D_LITERAL)
.inf_string(options::D_LITERAL)
.build_unchecked();
const_assert!(D_LITERAL.is_valid());
#[rustfmt::skip]
pub const COFFEESCRIPT_LITERAL: Options = Options::builder()
.inf_string(options::COFFEESCRIPT_INF)
.build_unchecked();
const_assert!(COFFEESCRIPT_LITERAL.is_valid());
#[rustfmt::skip]
pub const COFFEESCRIPT_STRING: Options = Options::builder()
.inf_string(options::COFFEESCRIPT_INF)
.build_unchecked();
const_assert!(COFFEESCRIPT_STRING.is_valid());
#[rustfmt::skip]
pub const COBOL_LITERAL: Options = Options::builder()
.nan_string(options::COBOL)
.inf_string(options::COBOL)
.build_unchecked();
const_assert!(COBOL_LITERAL.is_valid());
#[rustfmt::skip]
pub const COBOL_STRING: Options = Options::builder()
.nan_string(options::COBOL)
.inf_string(options::COBOL)
.build_unchecked();
const_assert!(COBOL_STRING.is_valid());
#[rustfmt::skip]
pub const FSHARP_LITERAL: Options = Options::builder()
.nan_string(options::FSHARP_LITERAL_NAN)
.inf_string(options::FSHARP_LITERAL_INF)
.build_unchecked();
const_assert!(FSHARP_LITERAL.is_valid());
#[rustfmt::skip]
pub const VB_LITERAL: Options = Options::builder()
.nan_string(options::VB_LITERAL)
.inf_string(options::VB_LITERAL)
.build_unchecked();
const_assert!(VB_LITERAL.is_valid());
#[rustfmt::skip]
pub const VB_STRING: Options = Options::builder()
.inf_string(options::VB_STRING_INF)
.build_unchecked();
const_assert!(VB_STRING.is_valid());
#[rustfmt::skip]
pub const OCAML_LITERAL: Options = Options::builder()
.nan_string(options::OCAML_LITERAL_NAN)
.inf_string(options::OCAML_LITERAL_INF)
.build_unchecked();
const_assert!(OCAML_LITERAL.is_valid());
#[rustfmt::skip]
pub const OBJECTIVEC_LITERAL: Options = Options::builder()
.nan_string(options::OBJECTIVEC)
.inf_string(options::OBJECTIVEC)
.build_unchecked();
const_assert!(OBJECTIVEC_LITERAL.is_valid());
#[rustfmt::skip]
pub const OBJECTIVEC_STRING: Options = Options::builder()
.nan_string(options::OBJECTIVEC)
.inf_string(options::OBJECTIVEC)
.build_unchecked();
const_assert!(OBJECTIVEC_STRING.is_valid());
#[rustfmt::skip]
pub const REASONML_LITERAL: Options = Options::builder()
.nan_string(options::REASONML_LITERAL_NAN)
.inf_string(options::REASONML_LITERAL_INF)
.build_unchecked();
const_assert!(REASONML_LITERAL.is_valid());
#[rustfmt::skip]
pub const MATLAB_LITERAL: Options = Options::builder()
.inf_string(options::MATLAB_LITERAL_INF)
.build_unchecked();
const_assert!(MATLAB_LITERAL.is_valid());
#[rustfmt::skip]
pub const ZIG_LITERAL: Options = Options::builder()
.nan_string(options::ZIG_LITERAL)
.inf_string(options::ZIG_LITERAL)
.build_unchecked();
const_assert!(ZIG_LITERAL.is_valid());
#[rustfmt::skip]
pub const SAGE_LITERAL: Options = Options::builder()
.inf_string(options::SAGE_LITERAL_INF)
.build_unchecked();
const_assert!(SAGE_LITERAL.is_valid());
#[rustfmt::skip]
pub const JSON: Options = Options::builder()
.nan_string(options::JSON)
.inf_string(options::JSON)
.build_unchecked();
const_assert!(JSON.is_valid());
#[rustfmt::skip]
pub const TOML: Options = Options::builder()
.nan_string(options::TOML)
.inf_string(options::TOML)
.build_unchecked();
const_assert!(TOML.is_valid());
#[rustfmt::skip]
pub const YAML: Options = JSON;
#[rustfmt::skip]
pub const XML: Options = Options::builder()
.inf_string(options::XML_INF)
.build_unchecked();
const_assert!(XML.is_valid());
#[rustfmt::skip]
pub const SQLITE: Options = Options::builder()
.nan_string(options::SQLITE)
.inf_string(options::SQLITE)
.build_unchecked();
const_assert!(SQLITE.is_valid());
#[rustfmt::skip]
pub const POSTGRESQL: Options = Options::builder()
.nan_string(options::POSTGRESQL)
.inf_string(options::POSTGRESQL)
.build_unchecked();
const_assert!(POSTGRESQL.is_valid());
#[rustfmt::skip]
pub const MYSQL: Options = Options::builder()
.nan_string(options::MYSQL)
.inf_string(options::MYSQL)
.build_unchecked();
const_assert!(MYSQL.is_valid());
#[rustfmt::skip]
pub const MONGODB: Options = Options::builder()
.inf_string(options::MONGODB_INF)
.build_unchecked();
const_assert!(MONGODB.is_valid());