Enum authzen_core::ActionError
source · pub enum ActionError<E1, E2, E3> {
Authz(E1),
Storage(E2),
TransactionCache(E3),
}Expand description
Represents the possible sources of error when performing an action which requires authorization.
Variants§
Authz(E1)
Wraps an error returned from a DecisionMaker when the subject is either not authorized to
perform an action or some other issue occurs while communicating with the
DecisionMaker.
Storage(E2)
Wraps an error returned from a StorageClient when the subject has been authorized to
perform an action but there an error occurs while actually performing the error. Examples
of this include network errors while communicating with an api or database, unique
constraint violations raised by a database, etc.
TransactionCache(E3)
Wraps an error returned from a TransactionCache when updating the transaction
cache after a successful performance of the action.
Implementations§
source§impl<E1, E2, E3> ActionError<E1, E2, E3>
impl<E1, E2, E3> ActionError<E1, E2, E3>
pub fn is_authz(&self) -> bool
pub fn is_storage(&self) -> bool
pub fn is_transaction_cache(&self) -> bool
source§impl<E1, E2, E3> ActionError<E1, E2, E3>
impl<E1, E2, E3> ActionError<E1, E2, E3>
pub fn unwrap_authz(self) -> E1
pub fn unwrap_storage(self) -> E2
pub fn unwrap_transaction_cache(self) -> E3
source§impl<E1, E2, E3> ActionError<E1, E2, E3>
impl<E1, E2, E3> ActionError<E1, E2, E3>
Trait Implementations§
source§impl<E1: Clone, E2: Clone, E3: Clone> Clone for ActionError<E1, E2, E3>
impl<E1: Clone, E2: Clone, E3: Clone> Clone for ActionError<E1, E2, E3>
source§fn clone(&self) -> ActionError<E1, E2, E3>
fn clone(&self) -> ActionError<E1, E2, E3>
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read moresource§impl<E1, E2, E3> Error for ActionError<E1, E2, E3>where
E1: Debug + Display + Error + 'static,
E3: Debug + Display + Error + 'static,
E2: Debug + Display + Error + 'static,
ActionError<E1, E2, E3>: Debug + Display,
impl<E1, E2, E3> Error for ActionError<E1, E2, E3>where E1: Debug + Display + Error + 'static, E3: Debug + Display + Error + 'static, E2: Debug + Display + Error + 'static, ActionError<E1, E2, E3>: Debug + Display,
source§fn source(&self) -> Option<&(dyn Error + 'static)>
fn source(&self) -> Option<&(dyn Error + 'static)>
The lower-level source of this error, if any. Read more
1.0.0 · source§fn description(&self) -> &str
fn description(&self) -> &str
👎Deprecated since 1.42.0: use the Display impl or to_string()
source§impl<DecisionMakerError, StorageError, TransactionCacheError> From<ActionError<DecisionMakerError, StorageError, TransactionCacheError>> for Errorwhere
DecisionMakerError: Display,
StorageError: Into<Error>,
TransactionCacheError: Into<Error>,
Available on crate feature extra-traits only.
impl<DecisionMakerError, StorageError, TransactionCacheError> From<ActionError<DecisionMakerError, StorageError, TransactionCacheError>> for Errorwhere DecisionMakerError: Display, StorageError: Into<Error>, TransactionCacheError: Into<Error>,
Available on crate feature
extra-traits only.source§fn from(
value: ActionError<DecisionMakerError, StorageError, TransactionCacheError>
) -> Self
fn from( value: ActionError<DecisionMakerError, StorageError, TransactionCacheError> ) -> Self
Converts to this type from the input type.
impl<E1: Copy, E2: Copy, E3: Copy> Copy for ActionError<E1, E2, E3>
Auto Trait Implementations§
impl<E1, E2, E3> RefUnwindSafe for ActionError<E1, E2, E3>where E1: RefUnwindSafe, E2: RefUnwindSafe, E3: RefUnwindSafe,
impl<E1, E2, E3> Send for ActionError<E1, E2, E3>where E1: Send, E2: Send, E3: Send,
impl<E1, E2, E3> Sync for ActionError<E1, E2, E3>where E1: Sync, E2: Sync, E3: Sync,
impl<E1, E2, E3> Unpin for ActionError<E1, E2, E3>where E1: Unpin, E2: Unpin, E3: Unpin,
impl<E1, E2, E3> UnwindSafe for ActionError<E1, E2, E3>where E1: UnwindSafe, E2: UnwindSafe, E3: UnwindSafe,
Blanket Implementations§
§impl<T> Conv for T
impl<T> Conv for T
§impl<Choices> CoproductSubsetter<CNil, HNil> for Choices
impl<Choices> CoproductSubsetter<CNil, HNil> for Choices
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where Self: Binary,
Causes
self to use its Binary implementation when Debug-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where Self: Display,
Causes
self to use its Display implementation when
Debug-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where Self: LowerExp,
Causes
self to use its LowerExp implementation when
Debug-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where Self: LowerHex,
Causes
self to use its LowerHex implementation when
Debug-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where Self: Octal,
Causes
self to use its Octal implementation when Debug-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where Self: Pointer,
Causes
self to use its Pointer implementation when
Debug-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where Self: UpperExp,
Causes
self to use its UpperExp implementation when
Debug-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where Self: UpperHex,
Causes
self to use its UpperHex implementation when
Debug-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where &'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
§impl<T> FutureExt for T
impl<T> FutureExt for T
§fn with_context(self, otel_cx: Context) -> WithContext<Self>
fn with_context(self, otel_cx: Context) -> WithContext<Self>
§fn with_current_context(self) -> WithContext<Self>
fn with_current_context(self) -> WithContext<Self>
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoSql for T
impl<T> IntoSql for T
source§fn into_sql<T>(self) -> Self::Expressionwhere
Self: AsExpression<T> + Sized,
T: SqlType + TypedExpressionType,
fn into_sql<T>(self) -> Self::Expressionwhere Self: AsExpression<T> + Sized, T: SqlType + TypedExpressionType,
Convert
self to an expression for Diesel’s query builder. Read moresource§fn as_sql<'a, T>(&'a self) -> <&'a Self as AsExpression<T>>::Expressionwhere
&'a Self: AsExpression<T>,
T: SqlType + TypedExpressionType,
fn as_sql<'a, T>(&'a self) -> <&'a Self as AsExpression<T>>::Expressionwhere &'a Self: AsExpression<T>, T: SqlType + TypedExpressionType,
Convert
&self to an expression for Diesel’s query builder. Read more§impl<T, U, I> LiftInto<U, I> for Twhere
U: LiftFrom<T, I>,
impl<T, U, I> LiftInto<U, I> for Twhere U: LiftFrom<T, I>,
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere Self: Sized,
Pipes by value. This is generally the method you want to use. Read more
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere R: 'a,
Borrows
self and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere R: 'a,
Mutably borrows
self and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere Self: Borrow<B>, B: 'a + ?Sized, R: 'a,
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> Rwhere
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> Rwhere Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere Self: AsRef<U>, U: 'a + ?Sized, R: 'a,
Borrows
self, then passes self.as_ref() into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere Self: AsMut<U>, U: 'a + ?Sized, R: 'a,
Mutably borrows
self, then passes self.as_mut() into the pipe
function.§impl<T> Pointable for T
impl<T> Pointable for T
§impl<T> RawSession<T> for Twhere
T: Send + Sync + 'static,
impl<T> RawSession<T> for Twhere T: Send + Sync + 'static,
type Key = ()
type Validation = ()
fn try_decode( self, _: &<T as RawSession<T>>::Key, _: &<T as RawSession<T>>::Validation ) -> Result<T, Error>
fn add_extensions( session: Result<Option<T>, Error>, _: &<T as RawSession<T>>::Key, _: &<T as RawSession<T>>::Validation, extensions: &mut Extensions )
source§impl<T, Conn> RunQueryDsl<Conn> for T
impl<T, Conn> RunQueryDsl<Conn> for T
source§fn execute<'query, 'conn>(
self,
conn: &'conn mut Conn
) -> <Conn as AsyncConnection>::ExecuteFuture<'conn, 'query>where
Conn: AsyncConnection + Send,
Self: ExecuteDsl<Conn, <Conn as AsyncConnection>::Backend> + 'query,
fn execute<'query, 'conn>( self, conn: &'conn mut Conn ) -> <Conn as AsyncConnection>::ExecuteFuture<'conn, 'query>where Conn: AsyncConnection + Send, Self: ExecuteDsl<Conn, <Conn as AsyncConnection>::Backend> + 'query,
Executes the given command, returning the number of rows affected. Read more
source§fn load<'query, U, 'conn>(
self,
conn: &'conn mut Conn
) -> AndThen<Self::LoadFuture<'conn>, TryCollect<Self::Stream<'conn>, Vec<U, Global>>, fn(_: Self::Stream<'conn>) -> TryCollect<Self::Stream<'conn>, Vec<U, Global>>>where
U: Send,
Conn: AsyncConnection,
Self: LoadQuery<'query, Conn, U> + 'query,
fn load<'query, U, 'conn>( self, conn: &'conn mut Conn ) -> AndThen<Self::LoadFuture<'conn>, TryCollect<Self::Stream<'conn>, Vec<U, Global>>, fn(_: Self::Stream<'conn>) -> TryCollect<Self::Stream<'conn>, Vec<U, Global>>>where U: Send, Conn: AsyncConnection, Self: LoadQuery<'query, Conn, U> + 'query,
source§fn load_stream<'conn, 'query, U>(
self,
conn: &'conn mut Conn
) -> Self::LoadFuture<'conn>where
Conn: AsyncConnection,
U: 'conn,
Self: LoadQuery<'query, Conn, U> + 'query,
fn load_stream<'conn, 'query, U>( self, conn: &'conn mut Conn ) -> Self::LoadFuture<'conn>where Conn: AsyncConnection, U: 'conn, Self: LoadQuery<'query, Conn, U> + 'query,
Executes the given query, returning a [
Stream] with the returned rows. Read moresource§fn get_result<'query, 'conn, U>(
self,
conn: &'conn mut Conn
) -> AndThen<Self::LoadFuture<'conn>, Map<StreamFuture<Pin<Box<Self::Stream<'conn>, Global>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<Self::Stream<'conn>, Global>>)) -> Result<U, Error>>, fn(_: Self::Stream<'conn>) -> Map<StreamFuture<Pin<Box<Self::Stream<'conn>, Global>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<Self::Stream<'conn>, Global>>)) -> Result<U, Error>>>where
U: Send + 'conn,
Conn: AsyncConnection,
Self: LoadQuery<'query, Conn, U> + 'query,
fn get_result<'query, 'conn, U>( self, conn: &'conn mut Conn ) -> AndThen<Self::LoadFuture<'conn>, Map<StreamFuture<Pin<Box<Self::Stream<'conn>, Global>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<Self::Stream<'conn>, Global>>)) -> Result<U, Error>>, fn(_: Self::Stream<'conn>) -> Map<StreamFuture<Pin<Box<Self::Stream<'conn>, Global>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<Self::Stream<'conn>, Global>>)) -> Result<U, Error>>>where U: Send + 'conn, Conn: AsyncConnection, Self: LoadQuery<'query, Conn, U> + 'query,
Runs the command, and returns the affected row. Read more
source§fn get_results<'query, U, 'conn>(
self,
conn: &'conn mut Conn
) -> AndThen<Self::LoadFuture<'conn>, TryCollect<Self::Stream<'conn>, Vec<U, Global>>, fn(_: Self::Stream<'conn>) -> TryCollect<Self::Stream<'conn>, Vec<U, Global>>>where
U: Send,
Conn: AsyncConnection,
Self: LoadQuery<'query, Conn, U> + 'query,
fn get_results<'query, U, 'conn>( self, conn: &'conn mut Conn ) -> AndThen<Self::LoadFuture<'conn>, TryCollect<Self::Stream<'conn>, Vec<U, Global>>, fn(_: Self::Stream<'conn>) -> TryCollect<Self::Stream<'conn>, Vec<U, Global>>>where U: Send, Conn: AsyncConnection, Self: LoadQuery<'query, Conn, U> + 'query,
Runs the command, returning an
Vec with the affected rows. Read moresource§fn first<'query, 'conn, U>(
self,
conn: &'conn mut Conn
) -> AndThen<<Self::Output as LoadQuery<'query, Conn, U>>::LoadFuture<'conn>, Map<StreamFuture<Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>, Global>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>, Global>>)) -> Result<U, Error>>, fn(_: <Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>) -> Map<StreamFuture<Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>, Global>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>, Global>>)) -> Result<U, Error>>>where
U: Send + 'conn,
Conn: AsyncConnection,
Self: LimitDsl,
Self::Output: LoadQuery<'query, Conn, U> + Send + 'query,
fn first<'query, 'conn, U>( self, conn: &'conn mut Conn ) -> AndThen<<Self::Output as LoadQuery<'query, Conn, U>>::LoadFuture<'conn>, Map<StreamFuture<Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>, Global>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>, Global>>)) -> Result<U, Error>>, fn(_: <Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>) -> Map<StreamFuture<Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>, Global>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>, Global>>)) -> Result<U, Error>>>where U: Send + 'conn, Conn: AsyncConnection, Self: LimitDsl, Self::Output: LoadQuery<'query, Conn, U> + Send + 'query,
Attempts to load a single record. Read more
§impl<Source> Sculptor<HNil, HNil> for Source
impl<Source> Sculptor<HNil, HNil> for Source
§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere Self: Borrow<B>, B: ?Sized,
Immutable access to the
Borrow<B> of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere Self: BorrowMut<B>, B: ?Sized,
Mutable access to the
BorrowMut<B> of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere Self: AsRef<R>, R: ?Sized,
Immutable access to the
AsRef<R> view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere Self: AsMut<R>, R: ?Sized,
Mutable access to the
AsMut<R> view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere
Self: Deref<Target = T>,
T: ?Sized,
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere Self: Deref<Target = T>, T: ?Sized,
Immutable access to the
Deref::Target of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere Self: DerefMut<Target = T> + Deref, T: ?Sized,
Mutable access to the
Deref::Target of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
Calls
.tap() only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls
.tap_mut() only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Selfwhere Self: Borrow<B>, B: ?Sized,
Calls
.tap_borrow() only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere Self: BorrowMut<B>, B: ?Sized,
Calls
.tap_borrow_mut() only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere Self: AsRef<R>, R: ?Sized,
Calls
.tap_ref() only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere Self: AsMut<R>, R: ?Sized,
Calls
.tap_ref_mut() only in debug builds, and is erased in release
builds.§impl<T> TryConv for T
impl<T> TryConv for T
source§impl<'subject, 'context, 'input, Ctx, T> TryCreate<'subject, 'context, 'input, Ctx> for Twhere
T: Send + Sync,
Ctx: Sync + 'subject + 'context,
impl<'subject, 'context, 'input, Ctx, T> TryCreate<'subject, 'context, 'input, Ctx> for Twhere T: Send + Sync, Ctx: Sync + 'subject + 'context,
source§fn can_create<'life0, 'async_trait, DM, SC, TC, I>(
ctx: &'life0 Ctx,
input: &'input I
) -> Pin<Box<dyn Future<Output = Result<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Ok, <DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error>> + Send + 'async_trait>>where
Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait,
DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait,
SC: StorageClient + Send + Sync + 'async_trait,
TC: Send + Sync + TransactionCache + 'async_trait,
Ctx: AuthorizationContext<DM, SC, TC>,
I: Send + Sync + 'async_trait,
'subject: 'async_trait,
'context: 'async_trait + 'input,
'input: 'async_trait,
'life0: 'async_trait + 'subject + 'context,
fn can_create<'life0, 'async_trait, DM, SC, TC, I>( ctx: &'life0 Ctx, input: &'input I ) -> Pin<Box<dyn Future<Output = Result<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Ok, <DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error>> + Send + 'async_trait>>where Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait, DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait, SC: StorageClient + Send + Sync + 'async_trait, TC: Send + Sync + TransactionCache + 'async_trait, Ctx: AuthorizationContext<DM, SC, TC>, I: Send + Sync + 'async_trait, 'subject: 'async_trait, 'context: 'async_trait + 'input, 'input: 'async_trait, 'life0: 'async_trait + 'subject + 'context,
Query whether the subject is authorized to create the specified object(s).
source§fn try_create<'life0, 'async_trait, DM, SC, TC, I>(
ctx: &'life0 Ctx,
input: I
) -> Pin<Box<dyn Future<Output = Result<<Create<Self> as StorageAction<SC, I>>::Ok, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Create<Self> as StorageAction<SC, I>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where
Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait,
DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait,
SC: StorageClient + Send + Sync + 'async_trait,
TC: Send + Sync + TransactionCache + TransactionCacheAction<Create<Self>, SC, I> + 'async_trait,
Ctx: AuthorizationContext<DM, SC, TC>,
Create<Self>: StorageAction<SC, I>,
I: Send + Sync + 'async_trait,
'subject: 'async_trait,
'context: 'async_trait,
'input: 'async_trait,
'life0: 'async_trait + 'subject + 'context,
fn try_create<'life0, 'async_trait, DM, SC, TC, I>( ctx: &'life0 Ctx, input: I ) -> Pin<Box<dyn Future<Output = Result<<Create<Self> as StorageAction<SC, I>>::Ok, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Create<Self> as StorageAction<SC, I>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait, DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait, SC: StorageClient + Send + Sync + 'async_trait, TC: Send + Sync + TransactionCache + TransactionCacheAction<Create<Self>, SC, I> + 'async_trait, Ctx: AuthorizationContext<DM, SC, TC>, Create<Self>: StorageAction<SC, I>, I: Send + Sync + 'async_trait, 'subject: 'async_trait, 'context: 'async_trait, 'input: 'async_trait, 'life0: 'async_trait + 'subject + 'context,
Query whether the subject is authorized to create the specified objects. If so, perform the action.
source§fn try_create_one<'life0, 'async_trait, DM, SC, TC, I>(
ctx: &'life0 Ctx,
input: I
) -> Pin<Box<dyn Future<Output = Result<<<Create<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Create<Self> as StorageAction<SC, [I; 1]>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where
Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait,
DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait,
SC: StorageClient + Send + Sync + 'async_trait,
TC: Send + Sync + TransactionCache + TransactionCacheAction<Create<Self>, SC, [I; 1]> + 'async_trait,
Ctx: AuthorizationContext<DM, SC, TC>,
Create<Self>: StorageAction<SC, [I; 1]>,
I: Send + Sync + 'async_trait,
<Create<Self> as StorageAction<SC, [I; 1]>>::Ok: IntoIterator,
<<Create<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item: Send,
'subject: 'async_trait,
'context: 'async_trait,
'input: 'async_trait,
'life0: 'async_trait + 'subject + 'context,
fn try_create_one<'life0, 'async_trait, DM, SC, TC, I>( ctx: &'life0 Ctx, input: I ) -> Pin<Box<dyn Future<Output = Result<<<Create<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Create<Self> as StorageAction<SC, [I; 1]>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait, DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Create<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait, SC: StorageClient + Send + Sync + 'async_trait, TC: Send + Sync + TransactionCache + TransactionCacheAction<Create<Self>, SC, [I; 1]> + 'async_trait, Ctx: AuthorizationContext<DM, SC, TC>, Create<Self>: StorageAction<SC, [I; 1]>, I: Send + Sync + 'async_trait, <Create<Self> as StorageAction<SC, [I; 1]>>::Ok: IntoIterator, <<Create<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item: Send, 'subject: 'async_trait, 'context: 'async_trait, 'input: 'async_trait, 'life0: 'async_trait + 'subject + 'context,
Query whether the subject is authorized to create the specified object. If so, perform the action. Expects the return type of the storage action to implement
IntoIterator.source§impl<'subject, 'context, 'input, Ctx, T> TryDelete<'subject, 'context, 'input, Ctx> for Twhere
T: Send + Sync,
Ctx: Sync + 'subject + 'context,
impl<'subject, 'context, 'input, Ctx, T> TryDelete<'subject, 'context, 'input, Ctx> for Twhere T: Send + Sync, Ctx: Sync + 'subject + 'context,
source§fn can_delete<'life0, 'async_trait, DM, SC, TC, I>(
ctx: &'life0 Ctx,
input: &'input I
) -> Pin<Box<dyn Future<Output = Result<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Ok, <DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error>> + Send + 'async_trait>>where
Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait,
DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait,
SC: StorageClient + Send + Sync + 'async_trait,
TC: Send + Sync + TransactionCache + 'async_trait,
Ctx: AuthorizationContext<DM, SC, TC>,
I: Send + Sync + 'async_trait,
'subject: 'async_trait,
'context: 'async_trait + 'input,
'input: 'async_trait,
'life0: 'async_trait + 'subject + 'context,
fn can_delete<'life0, 'async_trait, DM, SC, TC, I>( ctx: &'life0 Ctx, input: &'input I ) -> Pin<Box<dyn Future<Output = Result<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Ok, <DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error>> + Send + 'async_trait>>where Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait, DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait, SC: StorageClient + Send + Sync + 'async_trait, TC: Send + Sync + TransactionCache + 'async_trait, Ctx: AuthorizationContext<DM, SC, TC>, I: Send + Sync + 'async_trait, 'subject: 'async_trait, 'context: 'async_trait + 'input, 'input: 'async_trait, 'life0: 'async_trait + 'subject + 'context,
Query whether the subject is authorized to delete the specified object(s).
source§fn try_delete<'life0, 'async_trait, DM, SC, TC, I>(
ctx: &'life0 Ctx,
input: I
) -> Pin<Box<dyn Future<Output = Result<<Delete<Self> as StorageAction<SC, I>>::Ok, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Delete<Self> as StorageAction<SC, I>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where
Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait,
DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait,
SC: StorageClient + Send + Sync + 'async_trait,
TC: Send + Sync + TransactionCache + TransactionCacheAction<Delete<Self>, SC, I> + 'async_trait,
Ctx: AuthorizationContext<DM, SC, TC>,
Delete<Self>: StorageAction<SC, I>,
I: Send + Sync + 'async_trait,
'subject: 'async_trait,
'context: 'async_trait,
'input: 'async_trait,
'life0: 'async_trait + 'subject + 'context,
fn try_delete<'life0, 'async_trait, DM, SC, TC, I>( ctx: &'life0 Ctx, input: I ) -> Pin<Box<dyn Future<Output = Result<<Delete<Self> as StorageAction<SC, I>>::Ok, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Delete<Self> as StorageAction<SC, I>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait, DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait, SC: StorageClient + Send + Sync + 'async_trait, TC: Send + Sync + TransactionCache + TransactionCacheAction<Delete<Self>, SC, I> + 'async_trait, Ctx: AuthorizationContext<DM, SC, TC>, Delete<Self>: StorageAction<SC, I>, I: Send + Sync + 'async_trait, 'subject: 'async_trait, 'context: 'async_trait, 'input: 'async_trait, 'life0: 'async_trait + 'subject + 'context,
Query whether the subject is authorized to delete the specified objects. If so, perform the action.
source§fn try_delete_one<'life0, 'async_trait, DM, SC, TC, I>(
ctx: &'life0 Ctx,
input: I
) -> Pin<Box<dyn Future<Output = Result<<<Delete<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Delete<Self> as StorageAction<SC, [I; 1]>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where
Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait,
DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait,
SC: StorageClient + Send + Sync + 'async_trait,
TC: Send + Sync + TransactionCache + TransactionCacheAction<Delete<Self>, SC, [I; 1]> + 'async_trait,
Ctx: AuthorizationContext<DM, SC, TC>,
Delete<Self>: StorageAction<SC, [I; 1]>,
I: Send + Sync + 'async_trait,
<Delete<Self> as StorageAction<SC, [I; 1]>>::Ok: IntoIterator,
<<Delete<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item: Send,
'subject: 'async_trait,
'context: 'async_trait,
'input: 'async_trait,
'life0: 'async_trait + 'subject + 'context,
fn try_delete_one<'life0, 'async_trait, DM, SC, TC, I>( ctx: &'life0 Ctx, input: I ) -> Pin<Box<dyn Future<Output = Result<<<Delete<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Delete<Self> as StorageAction<SC, [I; 1]>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait, DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Delete<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait, SC: StorageClient + Send + Sync + 'async_trait, TC: Send + Sync + TransactionCache + TransactionCacheAction<Delete<Self>, SC, [I; 1]> + 'async_trait, Ctx: AuthorizationContext<DM, SC, TC>, Delete<Self>: StorageAction<SC, [I; 1]>, I: Send + Sync + 'async_trait, <Delete<Self> as StorageAction<SC, [I; 1]>>::Ok: IntoIterator, <<Delete<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item: Send, 'subject: 'async_trait, 'context: 'async_trait, 'input: 'async_trait, 'life0: 'async_trait + 'subject + 'context,
Query whether the subject is authorized to delete the specified object. If so, perform the action. Expects the return type of the storage action to implement
IntoIterator.source§impl<'subject, 'context, 'input, Ctx, T> TryRead<'subject, 'context, 'input, Ctx> for Twhere
T: Send + Sync,
Ctx: Sync + 'subject + 'context,
impl<'subject, 'context, 'input, Ctx, T> TryRead<'subject, 'context, 'input, Ctx> for Twhere T: Send + Sync, Ctx: Sync + 'subject + 'context,
source§fn can_read<'life0, 'async_trait, DM, SC, TC, I>(
ctx: &'life0 Ctx,
input: &'input I
) -> Pin<Box<dyn Future<Output = Result<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Ok, <DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error>> + Send + 'async_trait>>where
Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait,
DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait,
SC: StorageClient + Send + Sync + 'async_trait,
TC: Send + Sync + TransactionCache + 'async_trait,
Ctx: AuthorizationContext<DM, SC, TC>,
I: Send + Sync + 'async_trait,
'subject: 'async_trait,
'context: 'async_trait + 'input,
'input: 'async_trait,
'life0: 'async_trait + 'subject + 'context,
fn can_read<'life0, 'async_trait, DM, SC, TC, I>( ctx: &'life0 Ctx, input: &'input I ) -> Pin<Box<dyn Future<Output = Result<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Ok, <DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error>> + Send + 'async_trait>>where Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait, DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait, SC: StorageClient + Send + Sync + 'async_trait, TC: Send + Sync + TransactionCache + 'async_trait, Ctx: AuthorizationContext<DM, SC, TC>, I: Send + Sync + 'async_trait, 'subject: 'async_trait, 'context: 'async_trait + 'input, 'input: 'async_trait, 'life0: 'async_trait + 'subject + 'context,
Query whether the subject is authorized to read the specified object(s).
source§fn try_read<'life0, 'async_trait, DM, SC, TC, I>(
ctx: &'life0 Ctx,
input: I
) -> Pin<Box<dyn Future<Output = Result<<Read<Self> as StorageAction<SC, I>>::Ok, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Read<Self> as StorageAction<SC, I>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where
Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait,
DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait,
SC: StorageClient + Send + Sync + 'async_trait,
TC: Send + Sync + TransactionCache + TransactionCacheAction<Read<Self>, SC, I> + 'async_trait,
Ctx: AuthorizationContext<DM, SC, TC>,
Read<Self>: StorageAction<SC, I>,
I: Send + Sync + 'async_trait,
'subject: 'async_trait,
'context: 'async_trait,
'input: 'async_trait,
'life0: 'async_trait + 'subject + 'context,
fn try_read<'life0, 'async_trait, DM, SC, TC, I>( ctx: &'life0 Ctx, input: I ) -> Pin<Box<dyn Future<Output = Result<<Read<Self> as StorageAction<SC, I>>::Ok, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Read<Self> as StorageAction<SC, I>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait, DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait, SC: StorageClient + Send + Sync + 'async_trait, TC: Send + Sync + TransactionCache + TransactionCacheAction<Read<Self>, SC, I> + 'async_trait, Ctx: AuthorizationContext<DM, SC, TC>, Read<Self>: StorageAction<SC, I>, I: Send + Sync + 'async_trait, 'subject: 'async_trait, 'context: 'async_trait, 'input: 'async_trait, 'life0: 'async_trait + 'subject + 'context,
Query whether the subject is authorized to read the specified objects. If so, perform the action.
source§fn try_read_one<'life0, 'async_trait, DM, SC, TC, I>(
ctx: &'life0 Ctx,
input: I
) -> Pin<Box<dyn Future<Output = Result<<<Read<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Read<Self> as StorageAction<SC, [I; 1]>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where
Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait,
DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait,
SC: StorageClient + Send + Sync + 'async_trait,
TC: Send + Sync + TransactionCache + TransactionCacheAction<Read<Self>, SC, [I; 1]> + 'async_trait,
Ctx: AuthorizationContext<DM, SC, TC>,
Read<Self>: StorageAction<SC, [I; 1]>,
I: Send + Sync + 'async_trait,
<Read<Self> as StorageAction<SC, [I; 1]>>::Ok: IntoIterator,
<<Read<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item: Send,
'subject: 'async_trait,
'context: 'async_trait,
'input: 'async_trait,
'life0: 'async_trait + 'subject + 'context,
fn try_read_one<'life0, 'async_trait, DM, SC, TC, I>( ctx: &'life0 Ctx, input: I ) -> Pin<Box<dyn Future<Output = Result<<<Read<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Read<Self> as StorageAction<SC, [I; 1]>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait, DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Read<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait, SC: StorageClient + Send + Sync + 'async_trait, TC: Send + Sync + TransactionCache + TransactionCacheAction<Read<Self>, SC, [I; 1]> + 'async_trait, Ctx: AuthorizationContext<DM, SC, TC>, Read<Self>: StorageAction<SC, [I; 1]>, I: Send + Sync + 'async_trait, <Read<Self> as StorageAction<SC, [I; 1]>>::Ok: IntoIterator, <<Read<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item: Send, 'subject: 'async_trait, 'context: 'async_trait, 'input: 'async_trait, 'life0: 'async_trait + 'subject + 'context,
Query whether the subject is authorized to read the specified object. If so, perform the action. Expects the return type of the storage action to implement
IntoIterator.source§impl<'subject, 'context, 'input, Ctx, T> TryUpdate<'subject, 'context, 'input, Ctx> for Twhere
T: Send + Sync,
Ctx: Sync + 'subject + 'context,
impl<'subject, 'context, 'input, Ctx, T> TryUpdate<'subject, 'context, 'input, Ctx> for Twhere T: Send + Sync, Ctx: Sync + 'subject + 'context,
source§fn can_update<'life0, 'async_trait, DM, SC, TC, I>(
ctx: &'life0 Ctx,
input: &'input I
) -> Pin<Box<dyn Future<Output = Result<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Ok, <DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error>> + Send + 'async_trait>>where
Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait,
DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait,
SC: StorageClient + Send + Sync + 'async_trait,
TC: Send + Sync + TransactionCache + 'async_trait,
Ctx: AuthorizationContext<DM, SC, TC>,
I: Send + Sync + 'async_trait,
'subject: 'async_trait,
'context: 'async_trait + 'input,
'input: 'async_trait,
'life0: 'async_trait + 'subject + 'context,
fn can_update<'life0, 'async_trait, DM, SC, TC, I>( ctx: &'life0 Ctx, input: &'input I ) -> Pin<Box<dyn Future<Output = Result<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Ok, <DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error>> + Send + 'async_trait>>where Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait, DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait, SC: StorageClient + Send + Sync + 'async_trait, TC: Send + Sync + TransactionCache + 'async_trait, Ctx: AuthorizationContext<DM, SC, TC>, I: Send + Sync + 'async_trait, 'subject: 'async_trait, 'context: 'async_trait + 'input, 'input: 'async_trait, 'life0: 'async_trait + 'subject + 'context,
Query whether the subject is authorized to update the specified object(s).
source§fn try_update<'life0, 'async_trait, DM, SC, TC, I>(
ctx: &'life0 Ctx,
input: I
) -> Pin<Box<dyn Future<Output = Result<<Update<Self> as StorageAction<SC, I>>::Ok, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Update<Self> as StorageAction<SC, I>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where
Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait,
DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait,
SC: StorageClient + Send + Sync + 'async_trait,
TC: Send + Sync + TransactionCache + TransactionCacheAction<Update<Self>, SC, I> + 'async_trait,
Ctx: AuthorizationContext<DM, SC, TC>,
Update<Self>: StorageAction<SC, I>,
I: Send + Sync + 'async_trait,
'subject: 'async_trait,
'context: 'async_trait,
'input: 'async_trait,
'life0: 'async_trait + 'subject + 'context,
fn try_update<'life0, 'async_trait, DM, SC, TC, I>( ctx: &'life0 Ctx, input: I ) -> Pin<Box<dyn Future<Output = Result<<Update<Self> as StorageAction<SC, I>>::Ok, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Update<Self> as StorageAction<SC, I>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait, DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, I, <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait, SC: StorageClient + Send + Sync + 'async_trait, TC: Send + Sync + TransactionCache + TransactionCacheAction<Update<Self>, SC, I> + 'async_trait, Ctx: AuthorizationContext<DM, SC, TC>, Update<Self>: StorageAction<SC, I>, I: Send + Sync + 'async_trait, 'subject: 'async_trait, 'context: 'async_trait, 'input: 'async_trait, 'life0: 'async_trait + 'subject + 'context,
Query whether the subject is authorized to update the specified objects. If so, perform the action.
source§fn try_update_one<'life0, 'async_trait, DM, SC, TC, I>(
ctx: &'life0 Ctx,
input: I
) -> Pin<Box<dyn Future<Output = Result<<<Update<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Update<Self> as StorageAction<SC, [I; 1]>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where
Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait,
DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait,
SC: StorageClient + Send + Sync + 'async_trait,
TC: Send + Sync + TransactionCache + TransactionCacheAction<Update<Self>, SC, [I; 1]> + 'async_trait,
Ctx: AuthorizationContext<DM, SC, TC>,
Update<Self>: StorageAction<SC, [I; 1]>,
I: Send + Sync + 'async_trait,
<Update<Self> as StorageAction<SC, [I; 1]>>::Ok: IntoIterator,
<<Update<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item: Send,
'subject: 'async_trait,
'context: 'async_trait,
'input: 'async_trait,
'life0: 'async_trait + 'subject + 'context,
fn try_update_one<'life0, 'async_trait, DM, SC, TC, I>( ctx: &'life0 Ctx, input: I ) -> Pin<Box<dyn Future<Output = Result<<<Update<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item, ActionError<<DM as DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId>>::Error, <Update<Self> as StorageAction<SC, [I; 1]>>::Error, <TC as TransactionCache>::Error>>> + Send + 'async_trait>>where Self: AsStorage<<SC as StorageClient>::Backend> + 'async_trait, DM: DecisionMaker<<Ctx as AuthorizationContext<DM, SC, TC>>::Subject<'subject>, Update<Self>, Self, [I; 1], <Ctx as AuthorizationContext<DM, SC, TC>>::Context<'context>, SC::TransactionId> + Sync + 'async_trait, SC: StorageClient + Send + Sync + 'async_trait, TC: Send + Sync + TransactionCache + TransactionCacheAction<Update<Self>, SC, [I; 1]> + 'async_trait, Ctx: AuthorizationContext<DM, SC, TC>, Update<Self>: StorageAction<SC, [I; 1]>, I: Send + Sync + 'async_trait, <Update<Self> as StorageAction<SC, [I; 1]>>::Ok: IntoIterator, <<Update<Self> as StorageAction<SC, [I; 1]>>::Ok as IntoIterator>::Item: Send, 'subject: 'async_trait, 'context: 'async_trait, 'input: 'async_trait, 'life0: 'async_trait + 'subject + 'context,
Query whether the subject is authorized to update the specified object. If so, perform the action. Expects the return type of the storage action to implement
IntoIterator.