Adding method to add reference_triples to CoMIDs

Also added PartialEq, Eq, PartialOrd, Ord to most types.

Signed-off-by: Larry Dewey <[email protected]>

Author: larrydewey

src/comid.rs

@@ -85,7 +85,10 @@
 //! All components support optional extensions through [`ExtensionMap`] for future expandability.
 
 use crate::{
-    generate_tagged, AttestKeyTripleRecord, ConditionalEndorsementSeriesTripleRecord,
+    core::{RawValueType, TaggedBytes},
+    generate_tagged,
+    triples::{EnvironmentMap, MeasuredElementTypeChoice, MeasurementMap, MeasurementValuesMap},
+    AttestKeyTripleRecord, ConditionalEndorsementSeriesTripleRecord,
     ConditionalEndorsementTripleRecord, CoswidTripleRecord, DomainDependencyTripleRecord,
     DomainMembershipTripleRecord, EndorsedTripleRecord, ExtensionMap, IdentityTripleRecord,
     OneOrMany, ReferenceTripleRecord, Text, Tstr, Uint, Uri, UuidType,
@@ -104,7 +107,7 @@ generate_tagged!((
     "A Concise Module Identifier (CoMID) structured tag"
 ),);
 /// A Concise Module Identifier (CoMID) tag structure tagged with CBOR tag 506
-#[derive(Debug, Serialize, Deserialize, From, Constructor)]
+#[derive(Debug, Serialize, Deserialize, From, Constructor, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(C)]
 pub struct ConciseMidTag<'a> {
     /// Optional language identifier for the tag content
@@ -126,8 +129,141 @@ pub struct ConciseMidTag<'a> {
     pub extension: Option<ExtensionMap<'a>>,
 }
 
