Rename ManageExtension to Se050ManageExtension

To avoid confusion with trussed_manage::ManageExtension, this patch
renames trussed_se050_manage::ManageExtension to Se050ManageExtension.

CHANGELOG.md

@@ -6,7 +6,8 @@
 
 - Use extension crates `trussed-manage` and `trussed-wrap-key-to-file` instead
   of backend crate `trussed-staging`, see [trussed-staging#19][].
-- Move `manage::ManageExtension` into `trussed-se050-manage` crate.
+- Move `manage::ManageExtension` into `trussed-se050-manage` crate and rename
+  it to `Se050ManageExtension`.
 
 [trussed-staging#19]: https://github.com/trussed-dev/trussed-staging/pull/19
 

extensions/se050-manage/src/lib.rs

@@ -1,3 +1,5 @@
+#![no_std]
+
 use serde::{Deserialize, Serialize};
 use trussed::{
     serde_extensions::{Extension, ExtensionClient, ExtensionResult},
@@ -6,7 +8,7 @@ use trussed::{
 };
 
 #[derive(Debug, Default)]
-pub struct ManageExtension;
+pub struct Se050ManageExtension;
 
 /// Request information regarding the SE050
 #[derive(Debug, Deserialize, Serialize, Copy, Clone)]
@@ -20,38 +22,38 @@ pub struct TestSe050Request;
 
 #[allow(clippy::large_enum_variant)]
 #[derive(Debug, Deserialize, Serialize)]
-pub enum ManageRequest {
+pub enum Se050ManageRequest {
     Info(InfoRequest),
     TestSe050(TestSe050Request),
 }
 
-impl TryFrom<ManageRequest> for InfoRequest {
+impl TryFrom<Se050ManageRequest> for InfoRequest {
     type Error = Error;
-    fn try_from(request: ManageRequest) -> Result<Self, Self::Error> {
+    fn try_from(request: Se050ManageRequest) -> Result<Self, Self::Error> {
         match request {
-            ManageRequest::Info(request) => Ok(request),
+            Se050ManageRequest::Info(request) => Ok(request),
             _ => Err(Error::InternalError),
         }
     }
 }
 
-impl From<InfoRequest> for ManageRequest {
+impl From<InfoRequest> for Se050ManageRequest {
     fn from(request: InfoRequest) -> Self {
         Self::Info(request)
     }
 }
 
-impl TryFrom<ManageRequest> for TestSe050Request {
+impl TryFrom<Se050ManageRequest> for TestSe050Request {
     type Error = Error;
-    fn try_from(request: ManageRequest) -> Result<Self, Self::Error> {
+    fn try_from(request: Se050ManageRequest) -> Result<Self, Self::Error> {
         match request {
-            ManageRequest::TestSe050(request) => Ok(request),
+            Se050ManageRequest::TestSe050(request) => Ok(request),
             _ => Err(Error::InternalError),
         }
     }
 }
 
-impl From<TestSe050Request> for ManageRequest {
+impl From<TestSe050Request> for Se050ManageRequest {
     fn from(request: TestSe050Request) -> Self {
         Self::TestSe050(request)
     }
@@ -70,22 +72,22 @@ pub struct InfoReply {
 }
 
 #[derive(Debug, Deserialize, Serialize)]
-pub enum ManageReply {
+pub enum Se050ManageReply {
     Info(InfoReply),
     TestSe050(TestSe050Reply),
 }
 
-impl TryFrom<ManageReply> for InfoReply {
+impl TryFrom<Se050ManageReply> for InfoReply {
     type Error = Error;
-    fn try_from(request: ManageReply) -> Result<Self, Self::Error> {
+    fn try_from(request: Se050ManageReply) -> Result<Self, Self::Error> {
         match request {
-            ManageReply::Info(request) => Ok(request),
+            Se050ManageReply::Info(request) => Ok(request),
             _ => Err(Error::InternalError),
         }
     }
 }
 
-impl From<InfoReply> for ManageReply {
+impl From<InfoReply> for Se050ManageReply {
     fn from(request: InfoReply) -> Self {
         Self::Info(request)
     }
@@ -96,42 +98,42 @@ pub struct TestSe050Reply {
     pub reply: Bytes<1024>,
 }
 
-impl TryFrom<ManageReply> for TestSe050Reply {
+impl TryFrom<Se050ManageReply> for TestSe050Reply {
     type Error = Error;
-    fn try_from(request: ManageReply) -> Result<Self, Self::Error> {
+    fn try_from(request: Se050ManageReply) -> Result<Self, Self::Error> {
         match request {
-            ManageReply::TestSe050(request) => Ok(request),
+            Se050ManageReply::TestSe050(request) => Ok(request),
             _ => Err(Error::InternalError),
         }
     }
 }
 
-impl From<TestSe050Reply> for ManageReply {
+impl From<TestSe050Reply> for Se050ManageReply {
     fn from(request: TestSe050Reply) -> Self {
         Self::TestSe050(request)
     }
 }
 
-impl Extension for ManageExtension {
-    type Request = ManageRequest;
-    type Reply = ManageReply;
+impl Extension for Se050ManageExtension {
+    type Request = Se050ManageRequest;
+    type Reply = Se050ManageReply;
 }
 
-pub type ManageResult<'a, R, C> = ExtensionResult<'a, ManageExtension, R, C>;
+pub type Se050ManageResult<'a, R, C> = ExtensionResult<'a, Se050ManageExtension, R, C>;
 
-pub trait ManageClient: ExtensionClient<ManageExtension> {
+pub trait Se050ManageClient: ExtensionClient<Se050ManageExtension> {
     /// Get info on the SE050
-    fn get_info(&mut self) -> ManageResult<'_, InfoReply, Self> {
+    fn get_info(&mut self) -> Se050ManageResult<'_, InfoReply, Self> {
         self.extension(InfoRequest)
     }
 
     /// Test the se050 device and driver
     ///
     /// This will fake the results of the tests from v0.1.0-test-driver for compatibility but
     /// return correct metadata header to be shown in the test result
-    fn test_se050(&mut self) -> ManageResult<'_, TestSe050Reply, Self> {
+    fn test_se050(&mut self) -> Se050ManageResult<'_, TestSe050Reply, Self> {
         self.extension(TestSe050Request)
     }
 }
 
-impl<C: ExtensionClient<ManageExtension>> ManageClient for C {}
+impl<C: ExtensionClient<Se050ManageExtension>> Se050ManageClient for C {}

src/manage.rs

@@ -15,27 +15,27 @@ use trussed::{
     Error,
 };
 use trussed_se050_manage::{
-    InfoReply, InfoRequest, ManageExtension, ManageRequest, TestSe050Reply,
+    InfoReply, InfoRequest, Se050ManageExtension, Se050ManageRequest, TestSe050Reply,
 };
 
 use crate::Se050Backend;
 
-impl<Twi: I2CForT1, D: DelayUs<u32>> ExtensionImpl<ManageExtension> for Se050Backend<Twi, D> {
+impl<Twi: I2CForT1, D: DelayUs<u32>> ExtensionImpl<Se050ManageExtension> for Se050Backend<Twi, D> {
     fn extension_request<P: trussed::Platform>(
         &mut self,
         _core_ctx: &mut CoreContext,
         _backend_ctx: &mut Self::Context,
-        request: &<ManageExtension as Extension>::Request,
+        request: &<Se050ManageExtension as Extension>::Request,
         _resources: &mut ServiceResources<P>,
-    ) -> Result<<ManageExtension as Extension>::Reply, Error> {
+    ) -> Result<<Se050ManageExtension as Extension>::Reply, Error> {
         self.configure().map_err(|err| {
             debug!("Failed to enable for management: {err:?}");
             err
         })?;
 
         debug!("Runnig manage request: {request:?}");
         match request {
-            ManageRequest::Info(InfoRequest) => {
+            Se050ManageRequest::Info(InfoRequest) => {
                 let buf = &mut [0; 128];
                 let atr = self
                     .se
@@ -97,7 +97,7 @@ impl<Twi: I2CForT1, D: DelayUs<u32>> ExtensionImpl<ManageExtension> for Se050Bac
                 }
                 .into())
             }
-            ManageRequest::TestSe050(_) => {
+            Se050ManageRequest::TestSe050(_) => {
                 let mut buf = [b'a'; 128];
                 let mut reply = Bytes::new();
                 let atr = self.enable()?;