facebook/sapling
1
1
Fork 0
mirror of https://github.com/facebook/sapling.git synced 2024-10-10 08:47:12 +03:00
Code Issues Projects Releases Wiki Activity

thrift-types: recompile Thrift sources

Browse Source 
Summary: The thrift compiler and sources are changed.

Reviewed By: xavierd

Differential Revision: D20445164

fbshipit-source-id: f20f16ae02a922042f366a9a80a3642577f60e57
This commit is contained in:
Jun Wu 2020-03-13 14:22:07 -07:00 committed by Facebook GitHub Bot
parent 4312d0f3cc
commit cf04fe3e1f
3 changed files with 43 additions and 665 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
eden/scm/lib/thrift-types/eden/src/lib.rs
View File

@ -52,6 +52,7 @@ pub mod types {
pub struct MountArgument {
pub mountPoint: crate::types::PathString,
pub edenClientPath: crate::types::PathString,
pub readOnly: bool,
}
#[derive(Clone, Debug, PartialEq)]
@ -1123,6 +1124,7 @@ pub mod types {
Self {
mountPoint: Default::default(),
edenClientPath: Default::default(),
readOnly: Default::default(),
}
}
}
@ -1140,6 +1142,9 @@ pub mod types {
p.write_field_begin("edenClientPath", TType::String, 2);
Serialize::write(&self.edenClientPath, p);
p.write_field_end();
p.write_field_begin("readOnly", TType::Bool, 3);
Serialize::write(&self.readOnly, p);
p.write_field_end();
p.write_field_stop();
p.write_struct_end();
}
@ -1149,6 +1154,7 @@ pub mod types {
fn read(p: &mut P) -> anyhow::Result<Self> {
let mut field_mountPoint = None;
let mut field_edenClientPath = None;
let mut field_readOnly = None;
let _ = p.read_struct_begin(|_| ())?;
loop {
let (_, fty, fid) = p.read_field_begin(|_| ())?;
@ -1156,6 +1162,7 @@ pub mod types {
(TType::Stop, _) => break,
(TType::String, 1) => field_mountPoint = Some(Deserialize::read(p)?),
(TType::String, 2) => field_edenClientPath = Some(Deserialize::read(p)?),
(TType::Bool, 3) => field_readOnly = Some(Deserialize::read(p)?),
(fty, _) => p.skip(fty)?,
}
p.read_field_end()?;
@ -1164,6 +1171,7 @@ pub mod types {
Ok(Self {
mountPoint: field_mountPoint.unwrap_or_default(),
edenClientPath: field_edenClientPath.unwrap_or_default(),
readOnly: field_readOnly.unwrap_or_default(),
})
}
}
@ -18430,25 +18438,7 @@ pub mod errors {
}
}
#[derive(Debug, thiserror::Error)]
pub enum ChownError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for ChownError {
fn from(err: ::anyhow::Error) -> Self {
ChownError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for ChownError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
ChownError::ApplicationException(ae)
}
}
pub type ChownError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum GetScmStatusV2Error {
@ -18822,25 +18812,7 @@ pub mod errors {
}
}
#[derive(Debug, thiserror::Error)]
pub enum DebugOutstandingFuseCallsError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for DebugOutstandingFuseCallsError {
fn from(err: ::anyhow::Error) -> Self {
DebugOutstandingFuseCallsError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for DebugOutstandingFuseCallsError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
DebugOutstandingFuseCallsError::ApplicationException(ae)
}
}
pub type DebugOutstandingFuseCallsError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum DebugGetInodePathError {
@ -19122,65 +19094,11 @@ pub mod errors {
}
}
#[derive(Debug, thiserror::Error)]
pub enum EnableTracingError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
pub type EnableTracingError = ::fbthrift::NonthrowingFunctionError;
impl From<::anyhow::Error> for EnableTracingError {
fn from(err: ::anyhow::Error) -> Self {
EnableTracingError::ThriftError(err)
}
}
pub type DisableTracingError = ::fbthrift::NonthrowingFunctionError;
impl From<::fbthrift::ApplicationException> for EnableTracingError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
EnableTracingError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum DisableTracingError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for DisableTracingError {
fn from(err: ::anyhow::Error) -> Self {
DisableTracingError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for DisableTracingError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
DisableTracingError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetTracePointsError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetTracePointsError {
fn from(err: ::anyhow::Error) -> Self {
GetTracePointsError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetTracePointsError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetTracePointsError::ApplicationException(ae)
}
}
pub type GetTracePointsError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum InjectFaultError {

280
eden/scm/lib/thrift-types/fb303/src/lib.rs
View File

@ -4441,285 +4441,33 @@ pub mod mock {
pub mod errors {
pub mod facebook_service {
#[derive(Debug, thiserror::Error)]
pub enum GetRegexCountersCompressedError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
pub type GetRegexCountersCompressedError = ::fbthrift::NonthrowingFunctionError;
impl From<::anyhow::Error> for GetRegexCountersCompressedError {
fn from(err: ::anyhow::Error) -> Self {
GetRegexCountersCompressedError::ThriftError(err)
}
}
pub type GetCountersCompressedError = ::fbthrift::NonthrowingFunctionError;
impl From<::fbthrift::ApplicationException> for GetRegexCountersCompressedError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetRegexCountersCompressedError::ApplicationException(ae)
}
}
pub type GetCpuProfileError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum GetCountersCompressedError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
pub type GetCpuProfileWithOptionsError = ::fbthrift::NonthrowingFunctionError;
impl From<::anyhow::Error> for GetCountersCompressedError {
fn from(err: ::anyhow::Error) -> Self {
GetCountersCompressedError::ThriftError(err)
}
}
pub type GetHeapProfileError = ::fbthrift::NonthrowingFunctionError;
impl From<::fbthrift::ApplicationException> for GetCountersCompressedError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetCountersCompressedError::ApplicationException(ae)
}
}
pub type GetWallTimeProfileError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum GetCpuProfileError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
pub type GetMemoryUsageError = ::fbthrift::NonthrowingFunctionError;
impl From<::anyhow::Error> for GetCpuProfileError {
fn from(err: ::anyhow::Error) -> Self {
GetCpuProfileError::ThriftError(err)
}
}
pub type GetLoadError = ::fbthrift::NonthrowingFunctionError;
impl From<::fbthrift::ApplicationException> for GetCpuProfileError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetCpuProfileError::ApplicationException(ae)
}
}
pub type GetPidError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum GetCpuProfileWithOptionsError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
pub type GetCommandLineError = ::fbthrift::NonthrowingFunctionError;
impl From<::anyhow::Error> for GetCpuProfileWithOptionsError {
fn from(err: ::anyhow::Error) -> Self {
GetCpuProfileWithOptionsError::ThriftError(err)
}
}
pub type ReinitializeError = ::fbthrift::NonthrowingFunctionError;
impl From<::fbthrift::ApplicationException> for GetCpuProfileWithOptionsError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetCpuProfileWithOptionsError::ApplicationException(ae)
}
}
pub type ShutdownError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum GetHeapProfileError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
pub type TranslateFramesError = ::fbthrift::NonthrowingFunctionError;
impl From<::anyhow::Error> for GetHeapProfileError {
fn from(err: ::anyhow::Error) -> Self {
GetHeapProfileError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetHeapProfileError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetHeapProfileError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetWallTimeProfileError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetWallTimeProfileError {
fn from(err: ::anyhow::Error) -> Self {
GetWallTimeProfileError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetWallTimeProfileError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetWallTimeProfileError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetMemoryUsageError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetMemoryUsageError {
fn from(err: ::anyhow::Error) -> Self {
GetMemoryUsageError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetMemoryUsageError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetMemoryUsageError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetLoadError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetLoadError {
fn from(err: ::anyhow::Error) -> Self {
GetLoadError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetLoadError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetLoadError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetPidError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetPidError {
fn from(err: ::anyhow::Error) -> Self {
GetPidError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetPidError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetPidError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetCommandLineError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetCommandLineError {
fn from(err: ::anyhow::Error) -> Self {
GetCommandLineError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetCommandLineError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetCommandLineError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum ReinitializeError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for ReinitializeError {
fn from(err: ::anyhow::Error) -> Self {
ReinitializeError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for ReinitializeError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
ReinitializeError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum ShutdownError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for ShutdownError {
fn from(err: ::anyhow::Error) -> Self {
ShutdownError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for ShutdownError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
ShutdownError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum TranslateFramesError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for TranslateFramesError {
fn from(err: ::anyhow::Error) -> Self {
TranslateFramesError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for TranslateFramesError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
TranslateFramesError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetPcapLoggingConfigError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetPcapLoggingConfigError {
fn from(err: ::anyhow::Error) -> Self {
GetPcapLoggingConfigError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetPcapLoggingConfigError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetPcapLoggingConfigError::ApplicationException(ae)
}
}
pub type GetPcapLoggingConfigError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum SetPcapLoggingConfigError {

320
eden/scm/lib/thrift-types/fb303_core/src/lib.rs
View File

@ -4504,325 +4504,37 @@ pub mod mock {
pub mod errors {
pub mod base_service {
#[derive(Debug, thiserror::Error)]
pub enum GetStatusError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
pub type GetStatusError = ::fbthrift::NonthrowingFunctionError;
impl From<::anyhow::Error> for GetStatusError {
fn from(err: ::anyhow::Error) -> Self {
GetStatusError::ThriftError(err)
}
}
pub type GetNameError = ::fbthrift::NonthrowingFunctionError;
impl From<::fbthrift::ApplicationException> for GetStatusError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetStatusError::ApplicationException(ae)
}
}
pub type GetVersionError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum GetNameError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
pub type GetStatusDetailsError = ::fbthrift::NonthrowingFunctionError;
impl From<::anyhow::Error> for GetNameError {
fn from(err: ::anyhow::Error) -> Self {
GetNameError::ThriftError(err)
}
}
pub type GetCountersError = ::fbthrift::NonthrowingFunctionError;
impl From<::fbthrift::ApplicationException> for GetNameError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetNameError::ApplicationException(ae)
}
}
pub type GetRegexCountersError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum GetVersionError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
pub type GetSelectedCountersError = ::fbthrift::NonthrowingFunctionError;
impl From<::anyhow::Error> for GetVersionError {
fn from(err: ::anyhow::Error) -> Self {
GetVersionError::ThriftError(err)
}
}
pub type GetCounterError = ::fbthrift::NonthrowingFunctionError;
impl From<::fbthrift::ApplicationException> for GetVersionError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetVersionError::ApplicationException(ae)
}
}
pub type GetExportedValuesError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum GetStatusDetailsError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
pub type GetSelectedExportedValuesError = ::fbthrift::NonthrowingFunctionError;
impl From<::anyhow::Error> for GetStatusDetailsError {
fn from(err: ::anyhow::Error) -> Self {
GetStatusDetailsError::ThriftError(err)
}
}
pub type GetRegexExportedValuesError = ::fbthrift::NonthrowingFunctionError;
impl From<::fbthrift::ApplicationException> for GetStatusDetailsError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetStatusDetailsError::ApplicationException(ae)
}
}
pub type GetExportedValueError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum GetCountersError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
pub type SetOptionError = ::fbthrift::NonthrowingFunctionError;
impl From<::anyhow::Error> for GetCountersError {
fn from(err: ::anyhow::Error) -> Self {
GetCountersError::ThriftError(err)
}
}
pub type GetOptionError = ::fbthrift::NonthrowingFunctionError;
impl From<::fbthrift::ApplicationException> for GetCountersError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetCountersError::ApplicationException(ae)
}
}
pub type GetOptionsError = ::fbthrift::NonthrowingFunctionError;
#[derive(Debug, thiserror::Error)]
pub enum GetRegexCountersError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetRegexCountersError {
fn from(err: ::anyhow::Error) -> Self {
GetRegexCountersError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetRegexCountersError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetRegexCountersError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetSelectedCountersError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetSelectedCountersError {
fn from(err: ::anyhow::Error) -> Self {
GetSelectedCountersError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetSelectedCountersError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetSelectedCountersError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetCounterError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetCounterError {
fn from(err: ::anyhow::Error) -> Self {
GetCounterError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetCounterError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetCounterError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetExportedValuesError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetExportedValuesError {
fn from(err: ::anyhow::Error) -> Self {
GetExportedValuesError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetExportedValuesError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetExportedValuesError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetSelectedExportedValuesError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetSelectedExportedValuesError {
fn from(err: ::anyhow::Error) -> Self {
GetSelectedExportedValuesError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetSelectedExportedValuesError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetSelectedExportedValuesError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetRegexExportedValuesError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetRegexExportedValuesError {
fn from(err: ::anyhow::Error) -> Self {
GetRegexExportedValuesError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetRegexExportedValuesError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetRegexExportedValuesError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetExportedValueError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetExportedValueError {
fn from(err: ::anyhow::Error) -> Self {
GetExportedValueError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetExportedValueError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetExportedValueError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum SetOptionError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for SetOptionError {
fn from(err: ::anyhow::Error) -> Self {
SetOptionError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for SetOptionError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
SetOptionError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetOptionError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetOptionError {
fn from(err: ::anyhow::Error) -> Self {
GetOptionError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetOptionError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetOptionError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum GetOptionsError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for GetOptionsError {
fn from(err: ::anyhow::Error) -> Self {
GetOptionsError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for GetOptionsError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
GetOptionsError::ApplicationException(ae)
}
}
#[derive(Debug, thiserror::Error)]
pub enum AliveSinceError {
#[error("Application exception: {0:?}")]
ApplicationException(::fbthrift::types::ApplicationException),
#[error("{0}")]
ThriftError(::anyhow::Error),
}
impl From<::anyhow::Error> for AliveSinceError {
fn from(err: ::anyhow::Error) -> Self {
AliveSinceError::ThriftError(err)
}
}
impl From<::fbthrift::ApplicationException> for AliveSinceError {
fn from(ae: ::fbthrift::ApplicationException) -> Self {
AliveSinceError::ApplicationException(ae)
}
}
pub type AliveSinceError = ::fbthrift::NonthrowingFunctionError;
}