#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2018::*;
#[macro_use]
extern crate std;
use miniconf::Miniconf;
struct Inner {
inner: f32,
}
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 {
"inner" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
self.inner = 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 {
"inner" => {
if topic_parts.peek().is_some() {
return Err(miniconf::Error::PathTooLong);
}
miniconf::serde_json_core::to_slice(&self.inner, 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: "inner".len(),
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;
let postfix = if topic.len() != 0 { "/inner" } else { "inner" };
if topic.push_str(postfix).is_err() {
::core::panicking::unreachable_display(
&"Topic buffer too short",
);
}
return Some(());
}
_ => return None,
};
}
}
}
#[automatically_derived]
impl ::core::default::Default for Inner {
#[inline]
fn default() -> Inner {
Inner {
inner: ::core::default::Default::default(),
}
}
}
struct Settings {
a: f32,
b: i32,
#[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: "a".len(),
max_depth: 1,
}
}
1usize => {
miniconf::MiniconfMetadata {
max_topic_size: "b".len(),
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;
let postfix = if topic.len() != 0 { "/a" } else { "a" };
if topic.push_str(postfix).is_err() {
::core::panicking::unreachable_display(
&"Topic buffer too short",
);
}
return Some(());
}
1usize => {
let i = index[0];
index[0] += 1;
let postfix = if topic.len() != 0 { "/b" } else { "b" };
if topic.push_str(postfix).is_err() {
::core::panicking::unreachable_display(
&"Topic buffer too short",
);
}
return Some(());
}
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(),
}
}
}
extern crate test;
#[cfg(test)]
#[rustc_test_marker]
pub const insufficient_space: test::TestDescAndFn = test::TestDescAndFn {
desc: test::TestDesc {
name: test::StaticTestName("insufficient_space"),
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(insufficient_space())),
};
fn insufficient_space() {
let settings = Settings::default();
let meta = settings.get_metadata();
match (&meta.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 (&meta.max_topic_size, &"c/inner".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,
);
}
}
};
let mut small_state = [0; 2];
if !settings.iter_settings::<256>(&mut small_state).is_err() {
::core::panicking::panic(
"assertion failed: settings.iter_settings::<256>(&mut small_state).is_err()",
)
}
let mut state = [0; 10];
if !settings.iter_settings::<1>(&mut state).is_err() {
::core::panicking::panic(
"assertion failed: settings.iter_settings::<1>(&mut state).is_err()",
)
}
}
extern crate test;
#[cfg(test)]
#[rustc_test_marker]
pub const test_iteration: test::TestDescAndFn = test::TestDescAndFn {
desc: test::TestDesc {
name: test::StaticTestName("test_iteration"),
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(test_iteration())),
};
fn test_iteration() {
let settings = Settings::default();
let mut iterated = std::collections::HashMap::from([
("a".to_string(), false),
("b".to_string(), false),
("c/inner".to_string(), false),
]);
let mut iter_state = [0; 32];
for field in settings.iter_settings::<256>(&mut iter_state).unwrap() {
if !iterated.contains_key(&field.as_str().to_string()) {
::core::panicking::panic(
"assertion failed: iterated.contains_key(&field.as_str().to_string())",
)
}
iterated.insert(field.as_str().to_string(), true);
}
if !iterated.iter().map(|(_, value)| value).all(|&x| x) {
::core::panicking::panic(
"assertion failed: iterated.iter().map(|(_, value)| value).all(|&x| x)",
)
}
}
extern crate test;
#[cfg(test)]
#[rustc_test_marker]
pub const test_array_iteration: test::TestDescAndFn = test::TestDescAndFn {
desc: test::TestDesc {
name: test::StaticTestName("test_array_iteration"),
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(test_array_iteration())),
};
fn test_array_iteration() {
struct Settings {
#[miniconf(defer)]
data: [bool; 5],
}
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 {
"data" => self.data.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 {
"data" => self.data.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 => {
let mut meta = self.data.get_metadata();
if meta.max_topic_size > 0 {
meta.max_topic_size += 1;
}
meta.max_topic_size += "data".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 original_length = topic.len();
let postfix = if topic.len() != 0 { "/data" } else { "data" };
if topic.push_str(postfix).is_err() {
::core::panicking::unreachable_display(
&"Topic buffer too short",
);
}
if self.data.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 {
data: ::core::default::Default::default(),
}
}
}
let settings = Settings::default();
let mut settings_copy = Settings::default();
let mut iter_state = [0; 32];
for field in settings.iter_settings::<256>(&mut iter_state).unwrap() {
settings_copy.set(&field, b"true").unwrap();
}
if !settings_copy.data.iter().all(|x| *x) {
::core::panicking::panic(
"assertion failed: settings_copy.data.iter().all(|x| *x)",
)
}
}
#[rustc_main]
pub fn main() -> () {
extern crate test;
test::test_main_static(
&[&insufficient_space, &test_iteration, &test_array_iteration],
)
}