#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_execute_statement_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::BatchExecuteStatementOutput,
crate::error::BatchExecuteStatementError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::BatchExecuteStatementError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::BatchExecuteStatementError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::BatchExecuteStatementError {
meta: generic,
kind: crate::error::BatchExecuteStatementErrorKind::AccessDeniedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::access_denied_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_access_denied_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchExecuteStatementError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::BatchExecuteStatementError {
meta: generic,
kind: crate::error::BatchExecuteStatementErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchExecuteStatementError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::BatchExecuteStatementError {
meta: generic,
kind: crate::error::BatchExecuteStatementErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchExecuteStatementError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::BatchExecuteStatementError {
meta: generic,
kind: crate::error::BatchExecuteStatementErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchExecuteStatementError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableError" => crate::error::BatchExecuteStatementError {
meta: generic,
kind: crate::error::BatchExecuteStatementErrorKind::ServiceUnavailableError({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_unavailable_error::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_error_json_err(response.body().as_ref(), output).map_err(crate::error::BatchExecuteStatementError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"StatementTimeoutException" => crate::error::BatchExecuteStatementError {
meta: generic,
kind: crate::error::BatchExecuteStatementErrorKind::StatementTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::statement_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_statement_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchExecuteStatementError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::BatchExecuteStatementError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_execute_statement_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::BatchExecuteStatementOutput,
crate::error::BatchExecuteStatementError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::batch_execute_statement_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_batch_execute_statement(
response.body().as_ref(),
output,
)
.map_err(crate::error::BatchExecuteStatementError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_begin_transaction_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BeginTransactionOutput, crate::error::BeginTransactionError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::BeginTransactionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::BeginTransactionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::BeginTransactionError {
meta: generic,
kind: crate::error::BeginTransactionErrorKind::AccessDeniedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::access_denied_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_access_denied_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BeginTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::BeginTransactionError {
meta: generic,
kind: crate::error::BeginTransactionErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BeginTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::BeginTransactionError {
meta: generic,
kind: crate::error::BeginTransactionErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BeginTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::BeginTransactionError {
meta: generic,
kind: crate::error::BeginTransactionErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BeginTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableError" => crate::error::BeginTransactionError {
meta: generic,
kind: crate::error::BeginTransactionErrorKind::ServiceUnavailableError({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_unavailable_error::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_error_json_err(response.body().as_ref(), output).map_err(crate::error::BeginTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"StatementTimeoutException" => crate::error::BeginTransactionError {
meta: generic,
kind: crate::error::BeginTransactionErrorKind::StatementTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::statement_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_statement_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BeginTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::BeginTransactionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_begin_transaction_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BeginTransactionOutput, crate::error::BeginTransactionError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::begin_transaction_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_begin_transaction(
response.body().as_ref(),
output,
)
.map_err(crate::error::BeginTransactionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_commit_transaction_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CommitTransactionOutput, crate::error::CommitTransactionError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CommitTransactionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CommitTransactionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::CommitTransactionError {
meta: generic,
kind: crate::error::CommitTransactionErrorKind::AccessDeniedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::access_denied_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_access_denied_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CommitTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::CommitTransactionError {
meta: generic,
kind: crate::error::CommitTransactionErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CommitTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::CommitTransactionError {
meta: generic,
kind: crate::error::CommitTransactionErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CommitTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::CommitTransactionError {
meta: generic,
kind: crate::error::CommitTransactionErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CommitTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::CommitTransactionError {
meta: generic,
kind: crate::error::CommitTransactionErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CommitTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableError" => crate::error::CommitTransactionError {
meta: generic,
kind: crate::error::CommitTransactionErrorKind::ServiceUnavailableError({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_unavailable_error::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_error_json_err(response.body().as_ref(), output).map_err(crate::error::CommitTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"StatementTimeoutException" => crate::error::CommitTransactionError {
meta: generic,
kind: crate::error::CommitTransactionErrorKind::StatementTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::statement_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_statement_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CommitTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CommitTransactionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_commit_transaction_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CommitTransactionOutput, crate::error::CommitTransactionError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::commit_transaction_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_commit_transaction(
response.body().as_ref(),
output,
)
.map_err(crate::error::CommitTransactionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_execute_sql_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ExecuteSqlOutput, crate::error::ExecuteSqlError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ExecuteSqlError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ExecuteSqlError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ExecuteSqlError {
meta: generic,
kind: crate::error::ExecuteSqlErrorKind::AccessDeniedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::access_denied_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_access_denied_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExecuteSqlError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::ExecuteSqlError {
meta: generic,
kind: crate::error::ExecuteSqlErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExecuteSqlError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ExecuteSqlError {
meta: generic,
kind: crate::error::ExecuteSqlErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExecuteSqlError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ExecuteSqlError {
meta: generic,
kind: crate::error::ExecuteSqlErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExecuteSqlError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableError" => crate::error::ExecuteSqlError {
meta: generic,
kind: crate::error::ExecuteSqlErrorKind::ServiceUnavailableError({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_unavailable_error::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_error_json_err(response.body().as_ref(), output).map_err(crate::error::ExecuteSqlError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ExecuteSqlError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_execute_sql_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ExecuteSqlOutput, crate::error::ExecuteSqlError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::execute_sql_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_execute_sql(
response.body().as_ref(),
output,
)
.map_err(crate::error::ExecuteSqlError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_execute_statement_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ExecuteStatementOutput, crate::error::ExecuteStatementError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ExecuteStatementError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ExecuteStatementError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::ExecuteStatementError {
meta: generic,
kind: crate::error::ExecuteStatementErrorKind::AccessDeniedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::access_denied_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_access_denied_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExecuteStatementError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::ExecuteStatementError {
meta: generic,
kind: crate::error::ExecuteStatementErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExecuteStatementError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ExecuteStatementError {
meta: generic,
kind: crate::error::ExecuteStatementErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExecuteStatementError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ExecuteStatementError {
meta: generic,
kind: crate::error::ExecuteStatementErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExecuteStatementError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableError" => crate::error::ExecuteStatementError {
meta: generic,
kind: crate::error::ExecuteStatementErrorKind::ServiceUnavailableError({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_unavailable_error::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_error_json_err(response.body().as_ref(), output).map_err(crate::error::ExecuteStatementError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"StatementTimeoutException" => crate::error::ExecuteStatementError {
meta: generic,
kind: crate::error::ExecuteStatementErrorKind::StatementTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::statement_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_statement_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExecuteStatementError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ExecuteStatementError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_execute_statement_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ExecuteStatementOutput, crate::error::ExecuteStatementError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::execute_statement_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_execute_statement(
response.body().as_ref(),
output,
)
.map_err(crate::error::ExecuteStatementError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_rollback_transaction_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RollbackTransactionOutput,
crate::error::RollbackTransactionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::RollbackTransactionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::RollbackTransactionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::RollbackTransactionError {
meta: generic,
kind: crate::error::RollbackTransactionErrorKind::AccessDeniedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::access_denied_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_access_denied_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RollbackTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::RollbackTransactionError {
meta: generic,
kind: crate::error::RollbackTransactionErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RollbackTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::RollbackTransactionError {
meta: generic,
kind: crate::error::RollbackTransactionErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RollbackTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::RollbackTransactionError {
meta: generic,
kind: crate::error::RollbackTransactionErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RollbackTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::RollbackTransactionError {
meta: generic,
kind: crate::error::RollbackTransactionErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RollbackTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableError" => crate::error::RollbackTransactionError {
meta: generic,
kind: crate::error::RollbackTransactionErrorKind::ServiceUnavailableError({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::service_unavailable_error::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_error_json_err(response.body().as_ref(), output).map_err(crate::error::RollbackTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"StatementTimeoutException" => crate::error::RollbackTransactionError {
meta: generic,
kind: crate::error::RollbackTransactionErrorKind::StatementTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::statement_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_statement_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RollbackTransactionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::RollbackTransactionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_rollback_transaction_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RollbackTransactionOutput,
crate::error::RollbackTransactionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::rollback_transaction_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_rollback_transaction(
response.body().as_ref(),
output,
)
.map_err(crate::error::RollbackTransactionError::unhandled)?;
output.build()
})
}