+impl<'a> ConciseMidTag<'a> {
+    /// Adds a reference value to the CoMID tag's reference triples.
+    ///
+    /// This method serializes the provided value to CBOR bytes and adds it as a raw measurement value
+    /// within a reference triple. If a reference triple with the same environment already exists,
+    /// the measurement is added to that triple. Otherwise, a new reference triple is created.
+    ///
+    /// # Arguments
+    ///
+    /// * `environment` - The environment map that describes the context for this reference value
+    /// * `mkey` - Optional measurement element type that identifies what is being measured
+    /// * `value` - The value to serialize and store as the reference value
+    ///
+    /// # Returns
+    ///
+    /// Returns `Ok(())` if successful, or an `std::io::Error` if serialization fails.
+    ///
+    /// # Example
+    ///
+    /// ``` ignore
+    /// use corim_rs::{
+    ///     comid::{ConciseMidTag, TagIdentityMap, ComidEntityMap, TriplesMap, TagIdTypeChoice},
+    ///     core::{OneOrMore, Text, Tstr},
+    ///     triples::{EnvironmentMap, MeasuredElementTypeChoice},
+    /// };
+    ///
+    /// let mut comid = ConciseMidTag {
+    ///     language: None,
+    ///     tag_identity: TagIdentityMap {
+    ///         tag_id: TagIdTypeChoice::Tstr(Tstr::from("example-id")),
+    ///         tag_version: Some(1),
+    ///     },
+    ///     entities: OneOrMore::One(ComidEntityMap {
+    ///         entity_name: Text::from("Example Corp"),
+    ///         reg_id: None,
+    ///         role: OneOrMore::One(corim_rs::comid::ComidRoleTypeChoice::TagCreator),
+    ///         extension: None,
+    ///     }),
+    ///     linked_tags: None,
+    ///     triples: TriplesMap::default(),
+    ///     extension: None,
+    /// };
+    ///
+    /// // Add a reference value
+    /// let env = EnvironmentMap::default();
+    /// let reference_data = "example reference value";
+    /// comid.add_reference_value(env, None, &reference_data).expect("Failed to add reference value");
+    /// ```
+    ///
+    /// # How It Works
+    ///
+    /// 1. The value is serialized to CBOR bytes using the `ciborium` library
+    /// 2. The bytes are wrapped in a `TaggedBytes` structure
+    /// 3. A `MeasurementMap` is created with the provided measurement key and the raw value
+    /// 4. The method then updates the CoMID's reference triples based on existing data:
+    ///    - If no reference triples exist, a new one is created
+    ///    - If a reference triple with the matching environment exists, the measurement is added to it
+    ///    - If reference triples exist but none match the environment, a new triple is added
+    pub fn add_reference_value<T>(
+        &mut self,
+        environment: EnvironmentMap<'a>,
+        mkey: Option<MeasuredElementTypeChoice<'a>>,
+        value: &T,
+    ) -> Result<(), std::io::Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        let mut raw_bytes = vec![];
+        ciborium::into_writer(value, &mut raw_bytes)
+            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+        let raw_value = TaggedBytes::new(raw_bytes);
+
+        let measurement = MeasurementMap {
+            mkey,
+            mval: MeasurementValuesMap {
+                raw: Some(RawValueType {
+                    raw_value: raw_value.into(),
+                    raw_value_mask: None,
+                }),
+                ..Default::default()
+            },
+            authorized_by: None,
+        };
+
+        match &mut self.triples.reference_triples {
+            None => {
+                let new_record = ReferenceTripleRecord {
+                    ref_env: environment,
+                    ref_claims: measurement.into(),
+                };
+                self.triples.reference_triples = Some(OneOrMany::One(new_record));
+            }
+            Some(OneOrMany::One(record)) => {
+                if record.ref_env == environment {
+                    match &mut record.ref_claims {
+                        OneOrMany::One(original_claim) => {
+                            record.ref_claims =
+                                OneOrMany::Many(vec![std::mem::take(original_claim), measurement])
+                        }
+                        OneOrMany::Many(claims) => claims.push(measurement),
+                    }
+                } else {
+                    let new_record: ReferenceTripleRecord<'a> = ReferenceTripleRecord {
+                        ref_env: environment,
+                        ref_claims: measurement.into(),
+                    };
+
+                    let many = vec![std::mem::take(record), new_record];
+                    self.triples.reference_triples = Some(OneOrMany::Many(many));
+                }
+            }
+            Some(OneOrMany::Many(vec)) => {
+                if let Some(record) = vec.iter_mut().find(|r| r.ref_env == environment) {
+                    match &mut record.ref_claims {
+                        OneOrMany::One(claim) => {
+                            record.ref_claims =
+                                OneOrMany::Many(vec![std::mem::take(claim), measurement])
+                        }
+                        OneOrMany::Many(claims) => claims.push(measurement),
+                    }
+                } else {
+                    let new_record = ReferenceTripleRecord {
+                        ref_env: environment,
+                        ref_claims: measurement.into(),
+                    };
+                    vec.push(new_record);
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
 /// Identification information for a tag
-#[derive(Debug, Serialize, Deserialize, From, Constructor)]
+#[derive(Debug, Serialize, Deserialize, From, Constructor, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(C)]
 pub struct TagIdentityMap<'a> {
     /// Unique identifier for the tag
@@ -140,7 +276,7 @@ pub struct TagIdentityMap<'a> {
 }
 
 /// Represents either a string or UUID tag identifier
-#[derive(Debug, Serialize, Deserialize, From, TryFrom)]
+#[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(C)]
 pub enum TagIdTypeChoice<'a> {
     /// Text string identifier
@@ -156,7 +292,7 @@ impl<'a> From<&'a str> for TagIdTypeChoice<'a> {
 }
 
 /// Information about an entity associated with the tag
-#[derive(Debug, Serialize, Deserialize, From, Constructor)]
+#[derive(Debug, Serialize, Deserialize, From, Constructor, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(C)]
 pub struct ComidEntityMap<'a> {
     /// Name of the entity
@@ -175,7 +311,7 @@ pub struct ComidEntityMap<'a> {
 }
 
 /// Role types that can be assigned to entities
