#![feature(prelude_import)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
use snafu::{ensure, Backtrace, ErrorCompat, ResultExt, Snafu};
use std::{
fs,
path::{Path, PathBuf},
};
const CONFIG_DIRECTORY: &str = "";
const USER_ID: i32 = 0;
pub enum Error {
# [ snafu ( display ( "Could not open config from {}: {}" , filename . display ( ) , source ) ) ]
OpenConfig {
filename: PathBuf,
source: std::io::Error,
},
# [ snafu ( display ( "Could not save config to {}: {}" , filename . display ( ) , source ) ) ]
SaveConfig {
filename: PathBuf,
source: std::io::Error,
},
#[snafu(display("The user id {} is invalid", user_id))]
UserIdInvalid { user_id: i32, backtrace: Backtrace },
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Error {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&Error::OpenConfig {
filename: ref __self_0,
source: ref __self_1,
},) => {
let mut debug_trait_builder = f.debug_struct("OpenConfig");
let _ = debug_trait_builder.field("filename", &&(*__self_0));
let _ = debug_trait_builder.field("source", &&(*__self_1));
debug_trait_builder.finish()
}
(&Error::SaveConfig {
filename: ref __self_0,
source: ref __self_1,
},) => {
let mut debug_trait_builder = f.debug_struct("SaveConfig");
let _ = debug_trait_builder.field("filename", &&(*__self_0));
let _ = debug_trait_builder.field("source", &&(*__self_1));
debug_trait_builder.finish()
}
(&Error::UserIdInvalid {
user_id: ref __self_0,
backtrace: ref __self_1,
},) => {
let mut debug_trait_builder = f.debug_struct("UserIdInvalid");
let _ = debug_trait_builder.field("user_id", &&(*__self_0));
let _ = debug_trait_builder.field("backtrace", &&(*__self_1));
debug_trait_builder.finish()
}
}
}
}
struct OpenConfig<__T0> {
filename: __T0,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<__T0: ::core::fmt::Debug> ::core::fmt::Debug for OpenConfig<__T0> {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
OpenConfig {
filename: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("OpenConfig");
let _ = debug_trait_builder.field("filename", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<__T0: ::core::marker::Copy> ::core::marker::Copy for OpenConfig<__T0> {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<__T0: ::core::clone::Clone> ::core::clone::Clone for OpenConfig<__T0> {
#[inline]
fn clone(&self) -> OpenConfig<__T0> {
match *self {
OpenConfig {
filename: ref __self_0_0,
} => OpenConfig {
filename: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
impl<__T0> snafu::IntoError<Error> for OpenConfig<__T0>
where
Error: std::error::Error + snafu::ErrorCompat,
__T0: std::convert::Into<PathBuf>,
{
type Source = std::io::Error;
#[allow(unused_variables)]
fn into_error(self, error: Self::Source) -> Error {
Error::OpenConfig {
source: (|v| v)(error),
filename: self.filename.into(),
}
}
}
struct SaveConfig<__T0> {
filename: __T0,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<__T0: ::core::fmt::Debug> ::core::fmt::Debug for SaveConfig<__T0> {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
SaveConfig {
filename: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("SaveConfig");
let _ = debug_trait_builder.field("filename", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<__T0: ::core::marker::Copy> ::core::marker::Copy for SaveConfig<__T0> {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<__T0: ::core::clone::Clone> ::core::clone::Clone for SaveConfig<__T0> {
#[inline]
fn clone(&self) -> SaveConfig<__T0> {
match *self {
SaveConfig {
filename: ref __self_0_0,
} => SaveConfig {
filename: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
impl<__T0> snafu::IntoError<Error> for SaveConfig<__T0>
where
Error: std::error::Error + snafu::ErrorCompat,
__T0: std::convert::Into<PathBuf>,
{
type Source = std::io::Error;
#[allow(unused_variables)]
fn into_error(self, error: Self::Source) -> Error {
Error::SaveConfig {
source: (|v| v)(error),
filename: self.filename.into(),
}
}
}
struct UserIdInvalid<__T0> {
user_id: __T0,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<__T0: ::core::fmt::Debug> ::core::fmt::Debug for UserIdInvalid<__T0> {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
UserIdInvalid {
user_id: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("UserIdInvalid");
let _ = debug_trait_builder.field("user_id", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<__T0: ::core::marker::Copy> ::core::marker::Copy for UserIdInvalid<__T0> {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<__T0: ::core::clone::Clone> ::core::clone::Clone for UserIdInvalid<__T0> {
#[inline]
fn clone(&self) -> UserIdInvalid<__T0> {
match *self {
UserIdInvalid {
user_id: ref __self_0_0,
} => UserIdInvalid {
user_id: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
impl<__T0> UserIdInvalid<__T0> {
fn fail<__T>(self) -> std::result::Result<__T, Error>
where
__T0: std::convert::Into<i32>,
{
let Self { user_id } = self;
let error = Error::UserIdInvalid {
backtrace: std::default::Default::default(),
user_id: std::convert::Into::into(user_id),
};
std::result::Result::Err(error)
}
}
impl<__T0> snafu::IntoError<Error> for UserIdInvalid<__T0>
where
Error: std::error::Error + snafu::ErrorCompat,
__T0: std::convert::Into<i32>,
{
type Source = snafu::NoneError;
#[allow(unused_variables)]
fn into_error(self, error: Self::Source) -> Error {
Error::UserIdInvalid {
backtrace: std::default::Default::default(),
user_id: self.user_id.into(),
}
}
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
#[allow(unused_variables)]
match *self {
Error::OpenConfig {
ref filename,
ref source,
} => f.write_fmt(::core::fmt::Arguments::new_v1(
&["Could not open config from ", ": "],
&match (&filename.display(), &source) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
],
},
)),
Error::SaveConfig {
ref filename,
ref source,
} => f.write_fmt(::core::fmt::Arguments::new_v1(
&["Could not save config to ", ": "],
&match (&filename.display(), &source) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
],
},
)),
Error::UserIdInvalid {
ref user_id,
ref backtrace,
} => f.write_fmt(::core::fmt::Arguments::new_v1(
&["The user id ", " is invalid"],
&match (&user_id,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
)),
}
}
}
impl std::error::Error for Error
where
Self: std::fmt::Debug + std::fmt::Display,
{
fn description(&self) -> &str {
match *self {
Error::OpenConfig { .. } => "Error :: OpenConfig",
Error::SaveConfig { .. } => "Error :: SaveConfig",
Error::UserIdInvalid { .. } => "Error :: UserIdInvalid",
}
}
fn cause(&self) -> Option<&std::error::Error> {
use snafu::AsErrorSource;
match *self {
Error::OpenConfig { ref source, .. } => {
std::option::Option::Some(source.as_error_source())
}
Error::SaveConfig { ref source, .. } => {
std::option::Option::Some(source.as_error_source())
}
Error::UserIdInvalid { .. } => std::option::Option::None,
}
}
fn source(&self) -> Option<&(std::error::Error + 'static)> {
use snafu::AsErrorSource;
match *self {
Error::OpenConfig { ref source, .. } => {
std::option::Option::Some(source.as_error_source())
}
Error::SaveConfig { ref source, .. } => {
std::option::Option::Some(source.as_error_source())
}
Error::UserIdInvalid { .. } => std::option::Option::None,
}
}
}
impl snafu::ErrorCompat for Error {
fn backtrace(&self) -> Option<&snafu::Backtrace> {
match *self {
Error::OpenConfig { .. } => std::option::Option::None,
Error::SaveConfig { .. } => std::option::Option::None,
Error::UserIdInvalid { ref backtrace, .. } => std::option::Option::Some(backtrace),
}
}
}
pub type Result<T, E = Error> = std::result::Result<T, E>;
pub fn log_in_user<P>(config_root: P, user_id: i32) -> Result<bool>
where
P: AsRef<Path>,
{
let config_root = config_root.as_ref();
let filename = &config_root.join("config.toml");
let config = fs::read(filename).context(OpenConfig { filename })?;
fs::write(filename, config).context(SaveConfig { filename })?;
if !(user_id == 42) {
return UserIdInvalid { user_id }.fail();
};
Ok(true)
}
pub fn log_in() {
match log_in_user(CONFIG_DIRECTORY, USER_ID) {
Ok(true) => {
::std::io::_print(::core::fmt::Arguments::new_v1(
&["Logged in!\n"],
&match () {
() => [],
},
));
}
Ok(false) => {
::std::io::_print(::core::fmt::Arguments::new_v1(
&["Not logged in!\n"],
&match () {
() => [],
},
));
}
Err(e) => {
{
::std::io::_eprint(::core::fmt::Arguments::new_v1(
&["An error occurred: ", "\n"],
&match (&e,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
};
if let Some(backtrace) = ErrorCompat::backtrace(&e) {
{
::std::io::_print(::core::fmt::Arguments::new_v1(
&["", "\n"],
&match (&backtrace,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
};
}
}
}
}