Struct UnitTestingClientView 

pub struct UnitTestingClientView<'a> { /* private fields */ }

Per-exchange view onto the UnitTesting cluster’s client operations. Returned by UnitTestingClient::unit_testing. Each method consumes the view (and therefore the underlying crate::transport::exchange::Exchange) — one exchange is one IM transaction.

Implementations

impl<'a> UnitTestingClientView<'a>

pub async fn test(self, endpoint: u16) -> Result<(), Error>

pub async fn test_not_handled(self, endpoint: u16) -> Result<(), Error>

pub async fn test_specific( self, endpoint: u16, ) -> Result<TestSpecificResponseHandle<'a>, Error>

pub async fn test_unknown_command(self, endpoint: u16) -> Result<(), Error>

pub async fn test_add_arguments<F>( self, endpoint: u16, request: F, ) -> Result<TestAddArgumentsResponseHandle<'a>, Error>

where F: FnMut(TestAddArgumentsRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_simple_argument_request<F>( self, endpoint: u16, request: F, ) -> Result<TestSimpleArgumentResponseHandle<'a>, Error>

where F: FnMut(TestSimpleArgumentRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_struct_array_argument_request<F>( self, endpoint: u16, request: F, ) -> Result<TestStructArrayArgumentResponseHandle<'a>, Error>

where F: FnMut(TestStructArrayArgumentRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_struct_argument_request<F>( self, endpoint: u16, request: F, ) -> Result<BooleanResponseHandle<'a>, Error>

where F: FnMut(TestStructArgumentRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_nested_struct_argument_request<F>( self, endpoint: u16, request: F, ) -> Result<BooleanResponseHandle<'a>, Error>

where F: FnMut(TestNestedStructArgumentRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_list_struct_argument_request<F>( self, endpoint: u16, request: F, ) -> Result<BooleanResponseHandle<'a>, Error>

where F: FnMut(TestListStructArgumentRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_list_int_8_u_argument_request<F>( self, endpoint: u16, request: F, ) -> Result<BooleanResponseHandle<'a>, Error>

where F: FnMut(TestListInt8UArgumentRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_nested_struct_list_argument_request<F>( self, endpoint: u16, request: F, ) -> Result<BooleanResponseHandle<'a>, Error>

where F: FnMut(TestNestedStructListArgumentRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_list_nested_struct_list_argument_request<F>( self, endpoint: u16, request: F, ) -> Result<BooleanResponseHandle<'a>, Error>

where F: FnMut(TestListNestedStructListArgumentRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_list_int_8_u_reverse_request<F>( self, endpoint: u16, request: F, ) -> Result<TestListInt8UReverseResponseHandle<'a>, Error>

where F: FnMut(TestListInt8UReverseRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_enums_request<F>( self, endpoint: u16, request: F, ) -> Result<TestEnumsResponseHandle<'a>, Error>

where F: FnMut(TestEnumsRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_nullable_optional_request<F>( self, endpoint: u16, request: F, ) -> Result<TestNullableOptionalResponseHandle<'a>, Error>

where F: FnMut(TestNullableOptionalRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_complex_nullable_optional_request<F>( self, endpoint: u16, request: F, ) -> Result<TestComplexNullableOptionalResponseHandle<'a>, Error>

where F: FnMut(TestComplexNullableOptionalRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn simple_struct_echo_request<F>( self, endpoint: u16, request: F, ) -> Result<SimpleStructResponseHandle<'a>, Error>

where F: FnMut(SimpleStructEchoRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn timed_invoke_request(self, endpoint: u16) -> Result<(), Error>

pub async fn test_simple_optional_argument_request<F>( self, endpoint: u16, request: F, ) -> Result<(), Error>

where F: FnMut(TestSimpleOptionalArgumentRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_emit_test_event_request<F>( self, endpoint: u16, request: F, ) -> Result<TestEmitTestEventResponseHandle<'a>, Error>

where F: FnMut(TestEmitTestEventRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_emit_test_fabric_scoped_event_request<F>( self, endpoint: u16, request: F, ) -> Result<TestEmitTestFabricScopedEventResponseHandle<'a>, Error>

where F: FnMut(TestEmitTestFabricScopedEventRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_batch_helper_request<F>( self, endpoint: u16, request: F, ) -> Result<TestBatchHelperResponseHandle<'a>, Error>

where F: FnMut(TestBatchHelperRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_second_batch_helper_request<F>( self, endpoint: u16, request: F, ) -> Result<TestBatchHelperResponseHandle<'a>, Error>

where F: FnMut(TestSecondBatchHelperRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn string_echo_request<F>( self, endpoint: u16, request: F, ) -> Result<StringEchoResponseHandle<'a>, Error>

where F: FnMut(StringEchoRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn global_echo_request<F>( self, endpoint: u16, request: F, ) -> Result<GlobalEchoResponseHandle<'a>, Error>

where F: FnMut(GlobalEchoRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn test_check_command_flags(self, endpoint: u16) -> Result<(), Error>

pub async fn test_different_vendor_mei_request<F>( self, endpoint: u16, request: F, ) -> Result<TestDifferentVendorMeiResponseHandle<'a>, Error>

where F: FnMut(TestDifferentVendorMeiRequestRequestBuilder<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>>) -> Result<CmdDataBuilder<CmdDataArrayBuilder<InvReqBuilder<InvokeSender<'a>, 3>>, 2>, Error>,

pub async fn boolean_read(self, endpoint: u16) -> Result<bool, Error>

pub async fn bitmap_8_read(self, endpoint: u16) -> Result<Bitmap8MaskMap, Error>

pub async fn bitmap_16_read( self, endpoint: u16, ) -> Result<Bitmap16MaskMap, Error>

pub async fn bitmap_32_read( self, endpoint: u16, ) -> Result<Bitmap32MaskMap, Error>

pub async fn bitmap_64_read( self, endpoint: u16, ) -> Result<Bitmap64MaskMap, Error>

pub async fn int_8_u_read(self, endpoint: u16) -> Result<u8, Error>

pub async fn int_16_u_read(self, endpoint: u16) -> Result<u16, Error>

pub async fn int_24_u_read(self, endpoint: u16) -> Result<u32, Error>

pub async fn int_32_u_read(self, endpoint: u16) -> Result<u32, Error>

pub async fn int_40_u_read(self, endpoint: u16) -> Result<u64, Error>

pub async fn int_48_u_read(self, endpoint: u16) -> Result<u64, Error>

pub async fn int_56_u_read(self, endpoint: u16) -> Result<u64, Error>

pub async fn int_64_u_read(self, endpoint: u16) -> Result<u64, Error>

pub async fn int_8_s_read(self, endpoint: u16) -> Result<i8, Error>

pub async fn int_16_s_read(self, endpoint: u16) -> Result<i16, Error>

pub async fn int_24_s_read(self, endpoint: u16) -> Result<i32, Error>

pub async fn int_32_s_read(self, endpoint: u16) -> Result<i32, Error>

pub async fn int_40_s_read(self, endpoint: u16) -> Result<i64, Error>

pub async fn int_48_s_read(self, endpoint: u16) -> Result<i64, Error>

pub async fn int_56_s_read(self, endpoint: u16) -> Result<i64, Error>

pub async fn int_64_s_read(self, endpoint: u16) -> Result<i64, Error>

pub async fn enum_8_read(self, endpoint: u16) -> Result<u8, Error>

pub async fn enum_16_read(self, endpoint: u16) -> Result<u16, Error>

pub async fn float_single_read(self, endpoint: u16) -> Result<f32, Error>

pub async fn float_double_read(self, endpoint: u16) -> Result<f64, Error>

pub async fn octet_string_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<Octets<'_>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn list_int_8_u_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<TLVContainer<'_, u8, ArrayContainer>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn list_octet_string_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<TLVContainer<'_, Octets<'_>, ArrayContainer>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn list_struct_octet_string_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<TLVContainer<'_, TestListStructOctet<'_>, ArrayContainer>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn long_octet_string_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<Octets<'_>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn char_string_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<&str, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn long_char_string_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<&str, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn epoch_us_read(self, endpoint: u16) -> Result<u64, Error>

pub async fn epoch_s_read(self, endpoint: u16) -> Result<u32, Error>

pub async fn vendor_id_read(self, endpoint: u16) -> Result<u16, Error>

pub async fn list_nullables_and_optionals_struct_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<TLVContainer<'_, NullablesAndOptionalsStruct<'_>, ArrayContainer>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn enum_attr_read(self, endpoint: u16) -> Result<SimpleEnum, Error>

pub async fn struct_attr_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<SimpleStruct<'_>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn range_restricted_int_8_u_read( self, endpoint: u16, ) -> Result<u8, Error>

pub async fn range_restricted_int_8_s_read( self, endpoint: u16, ) -> Result<i8, Error>

pub async fn range_restricted_int_16_u_read( self, endpoint: u16, ) -> Result<u16, Error>

pub async fn range_restricted_int_16_s_read( self, endpoint: u16, ) -> Result<i16, Error>

pub async fn list_long_octet_string_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<TLVContainer<'_, Octets<'_>, ArrayContainer>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn list_fabric_scoped_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<TLVContainer<'_, TestFabricScoped<'_>, ArrayContainer>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn timed_write_boolean_read( self, endpoint: u16, ) -> Result<bool, Error>

pub async fn general_error_boolean_read( self, endpoint: u16, ) -> Result<bool, Error>

pub async fn cluster_error_boolean_read( self, endpoint: u16, ) -> Result<bool, Error>

pub async fn global_enum_read( self, endpoint: u16, ) -> Result<TestGlobalEnum, Error>

pub async fn global_struct_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<TestGlobalStruct<'_>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn unsupported_attribute_requiring_admin_privilege_read( self, endpoint: u16, ) -> Result<bool, Error>

pub async fn unsupported_read(self, endpoint: u16) -> Result<bool, Error>

pub async fn read_failure_code_read(self, endpoint: u16) -> Result<u8, Error>

pub async fn failure_int_32_u_read(self, endpoint: u16) -> Result<u32, Error>

pub async fn nullable_boolean_read( self, endpoint: u16, ) -> Result<Maybe<bool, AsNullable>, Error>

pub async fn nullable_bitmap_8_read( self, endpoint: u16, ) -> Result<Maybe<Bitmap8MaskMap, AsNullable>, Error>

pub async fn nullable_bitmap_16_read( self, endpoint: u16, ) -> Result<Maybe<Bitmap16MaskMap, AsNullable>, Error>

pub async fn nullable_bitmap_32_read( self, endpoint: u16, ) -> Result<Maybe<Bitmap32MaskMap, AsNullable>, Error>

pub async fn nullable_bitmap_64_read( self, endpoint: u16, ) -> Result<Maybe<Bitmap64MaskMap, AsNullable>, Error>

pub async fn nullable_int_8_u_read( self, endpoint: u16, ) -> Result<Maybe<u8, AsNullable>, Error>

pub async fn nullable_int_16_u_read( self, endpoint: u16, ) -> Result<Maybe<u16, AsNullable>, Error>

pub async fn nullable_int_24_u_read( self, endpoint: u16, ) -> Result<Maybe<u32, AsNullable>, Error>

pub async fn nullable_int_32_u_read( self, endpoint: u16, ) -> Result<Maybe<u32, AsNullable>, Error>

pub async fn nullable_int_40_u_read( self, endpoint: u16, ) -> Result<Maybe<u64, AsNullable>, Error>

pub async fn nullable_int_48_u_read( self, endpoint: u16, ) -> Result<Maybe<u64, AsNullable>, Error>

pub async fn nullable_int_56_u_read( self, endpoint: u16, ) -> Result<Maybe<u64, AsNullable>, Error>

pub async fn nullable_int_64_u_read( self, endpoint: u16, ) -> Result<Maybe<u64, AsNullable>, Error>

pub async fn nullable_int_8_s_read( self, endpoint: u16, ) -> Result<Maybe<i8, AsNullable>, Error>

pub async fn nullable_int_16_s_read( self, endpoint: u16, ) -> Result<Maybe<i16, AsNullable>, Error>

pub async fn nullable_int_24_s_read( self, endpoint: u16, ) -> Result<Maybe<i32, AsNullable>, Error>

pub async fn nullable_int_32_s_read( self, endpoint: u16, ) -> Result<Maybe<i32, AsNullable>, Error>

pub async fn nullable_int_40_s_read( self, endpoint: u16, ) -> Result<Maybe<i64, AsNullable>, Error>

pub async fn nullable_int_48_s_read( self, endpoint: u16, ) -> Result<Maybe<i64, AsNullable>, Error>

pub async fn nullable_int_56_s_read( self, endpoint: u16, ) -> Result<Maybe<i64, AsNullable>, Error>

pub async fn nullable_int_64_s_read( self, endpoint: u16, ) -> Result<Maybe<i64, AsNullable>, Error>

pub async fn nullable_enum_8_read( self, endpoint: u16, ) -> Result<Maybe<u8, AsNullable>, Error>

pub async fn nullable_enum_16_read( self, endpoint: u16, ) -> Result<Maybe<u16, AsNullable>, Error>

pub async fn nullable_float_single_read( self, endpoint: u16, ) -> Result<Maybe<f32, AsNullable>, Error>

pub async fn nullable_float_double_read( self, endpoint: u16, ) -> Result<Maybe<f64, AsNullable>, Error>

pub async fn nullable_octet_string_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<Maybe<Octets<'_>, AsNullable>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn nullable_char_string_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<Maybe<&str, AsNullable>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn nullable_enum_attr_read( self, endpoint: u16, ) -> Result<Maybe<SimpleEnum, AsNullable>, Error>

pub async fn nullable_struct_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<Maybe<SimpleStruct<'_>, AsNullable>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn nullable_range_restricted_int_8_u_read( self, endpoint: u16, ) -> Result<Maybe<u8, AsNullable>, Error>

pub async fn nullable_range_restricted_int_8_s_read( self, endpoint: u16, ) -> Result<Maybe<i8, AsNullable>, Error>

pub async fn nullable_range_restricted_int_16_u_read( self, endpoint: u16, ) -> Result<Maybe<u16, AsNullable>, Error>

pub async fn nullable_range_restricted_int_16_s_read( self, endpoint: u16, ) -> Result<Maybe<i16, AsNullable>, Error>

pub async fn write_only_int_8_u_read(self, endpoint: u16) -> Result<u8, Error>

pub async fn nullable_global_enum_read( self, endpoint: u16, ) -> Result<Maybe<TestGlobalEnum, AsNullable>, Error>

pub async fn nullable_global_struct_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<Maybe<TestGlobalStruct<'_>, AsNullable>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn generated_command_list_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<TLVContainer<'_, u32, ArrayContainer>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn accepted_command_list_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<TLVContainer<'_, u32, ArrayContainer>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn attribute_list_read_with<R>( self, endpoint: u16, f: impl FnOnce(Result<TLVContainer<'_, u32, ArrayContainer>, Error>) -> R, ) -> Result<R, Error>

Read a non-scalar attribute (string, octet string, struct or list) whose value borrows the response buffer. Decodes the value and passes Result<Value, Error> to f while the borrow is live, returning the owned R that f produces (copy out what you need, e.g. |v| v.map(|s| s.to_string())). A non-served optional attribute surfaces as Err to f.

pub async fn feature_map_read(self, endpoint: u16) -> Result<u32, Error>

pub async fn cluster_revision_read(self, endpoint: u16) -> Result<u16, Error>

pub async fn mei_int_8_u_read(self, endpoint: u16) -> Result<u8, Error>

pub async fn boolean_write( self, endpoint: u16, value: bool, ) -> Result<(), Error>

pub async fn bitmap_8_write( self, endpoint: u16, value: Bitmap8MaskMap, ) -> Result<(), Error>

pub async fn bitmap_16_write( self, endpoint: u16, value: Bitmap16MaskMap, ) -> Result<(), Error>

pub async fn bitmap_32_write( self, endpoint: u16, value: Bitmap32MaskMap, ) -> Result<(), Error>

pub async fn bitmap_64_write( self, endpoint: u16, value: Bitmap64MaskMap, ) -> Result<(), Error>

pub async fn int_8_u_write(self, endpoint: u16, value: u8) -> Result<(), Error>

pub async fn int_16_u_write( self, endpoint: u16, value: u16, ) -> Result<(), Error>

pub async fn int_24_u_write( self, endpoint: u16, value: u32, ) -> Result<(), Error>

pub async fn int_32_u_write( self, endpoint: u16, value: u32, ) -> Result<(), Error>

pub async fn int_40_u_write( self, endpoint: u16, value: u64, ) -> Result<(), Error>

pub async fn int_48_u_write( self, endpoint: u16, value: u64, ) -> Result<(), Error>

pub async fn int_56_u_write( self, endpoint: u16, value: u64, ) -> Result<(), Error>

pub async fn int_64_u_write( self, endpoint: u16, value: u64, ) -> Result<(), Error>

pub async fn int_8_s_write(self, endpoint: u16, value: i8) -> Result<(), Error>

pub async fn int_16_s_write( self, endpoint: u16, value: i16, ) -> Result<(), Error>

pub async fn int_24_s_write( self, endpoint: u16, value: i32, ) -> Result<(), Error>

pub async fn int_32_s_write( self, endpoint: u16, value: i32, ) -> Result<(), Error>

pub async fn int_40_s_write( self, endpoint: u16, value: i64, ) -> Result<(), Error>

pub async fn int_48_s_write( self, endpoint: u16, value: i64, ) -> Result<(), Error>

pub async fn int_56_s_write( self, endpoint: u16, value: i64, ) -> Result<(), Error>

pub async fn int_64_s_write( self, endpoint: u16, value: i64, ) -> Result<(), Error>

pub async fn enum_8_write(self, endpoint: u16, value: u8) -> Result<(), Error>

pub async fn enum_16_write(self, endpoint: u16, value: u16) -> Result<(), Error>

pub async fn float_single_write( self, endpoint: u16, value: f32, ) -> Result<(), Error>

pub async fn float_double_write( self, endpoint: u16, value: f64, ) -> Result<(), Error>

pub async fn epoch_us_write( self, endpoint: u16, value: u64, ) -> Result<(), Error>

pub async fn epoch_s_write(self, endpoint: u16, value: u32) -> Result<(), Error>

pub async fn vendor_id_write( self, endpoint: u16, value: u16, ) -> Result<(), Error>

pub async fn enum_attr_write( self, endpoint: u16, value: SimpleEnum, ) -> Result<(), Error>

pub async fn range_restricted_int_8_u_write( self, endpoint: u16, value: u8, ) -> Result<(), Error>

pub async fn range_restricted_int_8_s_write( self, endpoint: u16, value: i8, ) -> Result<(), Error>

pub async fn range_restricted_int_16_u_write( self, endpoint: u16, value: u16, ) -> Result<(), Error>

pub async fn range_restricted_int_16_s_write( self, endpoint: u16, value: i16, ) -> Result<(), Error>

pub async fn timed_write_boolean_write( self, endpoint: u16, value: bool, ) -> Result<(), Error>

pub async fn general_error_boolean_write( self, endpoint: u16, value: bool, ) -> Result<(), Error>

pub async fn cluster_error_boolean_write( self, endpoint: u16, value: bool, ) -> Result<(), Error>

pub async fn global_enum_write( self, endpoint: u16, value: TestGlobalEnum, ) -> Result<(), Error>

pub async fn unsupported_attribute_requiring_admin_privilege_write( self, endpoint: u16, value: bool, ) -> Result<(), Error>

pub async fn unsupported_write( self, endpoint: u16, value: bool, ) -> Result<(), Error>

pub async fn read_failure_code_write( self, endpoint: u16, value: u8, ) -> Result<(), Error>

pub async fn failure_int_32_u_write( self, endpoint: u16, value: u32, ) -> Result<(), Error>

pub async fn nullable_boolean_write( self, endpoint: u16, value: Maybe<bool, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_bitmap_8_write( self, endpoint: u16, value: Maybe<Bitmap8MaskMap, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_bitmap_16_write( self, endpoint: u16, value: Maybe<Bitmap16MaskMap, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_bitmap_32_write( self, endpoint: u16, value: Maybe<Bitmap32MaskMap, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_bitmap_64_write( self, endpoint: u16, value: Maybe<Bitmap64MaskMap, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_8_u_write( self, endpoint: u16, value: Maybe<u8, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_16_u_write( self, endpoint: u16, value: Maybe<u16, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_24_u_write( self, endpoint: u16, value: Maybe<u32, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_32_u_write( self, endpoint: u16, value: Maybe<u32, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_40_u_write( self, endpoint: u16, value: Maybe<u64, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_48_u_write( self, endpoint: u16, value: Maybe<u64, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_56_u_write( self, endpoint: u16, value: Maybe<u64, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_64_u_write( self, endpoint: u16, value: Maybe<u64, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_8_s_write( self, endpoint: u16, value: Maybe<i8, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_16_s_write( self, endpoint: u16, value: Maybe<i16, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_24_s_write( self, endpoint: u16, value: Maybe<i32, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_32_s_write( self, endpoint: u16, value: Maybe<i32, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_40_s_write( self, endpoint: u16, value: Maybe<i64, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_48_s_write( self, endpoint: u16, value: Maybe<i64, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_56_s_write( self, endpoint: u16, value: Maybe<i64, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_int_64_s_write( self, endpoint: u16, value: Maybe<i64, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_enum_8_write( self, endpoint: u16, value: Maybe<u8, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_enum_16_write( self, endpoint: u16, value: Maybe<u16, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_float_single_write( self, endpoint: u16, value: Maybe<f32, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_float_double_write( self, endpoint: u16, value: Maybe<f64, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_enum_attr_write( self, endpoint: u16, value: Maybe<SimpleEnum, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_range_restricted_int_8_u_write( self, endpoint: u16, value: Maybe<u8, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_range_restricted_int_8_s_write( self, endpoint: u16, value: Maybe<i8, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_range_restricted_int_16_u_write( self, endpoint: u16, value: Maybe<u16, AsNullable>, ) -> Result<(), Error>

pub async fn nullable_range_restricted_int_16_s_write( self, endpoint: u16, value: Maybe<i16, AsNullable>, ) -> Result<(), Error>

pub async fn write_only_int_8_u_write( self, endpoint: u16, value: u8, ) -> Result<(), Error>

pub async fn nullable_global_enum_write( self, endpoint: u16, value: Maybe<TestGlobalEnum, AsNullable>, ) -> Result<(), Error>

pub async fn mei_int_8_u_write( self, endpoint: u16, value: u8, ) -> Result<(), Error>