-#[derive(Debug, Serialize, Deserialize, From, TryFrom)]
+#[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(C)]
 pub enum ComidRoleTypeChoice {
     /// Entity that created the tag (value: 0)
@@ -187,7 +323,7 @@ pub enum ComidRoleTypeChoice {
 }
 
 /// Reference to another tag and its relationship to this one
-#[derive(Debug, Serialize, Deserialize, From, Constructor)]
+#[derive(Debug, Serialize, Deserialize, From, Constructor, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(C)]
 pub struct LinkedTagMap<'a> {
     /// Identifier of the linked tag
@@ -199,7 +335,7 @@ pub struct LinkedTagMap<'a> {
 }
 
 /// Types of relationships between tags
-#[derive(Debug, Serialize, Deserialize, From, TryFrom)]
+#[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(C)]
 pub enum TagRelTypeChoice {
     /// This tag supplements the linked tag by providing additional information
@@ -211,7 +347,7 @@ pub enum TagRelTypeChoice {
 }
 
 /// Collection of different types of triples describing the module characteristics
-#[derive(Default, Debug, Serialize, Deserialize, From)]
+#[derive(Default, Debug, Serialize, Deserialize, From, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(C)]
 pub struct TriplesMap<'a> {
     /// Optional reference triples that link to external references

src/core.rs

@@ -66,11 +66,6 @@ pub type Int = i32;
 /// Integer is an alias for Int type
 pub type Integer = Int;
 
-pub enum StrWrapper<'a, T> {
-    Tstr(Tstr<'a>),
-    Other(T),
-}
-
 /// ExtensionMap represents the possible types that can be used in extensions
 #[derive(Debug, Serialize, Deserialize, Ord, PartialOrd, Eq, PartialEq, From, TryFrom)]
 pub enum ExtensionMap<'a> {
@@ -91,7 +86,20 @@ pub enum ExtensionMap<'a> {
 }
 
 /// UUID type representing a 16-byte unique identifier
