#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2018::*;
#[macro_use]
extern crate std;
use miniconf::Miniconf;
use serde::{Deserialize, Serialize};
extern crate test;
#[cfg(test)]
#[rustc_test_marker]
pub const atomic_struct: test::TestDescAndFn = test::TestDescAndFn {
desc: test::TestDesc {
name: test::StaticTestName("atomic_struct"),
ignore: false,
ignore_message: ::core::option::Option::None,
compile_fail: false,
no_run: false,
should_panic: test::ShouldPanic::No,
test_type: test::TestType::IntegrationTest,
},
testfn: test::StaticTestFn(|| test::assert_test_result(atomic_struct())),
};
fn atomic_struct() {
struct Inner {
a: u32,
b: u32,
}
impl miniconf::Miniconf for Inner {
fn string_set(
&mut self,
mut topic_parts: core::iter::Peekable<core::str::Split<char>>,
value: &[u8],
) -> Result<(), miniconf::Error> {
let field = topic_parts.next().ok_or(miniconf::Error::PathTooShort)?;
match field {
"a" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
self.a = miniconf::serde_json_core::from_slice(value)?.0;
Ok(())
}
"b" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
self.b = miniconf::serde_json_core::from_slice(value)?.0;
Ok(())
}
_ => Err(miniconf::Error::PathNotFound),
}
}
fn string_get(
&self,
mut topic_parts: core::iter::Peekable<core::str::Split<char>>,
value: &mut [u8],
) -> Result<usize, miniconf::Error> {
let field = topic_parts.next().ok_or(miniconf::Error::PathTooShort)?;
match field {
"a" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
miniconf::serde_json_core::to_slice(&self.a, value)
.map_err(|_| miniconf::Error::SerializationFailed)
}
"b" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
miniconf::serde_json_core::to_slice(&self.b, value)
.map_err(|_| miniconf::Error::SerializationFailed)
}
_ => Err(miniconf::Error::PathNotFound),
}
}
fn get_metadata(&self) -> miniconf::MiniconfMetadata {
let mut maximum_sizes = miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 0,
};
let mut index = 0;
loop {
let metadata = match index {
0usize => {
miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 1,
}
}
1usize => {
miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 1,
}
}
_ => break,
};
maximum_sizes
.max_topic_size = core::cmp::max(
maximum_sizes.max_topic_size,
metadata.max_topic_size,
);
maximum_sizes
.max_depth = core::cmp::max(
maximum_sizes.max_depth,
metadata.max_depth,
);
index += 1;
}
maximum_sizes.max_depth += 1;
maximum_sizes
}
fn recurse_paths<const TS: usize>(
&self,
index: &mut [usize],
topic: &mut miniconf::heapless::String<TS>,
) -> Option<()> {
if index.len() == 0 {
::core::panicking::unreachable_display(&"Index stack too small");
}
loop {
match index[0] {
0usize => {
let i = index[0];
index[0] += 1;
if i == 0 { Some(()) } else { None }
}
1usize => {
let i = index[0];
index[0] += 1;
if i == 0 { Some(()) } else { None }
}
_ => return None,
};
}
}
}
#[automatically_derived]
impl ::core::default::Default for Inner {
#[inline]
fn default() -> Inner {
Inner {
a: ::core::default::Default::default(),
b: ::core::default::Default::default(),
}
}
}
impl ::core::marker::StructuralPartialEq for Inner {}
#[automatically_derived]
impl ::core::cmp::PartialEq for Inner {
#[inline]
fn eq(&self, other: &Inner) -> bool {
self.a == other.a && self.b == other.b
}
#[inline]
fn ne(&self, other: &Inner) -> bool {
self.a != other.a || self.b != other.b
}
}
#[automatically_derived]
impl ::core::fmt::Debug for Inner {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field2_finish(
f,
"Inner",
"a",
&&self.a,
"b",
&&self.b,
)
}
}
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
#[allow(unused_extern_crates, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for Inner {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::__private::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"Inner",
false as usize + 1 + 1,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"a",
&self.a,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"b",
&self.b,
) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
#[allow(unused_extern_crates, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for Inner {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::__private::Formatter,
) -> _serde::__private::fmt::Result {
_serde::__private::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::__private::Ok(__Field::__field0),
1u64 => _serde::__private::Ok(__Field::__field1),
_ => _serde::__private::Ok(__Field::__ignore),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"a" => _serde::__private::Ok(__Field::__field0),
"b" => _serde::__private::Ok(__Field::__field1),
_ => _serde::__private::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"a" => _serde::__private::Ok(__Field::__field0),
b"b" => _serde::__private::Ok(__Field::__field1),
_ => _serde::__private::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::__private::PhantomData<Inner>,
lifetime: _serde::__private::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = Inner;
fn expecting(
&self,
__formatter: &mut _serde::__private::Formatter,
) -> _serde::__private::fmt::Result {
_serde::__private::Formatter::write_str(
__formatter,
"struct Inner",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
u32,
>(&mut __seq) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
} {
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct Inner with 2 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
u32,
>(&mut __seq) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
} {
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct Inner with 2 elements",
),
);
}
};
_serde::__private::Ok(Inner { a: __field0, b: __field1 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::__private::Option<u32> = _serde::__private::None;
let mut __field1: _serde::__private::Option<u32> = _serde::__private::None;
while let _serde::__private::Some(__key)
= match _serde::de::MapAccess::next_key::<
__Field,
>(&mut __map) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
} {
match __key {
__Field::__field0 => {
if _serde::__private::Option::is_some(&__field0) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("a"),
);
}
__field0 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<u32>(&mut __map) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::__private::Option::is_some(&__field1) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("b"),
);
}
__field1 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<u32>(&mut __map) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(&mut __map) {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::__private::Some(__field0) => __field0,
_serde::__private::None => {
match _serde::__private::de::missing_field("a") {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::__private::Some(__field1) => __field1,
_serde::__private::None => {
match _serde::__private::de::missing_field("b") {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
}
}
};
_serde::__private::Ok(Inner { a: __field0, b: __field1 })
}
}
const FIELDS: &'static [&'static str] = &["a", "b"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"Inner",
FIELDS,
__Visitor {
marker: _serde::__private::PhantomData::<Inner>,
lifetime: _serde::__private::PhantomData,
},
)
}
}
};
struct Settings {
a: f32,
b: bool,
#[miniconf(defer)]
c: Inner,
}
impl miniconf::Miniconf for Settings {
fn string_set(
&mut self,
mut topic_parts: core::iter::Peekable<core::str::Split<char>>,
value: &[u8],
) -> Result<(), miniconf::Error> {
let field = topic_parts.next().ok_or(miniconf::Error::PathTooShort)?;
match field {
"a" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
self.a = miniconf::serde_json_core::from_slice(value)?.0;
Ok(())
}
"b" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
self.b = miniconf::serde_json_core::from_slice(value)?.0;
Ok(())
}
"c" => self.c.string_set(topic_parts, value),
_ => Err(miniconf::Error::PathNotFound),
}
}
fn string_get(
&self,
mut topic_parts: core::iter::Peekable<core::str::Split<char>>,
value: &mut [u8],
) -> Result<usize, miniconf::Error> {
let field = topic_parts.next().ok_or(miniconf::Error::PathTooShort)?;
match field {
"a" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
miniconf::serde_json_core::to_slice(&self.a, value)
.map_err(|_| miniconf::Error::SerializationFailed)
}
"b" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
miniconf::serde_json_core::to_slice(&self.b, value)
.map_err(|_| miniconf::Error::SerializationFailed)
}
"c" => self.c.string_get(topic_parts, value),
_ => Err(miniconf::Error::PathNotFound),
}
}
fn get_metadata(&self) -> miniconf::MiniconfMetadata {
let mut maximum_sizes = miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 0,
};
let mut index = 0;
loop {
let metadata = match index {
0usize => {
miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 1,
}
}
1usize => {
miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 1,
}
}
2usize => {
let mut meta = self.c.get_metadata();
if meta.max_topic_size > 0 {
meta.max_topic_size += 1;
}
meta.max_topic_size += "c".len();
meta
}
_ => break,
};
maximum_sizes
.max_topic_size = core::cmp::max(
maximum_sizes.max_topic_size,
metadata.max_topic_size,
);
maximum_sizes
.max_depth = core::cmp::max(
maximum_sizes.max_depth,
metadata.max_depth,
);
index += 1;
}
maximum_sizes.max_depth += 1;
maximum_sizes
}
fn recurse_paths<const TS: usize>(
&self,
index: &mut [usize],
topic: &mut miniconf::heapless::String<TS>,
) -> Option<()> {
if index.len() == 0 {
::core::panicking::unreachable_display(&"Index stack too small");
}
loop {
match index[0] {
0usize => {
let i = index[0];
index[0] += 1;
if i == 0 { Some(()) } else { None }
}
1usize => {
let i = index[0];
index[0] += 1;
if i == 0 { Some(()) } else { None }
}
2usize => {
let original_length = topic.len();
let postfix = if topic.len() != 0 { "/c" } else { "c" };
if topic.push_str(postfix).is_err() {
::core::panicking::unreachable_display(
&"Topic buffer too short",
);
}
if self.c.recurse_paths(&mut index[1..], topic).is_some() {
return Some(());
}
topic.truncate(original_length);
index[0] += 1;
index[1..].iter_mut().for_each(|x| *x = 0);
}
_ => return None,
};
}
}
}
#[automatically_derived]
impl ::core::default::Default for Settings {
#[inline]
fn default() -> Settings {
Settings {
a: ::core::default::Default::default(),
b: ::core::default::Default::default(),
c: ::core::default::Default::default(),
}
}
}
impl ::core::marker::StructuralPartialEq for Settings {}
#[automatically_derived]
impl ::core::cmp::PartialEq for Settings {
#[inline]
fn eq(&self, other: &Settings) -> bool {
self.a == other.a && self.b == other.b && self.c == other.c
}
#[inline]
fn ne(&self, other: &Settings) -> bool {
self.a != other.a || self.b != other.b || self.c != other.c
}
}
#[automatically_derived]
impl ::core::fmt::Debug for Settings {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field3_finish(
f,
"Settings",
"a",
&&self.a,
"b",
&&self.b,
"c",
&&self.c,
)
}
}
let mut settings = Settings::default();
let field = "c/a".split('/').peekable();
if !settings.string_set(field, b"4").is_err() {
::core::panicking::panic(
"assertion failed: settings.string_set(field, b\\\"4\\\").is_err()",
)
}
let field = "c".split('/').peekable();
settings.string_set(field, b"{\"a\": 5, \"b\": 3}").unwrap();
let expected = {
let mut expected = Settings::default();
expected.c.a = 5;
expected.c.b = 3;
expected
};
match (&settings, &expected) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(
kind,
&*left_val,
&*right_val,
::core::option::Option::None,
);
}
}
};
let metadata = settings.get_metadata();
match (&metadata.max_depth, &2) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(
kind,
&*left_val,
&*right_val,
::core::option::Option::None,
);
}
}
};
match (&metadata.max_topic_size, &"c".len()) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(
kind,
&*left_val,
&*right_val,
::core::option::Option::None,
);
}
}
};
}
extern crate test;
#[cfg(test)]
#[rustc_test_marker]
pub const recursive_struct: test::TestDescAndFn = test::TestDescAndFn {
desc: test::TestDesc {
name: test::StaticTestName("recursive_struct"),
ignore: false,
ignore_message: ::core::option::Option::None,
compile_fail: false,
no_run: false,
should_panic: test::ShouldPanic::No,
test_type: test::TestType::IntegrationTest,
},
testfn: test::StaticTestFn(|| test::assert_test_result(recursive_struct())),
};
fn recursive_struct() {
struct Inner {
a: u32,
}
impl miniconf::Miniconf for Inner {
fn string_set(
&mut self,
mut topic_parts: core::iter::Peekable<core::str::Split<char>>,
value: &[u8],
) -> Result<(), miniconf::Error> {
let field = topic_parts.next().ok_or(miniconf::Error::PathTooShort)?;
match field {
"a" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
self.a = miniconf::serde_json_core::from_slice(value)?.0;
Ok(())
}
_ => Err(miniconf::Error::PathNotFound),
}
}
fn string_get(
&self,
mut topic_parts: core::iter::Peekable<core::str::Split<char>>,
value: &mut [u8],
) -> Result<usize, miniconf::Error> {
let field = topic_parts.next().ok_or(miniconf::Error::PathTooShort)?;
match field {
"a" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
miniconf::serde_json_core::to_slice(&self.a, value)
.map_err(|_| miniconf::Error::SerializationFailed)
}
_ => Err(miniconf::Error::PathNotFound),
}
}
fn get_metadata(&self) -> miniconf::MiniconfMetadata {
let mut maximum_sizes = miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 0,
};
let mut index = 0;
loop {
let metadata = match index {
0usize => {
miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 1,
}
}
_ => break,
};
maximum_sizes
.max_topic_size = core::cmp::max(
maximum_sizes.max_topic_size,
metadata.max_topic_size,
);
maximum_sizes
.max_depth = core::cmp::max(
maximum_sizes.max_depth,
metadata.max_depth,
);
index += 1;
}
maximum_sizes.max_depth += 1;
maximum_sizes
}
fn recurse_paths<const TS: usize>(
&self,
index: &mut [usize],
topic: &mut miniconf::heapless::String<TS>,
) -> Option<()> {
if index.len() == 0 {
::core::panicking::unreachable_display(&"Index stack too small");
}
loop {
match index[0] {
0usize => {
let i = index[0];
index[0] += 1;
if i == 0 { Some(()) } else { None }
}
_ => return None,
};
}
}
}
#[automatically_derived]
impl ::core::default::Default for Inner {
#[inline]
fn default() -> Inner {
Inner {
a: ::core::default::Default::default(),
}
}
}
impl ::core::marker::StructuralPartialEq for Inner {}
#[automatically_derived]
impl ::core::cmp::PartialEq for Inner {
#[inline]
fn eq(&self, other: &Inner) -> bool {
self.a == other.a
}
#[inline]
fn ne(&self, other: &Inner) -> bool {
self.a != other.a
}
}
#[automatically_derived]
impl ::core::fmt::Debug for Inner {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field1_finish(f, "Inner", "a", &&self.a)
}
}
struct Settings {
a: f32,
b: bool,
#[miniconf(defer)]
c: Inner,
}
impl miniconf::Miniconf for Settings {
fn string_set(
&mut self,
mut topic_parts: core::iter::Peekable<core::str::Split<char>>,
value: &[u8],
) -> Result<(), miniconf::Error> {
let field = topic_parts.next().ok_or(miniconf::Error::PathTooShort)?;
match field {
"a" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
self.a = miniconf::serde_json_core::from_slice(value)?.0;
Ok(())
}
"b" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
self.b = miniconf::serde_json_core::from_slice(value)?.0;
Ok(())
}
"c" => self.c.string_set(topic_parts, value),
_ => Err(miniconf::Error::PathNotFound),
}
}
fn string_get(
&self,
mut topic_parts: core::iter::Peekable<core::str::Split<char>>,
value: &mut [u8],
) -> Result<usize, miniconf::Error> {
let field = topic_parts.next().ok_or(miniconf::Error::PathTooShort)?;
match field {
"a" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
miniconf::serde_json_core::to_slice(&self.a, value)
.map_err(|_| miniconf::Error::SerializationFailed)
}
"b" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
miniconf::serde_json_core::to_slice(&self.b, value)
.map_err(|_| miniconf::Error::SerializationFailed)
}
"c" => self.c.string_get(topic_parts, value),
_ => Err(miniconf::Error::PathNotFound),
}
}
fn get_metadata(&self) -> miniconf::MiniconfMetadata {
let mut maximum_sizes = miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 0,
};
let mut index = 0;
loop {
let metadata = match index {
0usize => {
miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 1,
}
}
1usize => {
miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 1,
}
}
2usize => {
let mut meta = self.c.get_metadata();
if meta.max_topic_size > 0 {
meta.max_topic_size += 1;
}
meta.max_topic_size += "c".len();
meta
}
_ => break,
};
maximum_sizes
.max_topic_size = core::cmp::max(
maximum_sizes.max_topic_size,
metadata.max_topic_size,
);
maximum_sizes
.max_depth = core::cmp::max(
maximum_sizes.max_depth,
metadata.max_depth,
);
index += 1;
}
maximum_sizes.max_depth += 1;
maximum_sizes
}
fn recurse_paths<const TS: usize>(
&self,
index: &mut [usize],
topic: &mut miniconf::heapless::String<TS>,
) -> Option<()> {
if index.len() == 0 {
::core::panicking::unreachable_display(&"Index stack too small");
}
loop {
match index[0] {
0usize => {
let i = index[0];
index[0] += 1;
if i == 0 { Some(()) } else { None }
}
1usize => {
let i = index[0];
index[0] += 1;
if i == 0 { Some(()) } else { None }
}
2usize => {
let original_length = topic.len();
let postfix = if topic.len() != 0 { "/c" } else { "c" };
if topic.push_str(postfix).is_err() {
::core::panicking::unreachable_display(
&"Topic buffer too short",
);
}
if self.c.recurse_paths(&mut index[1..], topic).is_some() {
return Some(());
}
topic.truncate(original_length);
index[0] += 1;
index[1..].iter_mut().for_each(|x| *x = 0);
}
_ => return None,
};
}
}
}
#[automatically_derived]
impl ::core::default::Default for Settings {
#[inline]
fn default() -> Settings {
Settings {
a: ::core::default::Default::default(),
b: ::core::default::Default::default(),
c: ::core::default::Default::default(),
}
}
}
impl ::core::marker::StructuralPartialEq for Settings {}
#[automatically_derived]
impl ::core::cmp::PartialEq for Settings {
#[inline]
fn eq(&self, other: &Settings) -> bool {
self.a == other.a && self.b == other.b && self.c == other.c
}
#[inline]
fn ne(&self, other: &Settings) -> bool {
self.a != other.a || self.b != other.b || self.c != other.c
}
}
#[automatically_derived]
impl ::core::fmt::Debug for Settings {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field3_finish(
f,
"Settings",
"a",
&&self.a,
"b",
&&self.b,
"c",
&&self.c,
)
}
}
let mut settings = Settings::default();
let field = "c/a".split('/').peekable();
settings.string_set(field, b"3").unwrap();
let expected = {
let mut expected = Settings::default();
expected.c.a = 3;
expected
};
match (&settings, &expected) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(
kind,
&*left_val,
&*right_val,
::core::option::Option::None,
);
}
}
};
let field = "c".split('/').peekable();
if !settings.string_set(field, b"{\"a\": 5}").is_err() {
::core::panicking::panic(
"assertion failed: settings.string_set(field, b\\\"{\\\\\\\"a\\\\\\\": 5}\\\").is_err()",
)
}
let metadata = settings.get_metadata();
match (&metadata.max_depth, &3) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(
kind,
&*left_val,
&*right_val,
::core::option::Option::None,
);
}
}
};
match (&metadata.max_topic_size, &"c/a".len()) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(
kind,
&*left_val,
&*right_val,
::core::option::Option::None,
);
}
}
};
}
extern crate test;
#[cfg(test)]
#[rustc_test_marker]
pub const struct_with_string: test::TestDescAndFn = test::TestDescAndFn {
desc: test::TestDesc {
name: test::StaticTestName("struct_with_string"),
ignore: false,
ignore_message: ::core::option::Option::None,
compile_fail: false,
no_run: false,
should_panic: test::ShouldPanic::No,
test_type: test::TestType::IntegrationTest,
},
testfn: test::StaticTestFn(|| test::assert_test_result(struct_with_string())),
};
fn struct_with_string() {
struct Settings {
string: heapless::String<10>,
}
impl miniconf::Miniconf for Settings {
fn string_set(
&mut self,
mut topic_parts: core::iter::Peekable<core::str::Split<char>>,
value: &[u8],
) -> Result<(), miniconf::Error> {
let field = topic_parts.next().ok_or(miniconf::Error::PathTooShort)?;
match field {
"string" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
self.string = miniconf::serde_json_core::from_slice(value)?.0;
Ok(())
}
_ => Err(miniconf::Error::PathNotFound),
}
}
fn string_get(
&self,
mut topic_parts: core::iter::Peekable<core::str::Split<char>>,
value: &mut [u8],
) -> Result<usize, miniconf::Error> {
let field = topic_parts.next().ok_or(miniconf::Error::PathTooShort)?;
match field {
"string" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
miniconf::serde_json_core::to_slice(&self.string, value)
.map_err(|_| miniconf::Error::SerializationFailed)
}
_ => Err(miniconf::Error::PathNotFound),
}
}
fn get_metadata(&self) -> miniconf::MiniconfMetadata {
let mut maximum_sizes = miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 0,
};
let mut index = 0;
loop {
let metadata = match index {
0usize => {
miniconf::MiniconfMetadata {
max_topic_size: 0,
max_depth: 1,
}
}
_ => break,
};
maximum_sizes
.max_topic_size = core::cmp::max(
maximum_sizes.max_topic_size,
metadata.max_topic_size,
);
maximum_sizes
.max_depth = core::cmp::max(
maximum_sizes.max_depth,
metadata.max_depth,
);
index += 1;
}
maximum_sizes.max_depth += 1;
maximum_sizes
}
fn recurse_paths<const TS: usize>(
&self,
index: &mut [usize],
topic: &mut miniconf::heapless::String<TS>,
) -> Option<()> {
if index.len() == 0 {
::core::panicking::unreachable_display(&"Index stack too small");
}
loop {
match index[0] {
0usize => {
let i = index[0];
index[0] += 1;
if i == 0 { Some(()) } else { None }
}
_ => return None,
};
}
}
}
#[automatically_derived]
impl ::core::default::Default for Settings {
#[inline]
fn default() -> Settings {
Settings {
string: ::core::default::Default::default(),
}
}
}
let mut s = Settings::default();
let field = "string".split('/').peekable();
let mut buf = [0u8; 256];
let len = s.string_get(field, &mut buf).unwrap();
match (&&buf[..len], &b"\"\"") {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(
kind,
&*left_val,
&*right_val,
::core::option::Option::None,
);
}
}
};
let field = "string".split('/').peekable();
s.string_set(field, br#""test""#).unwrap();
match (&s.string, &"test") {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(
kind,
&*left_val,
&*right_val,
::core::option::Option::None,
);
}
}
};
}
#[rustc_main]
pub fn main() -> () {
extern crate test;
test::test_main_static(&[&atomic_struct, &recursive_struct, &struct_with_string])
}