Struct CommonProperties 

pub struct CommonProperties {
    pub type: String,
    pub id: String,
    pub schema_version: Option<String>,
    pub created: DateTime<Utc>,
    pub modified: DateTime<Utc>,
    pub created_by_ref: Option<String>,
    pub custom_properties: HashMap<String, Value>,
}

Common properties shared by MAEC top-level objects

These properties are flattened into each MAEC object type via serde, providing consistent ID generation, timestamping, and metadata.

Fields

type: String

The type of MAEC object (e.g., “package”, “malware-family”)

id: String

Unique identifier for this object (format: “type–uuid”)

schema_version: Option<String>

MAEC specification version (should be “5.0”)

created: DateTime<Utc>

Timestamp when the object was created

modified: DateTime<Utc>

Timestamp when the object was last modified

created_by_ref: Option<String>

Reference to the identity that created this object

custom_properties: HashMap<String, Value>

Custom properties for extensions

Implementations

impl CommonProperties

pub fn new( object_type: impl Into<String>, created_by_ref: Option<String>, ) -> Self

Creates a new CommonProperties instance

Arguments

• object_type - The MAEC object type (e.g., “package”, “malware-family”)
• created_by_ref - Optional reference to the creating identity

Examples

use maec::common::CommonProperties;

let common = CommonProperties::new("malware-family", None);
assert_eq!(common.r#type, "malware-family");
assert_eq!(common.schema_version, Some("5.0".to_string()));

pub fn new_version(&mut self)

Creates a new version of this object by updating the modified timestamp

In MAEC (like STIX), when you update an object, you keep the same ID and created timestamp but update the modified timestamp to indicate a new version.

Examples

use maec::common::CommonProperties;
use std::thread;
use std::time::Duration;

let mut common = CommonProperties::new("malware-family", None);
let original_modified = common.modified;

thread::sleep(Duration::from_millis(10));
common.new_version();

assert!(common.modified > original_modified);
assert_eq!(common.created, original_modified); // created unchanged

Trait Implementations

impl Clone for CommonProperties

fn clone(&self) -> CommonProperties

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CommonProperties

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CommonProperties

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CommonProperties

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl MaecObject for CommonProperties

fn id(&self) -> &str

Returns the unique identifier of the object

fn type_(&self) -> &str

Returns the type of the MAEC object (e.g., “package”, “malware-family”)

fn created(&self) -> DateTime<Utc>

Returns when the object was created

impl PartialEq for CommonProperties

fn eq(&self, other: &CommonProperties) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CommonProperties

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CommonProperties

impl StructuralPartialEq for CommonProperties