-#[derive(Default, Debug, Serialize, Deserialize, From, AsRef, AsMut, Constructor)]
+#[derive(
+    Default,
+    Debug,
+    Serialize,
+    Deserialize,
+    From,
+    AsRef,
+    AsMut,
+    Constructor,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+)]
 pub struct UuidType {
     #[serde(flatten)]
     pub field: [u8; 16],
@@ -107,7 +115,7 @@ impl TryFrom<&[u8]> for UuidType {
 }
 
 /// UEID type representing a 33-byte Unique Entity Identifier
-#[derive(Debug, Serialize, Deserialize, From, Constructor)]
+#[derive(Debug, Serialize, Deserialize, From, Constructor, PartialEq, Eq, PartialOrd, Ord)]
 pub struct UeidType {
     #[serde(flatten)]
     pub field: FixedBytes<33>,
@@ -134,7 +142,7 @@ generate_tagged!(
 
 /// Represents a value that can be either text or bytes
 #[repr(C)]
-#[derive(Debug, Serialize, Deserialize, From, TryFrom)]
+#[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord)]
 pub enum TextOrBytes<'a> {
     /// UTF-8 string value
     Text(Text<'a>),
@@ -144,7 +152,7 @@ pub enum TextOrBytes<'a> {
 
 /// Represents a value that can be either text or fixed-size bytes
 #[repr(C)]
-#[derive(Debug, Serialize, Deserialize, From, TryFrom)]
+#[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord)]
 pub enum TextOrBytesSized<'a, const N: usize> {
     /// UTF-8 string value
     Text(Text<'a>),
@@ -154,7 +162,7 @@ pub enum TextOrBytesSized<'a, const N: usize> {
 
 /// Represents a hash entry with algorithm ID and hash value
 #[repr(C)]
-#[derive(Debug, Serialize, Deserialize, From, Constructor)]
+#[derive(Debug, Serialize, Deserialize, From, Constructor, PartialEq, Eq, PartialOrd, Ord)]
 pub struct HashEntry {
     /// Algorithm identifier for the hash
     #[serde(rename = "hash-alg-id")]
@@ -205,7 +213,7 @@ pub enum OneOrMany<T> {
 }
 
 /// Represents an attribute value that can be either text or integer, single or multiple
-#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Serialize, Deserialize, From, TryFrom)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, From, TryFrom)]
 #[serde(untagged)]
 #[repr(C)]
 pub enum AttributeValue<'a> {
@@ -214,7 +222,9 @@ pub enum AttributeValue<'a> {
 }
 
 /// Represents global attributes with optional language tag and arbitrary attributes
-#[derive(Default, Debug, Clone, Serialize, Deserialize, From, Constructor)]
+#[derive(
+    Default, Debug, Clone, Serialize, Deserialize, From, Constructor, PartialEq, Eq, PartialOrd, Ord,
+)]
 #[repr(C)]
 pub struct GlobalAttributes<'a> {
     /// Optional language tag (ex. en_US)
@@ -273,7 +283,7 @@ pub enum CotlMapRegistry {
 
 /// Represents a digest value with its algorithm identifier
 #[repr(C)]
-#[derive(Debug, Serialize, Deserialize, From, Constructor)]
+#[derive(Debug, Serialize, Deserialize, From, Constructor, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Digest<'a> {
     /// Algorithm identifier for the digest
     pub alg: AlgLabel<'a>,
@@ -283,7 +293,7 @@ pub struct Digest<'a> {
 
 /// Represents either a COSE key set or a single COSE key
 #[repr(C)]
-#[derive(Debug, Serialize, Deserialize, From, TryFrom)]
+#[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord)]
 pub enum CoseKeySetOrKey<'a> {
     /// A set of COSE keys
     KeySet(OneOrMany<CoseKey<'a>>),
@@ -292,7 +302,7 @@ pub enum CoseKeySetOrKey<'a> {
 }
 
 /// Represents a COSE key structure as defined in RFC 8152
-#[derive(Debug, Serialize, Deserialize, From, Constructor)]
+#[derive(Debug, Serialize, Deserialize, From, Constructor, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(C)]
 pub struct CoseKey<'a> {
     /// Key type identifier (kty)
@@ -316,15 +326,17 @@ pub struct CoseKey<'a> {
     pub extension: Option<ExtensionMap<'a>>,
 }
 
-#[derive(Default, Debug, Serialize, Deserialize, From, Constructor)]
+#[derive(
+    Default, Debug, Serialize, Deserialize, From, Constructor, PartialEq, Eq, PartialOrd, Ord,
+)]
 #[repr(C)]
 /// Raw value data structure with associated mask
 pub struct MaskedRawValue {
     pub value: Bytes,
     pub mask: Bytes,
 }
 
-#[derive(Debug, Serialize, Deserialize, From, Constructor)]
+#[derive(Debug, Serialize, Deserialize, From, Constructor, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(C)]
 /// Container for raw values with optional masking
 pub struct RawValueType {
@@ -335,7 +347,7 @@ pub struct RawValueType {
 /// Type alias for raw value masks
 pub type RawValueMaskType = Bytes;
 
-#[derive(Debug, Serialize, Deserialize, From)]
+#[derive(Debug, Serialize, Deserialize, From, PartialEq, Eq, PartialOrd, Ord)]
 /// Represents different types of raw values
 pub enum RawValueTypeChoice {
     TaggedBytes(TaggedBytes),
@@ -344,7 +356,7 @@ pub enum RawValueTypeChoice {
 
 /// Version scheme enumeration as defined in the specification
 #[repr(C)]
-#[derive(Debug, Serialize, Deserialize, From, TryFrom)]
+#[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord)]
 pub enum VersionScheme {
     /// Multi-part numeric version (e.g., 1.2.3)
     Multipartnumeric = 1,
@@ -392,7 +404,7 @@ pub enum VersionScheme {
 /// let alg = CoseAlgorithm::ES256;  // ECDSA with SHA-256
 /// let hash_alg = CoseAlgorithm::Sha256;  // SHA-256 hash function
 /// ```
-#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 #[repr(i64)]
 pub enum CoseAlgorithm {
     /// Reserved for private use (-65536)