memscope_rs/capture/types/
ownership.rs

1//! Ownership tracking types.
2//!
3//! This module contains types for tracking ownership hierarchy,
4//! ownership transfers, weak references, and circular references.
5
6use serde::{Deserialize, Serialize};
7
8use super::generic::MemoryImpact;
9use super::leak_detection::LeakRiskLevel;
10
11/// Ownership hierarchy analysis.
12#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13pub struct OwnershipHierarchy {
14    /// Root owners in the hierarchy.
15    pub root_owners: Vec<OwnershipNode>,
16    /// Maximum ownership depth.
17    pub max_depth: usize,
18    /// Total objects in hierarchy.
19    pub total_objects: usize,
20    /// Ownership transfer events.
21    pub transfer_events: Vec<OwnershipTransferEvent>,
22    /// Weak reference analysis.
23    pub weak_references: Vec<WeakReferenceInfo>,
24    /// Circular reference detection.
25    pub circular_references: Vec<CircularReferenceInfo>,
26}
27
28/// Node in ownership hierarchy.
29#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
30pub struct OwnershipNode {
31    /// Object identifier.
32    pub object_id: usize,
33    /// Object type name.
34    pub type_name: String,
35    /// Ownership type.
36    pub ownership_type: OwnershipType,
37    /// Owned objects.
38    pub owned_objects: Vec<OwnershipNode>,
39    /// Reference count (for Rc/Arc).
40    pub reference_count: Option<usize>,
41    /// Weak reference count.
42    pub weak_reference_count: Option<usize>,
43}
44
45/// Types of ownership.
46#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
47pub enum OwnershipType {
48    /// Unique ownership (Box, owned values).
49    Unique,
50    /// Shared ownership (Rc).
51    SharedSingleThreaded,
52    /// Shared ownership (Arc).
53    SharedMultiThreaded,
54    /// Borrowed reference.
55    Borrowed,
56    /// Weak reference.
57    Weak,
58    /// Raw pointer (unsafe).
59    Raw,
60}
61
62/// Ownership transfer event.
63#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
64pub struct OwnershipTransferEvent {
65    /// Source object.
66    pub source_object: usize,
67    /// Target object.
68    pub target_object: usize,
69    /// Transfer type.
70    pub transfer_type: OwnershipTransferType,
71    /// Transfer timestamp.
72    pub timestamp: u64,
73    /// Transfer mechanism.
74    pub mechanism: String,
75}
76
77/// Types of ownership transfers.
78#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
79pub enum OwnershipTransferType {
80    /// Move operation.
81    Move,
82    /// Clone operation.
83    Clone,
84    /// Reference creation.
85    Borrow,
86    /// Reference counting increment.
87    ReferenceIncrement,
88    /// Reference counting decrement.
89    ReferenceDecrement,
90}
91
92/// Weak reference information.
93#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
94pub struct WeakReferenceInfo {
95    /// Weak reference object ID.
96    pub weak_ref_id: usize,
97    /// Target object ID.
98    pub target_object_id: usize,
99    /// Weak reference type.
100    pub weak_ref_type: WeakReferenceType,
101    /// Is target still alive.
102    pub target_alive: bool,
103    /// Upgrade attempts.
104    pub upgrade_attempts: u32,
105    /// Successful upgrades.
106    pub successful_upgrades: u32,
107}
108
109/// Types of weak references.
110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
111pub enum WeakReferenceType {
112    /// std::rc::Weak.
113    RcWeak,
114    /// std::sync::Weak.
115    ArcWeak,
116    /// Custom weak reference.
117    Custom,
118}
119
120/// Circular reference information.
121#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
122pub struct CircularReferenceInfo {
123    /// Objects involved in the cycle.
124    pub cycle_objects: Vec<usize>,
125    /// Cycle detection timestamp.
126    pub detection_timestamp: u64,
127    /// Cycle type.
128    pub cycle_type: CircularReferenceType,
129    /// Potential memory leak risk.
130    pub leak_risk: LeakRiskLevel,
131    /// Suggested resolution.
132    pub resolution_suggestion: String,
133}
134
135/// Types of circular references.
136#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
137pub enum CircularReferenceType {
138    /// Direct circular reference (A -> B -> A).
139    Direct,
140    /// Indirect circular reference (A -> B -> C -> A).
141    Indirect,
142    /// Self-referential (A -> A).
143    SelfReferential,
144    /// Complex multi-path cycle.
145    Complex,
146}
147
148/// Type relationship information.
149#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
150pub struct TypeRelationshipInfo {
151    /// Type name.
152    pub type_name: String,
153    /// Parent types (traits, base structs).
154    pub parent_types: Vec<ParentTypeInfo>,
155    /// Child types (implementors, derived types).
156    pub child_types: Vec<ChildTypeInfo>,
157    /// Composed types (fields, associated types).
158    pub composed_types: Vec<ComposedTypeInfo>,
159    /// Relationship complexity score.
160    pub complexity_score: u32,
161    /// Inheritance depth.
162    pub inheritance_depth: u32,
163    /// Composition breadth.
164    pub composition_breadth: u32,
165}
166
167/// Parent type information.
168#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
169pub struct ParentTypeInfo {
170    /// Parent type name.
171    pub type_name: String,
172    /// Relationship type.
173    pub relationship_type: RelationshipType,
174    /// Inheritance level.
175    pub inheritance_level: u32,
176    /// Memory layout impact.
177    pub memory_impact: MemoryImpact,
178}
179
180/// Child type information.
181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
182pub struct ChildTypeInfo {
183    /// Child type name.
184    pub type_name: String,
185    /// Relationship type.
186    pub relationship_type: RelationshipType,
187    /// Specialization level.
188    pub specialization_level: u32,
189    /// Usage frequency.
190    pub usage_frequency: u32,
191}
192
193/// Composed type information.
194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
195pub struct ComposedTypeInfo {
196    /// Composed type name.
197    pub type_name: String,
198    /// Field or association name.
199    pub field_name: String,
200    /// Composition type.
201    pub composition_type: CompositionType,
202    /// Memory offset (if applicable).
203    pub memory_offset: Option<usize>,
204    /// Access frequency.
205    pub access_frequency: u32,
206}
207
208/// Type relationship types.
209#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
210pub enum RelationshipType {
211    /// Trait implementation relationship.
212    TraitImplementation,
213    /// Trait bound relationship.
214    TraitBound,
215    /// Inheritance relationship.
216    Inheritance,
217    /// Association relationship.
218    Association,
219    /// Aggregation relationship.
220    Composition,
221    /// Dependency relationship.
222    Dependency,
223}
224
225/// Composition types.
226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
227pub enum CompositionType {
228    /// Field composition type.
229    Field,
230    /// Associated type composition type.
231    AssociatedType,
232    /// Generic parameter composition type.
233    GenericParameter,
234    /// Nested type composition type.
235    NestedType,
236    /// Reference composition type.
237    Reference,
238    /// Smart pointer composition type.
239    SmartPointer,
240}
241
242impl From<crate::core::types::TypeRelationshipInfo> for TypeRelationshipInfo {
243    fn from(old: crate::core::types::TypeRelationshipInfo) -> Self {
244        Self {
245            type_name: old.type_name,
246            parent_types: old
247                .parent_types
248                .into_iter()
249                .map(|p| ParentTypeInfo {
250                    type_name: p.type_name,
251                    relationship_type: match p.relationship_type {
252                        crate::core::types::RelationshipType::TraitImplementation => {
253                            RelationshipType::TraitImplementation
254                        }
255                        crate::core::types::RelationshipType::TraitBound => {
256                            RelationshipType::TraitBound
257                        }
258                        crate::core::types::RelationshipType::Inheritance => {
259                            RelationshipType::Inheritance
260                        }
261                        crate::core::types::RelationshipType::Association => {
262                            RelationshipType::Association
263                        }
264                        crate::core::types::RelationshipType::Composition => {
265                            RelationshipType::Composition
266                        }
267                        crate::core::types::RelationshipType::Dependency => {
268                            RelationshipType::Dependency
269                        }
270                    },
271                    inheritance_level: p.inheritance_level,
272                    memory_impact: match p.memory_impact {
273                        crate::core::types::MemoryImpact::None => MemoryImpact::None,
274                        crate::core::types::MemoryImpact::SizeIncrease(s) => {
275                            MemoryImpact::SizeIncrease(s)
276                        }
277                        crate::core::types::MemoryImpact::AlignmentChange(s) => {
278                            MemoryImpact::AlignmentChange(s)
279                        }
280                        crate::core::types::MemoryImpact::LayoutChange(s) => {
281                            MemoryImpact::LayoutChange(s)
282                        }
283                    },
284                })
285                .collect(),
286            child_types: old
287                .child_types
288                .into_iter()
289                .map(|c| ChildTypeInfo {
290                    type_name: c.type_name,
291                    relationship_type: match c.relationship_type {
292                        crate::core::types::RelationshipType::TraitImplementation => {
293                            RelationshipType::TraitImplementation
294                        }
295                        crate::core::types::RelationshipType::TraitBound => {
296                            RelationshipType::TraitBound
297                        }
298                        crate::core::types::RelationshipType::Inheritance => {
299                            RelationshipType::Inheritance
300                        }
301                        crate::core::types::RelationshipType::Association => {
302                            RelationshipType::Association
303                        }
304                        crate::core::types::RelationshipType::Composition => {
305                            RelationshipType::Composition
306                        }
307                        crate::core::types::RelationshipType::Dependency => {
308                            RelationshipType::Dependency
309                        }
310                    },
311                    specialization_level: c.specialization_level,
312                    usage_frequency: c.usage_frequency,
313                })
314                .collect(),
315            composed_types: old
316                .composed_types
317                .into_iter()
318                .map(|c| ComposedTypeInfo {
319                    type_name: c.type_name,
320                    field_name: c.field_name,
321                    composition_type: match c.composition_type {
322                        crate::core::types::CompositionType::Field => CompositionType::Field,
323                        crate::core::types::CompositionType::AssociatedType => {
324                            CompositionType::AssociatedType
325                        }
326                        crate::core::types::CompositionType::GenericParameter => {
327                            CompositionType::GenericParameter
328                        }
329                        crate::core::types::CompositionType::NestedType => {
330                            CompositionType::NestedType
331                        }
332                        crate::core::types::CompositionType::Reference => {
333                            CompositionType::Reference
334                        }
335                        crate::core::types::CompositionType::SmartPointer => {
336                            CompositionType::SmartPointer
337                        }
338                    },
339                    memory_offset: c.memory_offset,
340                    access_frequency: c.access_frequency,
341                })
342                .collect(),
343            complexity_score: old.complexity_score,
344            inheritance_depth: old.inheritance_depth,
345            composition_breadth: old.composition_breadth,
346        }
347    }
348}
349
350impl From<crate::core::types::OwnershipNode> for OwnershipNode {
351    fn from(old: crate::core::types::OwnershipNode) -> Self {
352        Self {
353            object_id: old.object_id,
354            type_name: old.type_name,
355            ownership_type: match old.ownership_type {
356                crate::core::types::OwnershipType::Unique => OwnershipType::Unique,
357                crate::core::types::OwnershipType::SharedSingleThreaded => {
358                    OwnershipType::SharedSingleThreaded
359                }
360                crate::core::types::OwnershipType::SharedMultiThreaded => {
361                    OwnershipType::SharedMultiThreaded
362                }
363                crate::core::types::OwnershipType::Borrowed => OwnershipType::Borrowed,
364                crate::core::types::OwnershipType::Weak => OwnershipType::Weak,
365                crate::core::types::OwnershipType::Raw => OwnershipType::Raw,
366            },
367            owned_objects: old.owned_objects.into_iter().map(Into::into).collect(),
368            reference_count: old.reference_count,
369            weak_reference_count: old.weak_reference_count,
370        }
371    }
372}
373
374impl From<crate::core::types::OwnershipTransferEvent> for OwnershipTransferEvent {
375    fn from(old: crate::core::types::OwnershipTransferEvent) -> Self {
376        Self {
377            source_object: old.source_object,
378            target_object: old.target_object,
379            transfer_type: match old.transfer_type {
380                crate::core::types::OwnershipTransferType::Move => OwnershipTransferType::Move,
381                crate::core::types::OwnershipTransferType::Clone => OwnershipTransferType::Clone,
382                crate::core::types::OwnershipTransferType::Borrow => OwnershipTransferType::Borrow,
383                crate::core::types::OwnershipTransferType::ReferenceIncrement => {
384                    OwnershipTransferType::ReferenceIncrement
385                }
386                crate::core::types::OwnershipTransferType::ReferenceDecrement => {
387                    OwnershipTransferType::ReferenceDecrement
388                }
389            },
390            timestamp: old.timestamp,
391            mechanism: old.mechanism,
392        }
393    }
394}
395
396impl From<crate::core::types::WeakReferenceInfo> for WeakReferenceInfo {
397    fn from(old: crate::core::types::WeakReferenceInfo) -> Self {
398        Self {
399            weak_ref_id: old.weak_ref_id,
400            target_object_id: old.target_object_id,
401            weak_ref_type: match old.weak_ref_type {
402                crate::core::types::WeakReferenceType::RcWeak => WeakReferenceType::RcWeak,
403                crate::core::types::WeakReferenceType::ArcWeak => WeakReferenceType::ArcWeak,
404                crate::core::types::WeakReferenceType::Custom => WeakReferenceType::Custom,
405            },
406            target_alive: old.target_alive,
407            upgrade_attempts: old.upgrade_attempts,
408            successful_upgrades: old.successful_upgrades,
409        }
410    }
411}
412
413impl From<crate::core::types::CircularReferenceInfo> for CircularReferenceInfo {
414    fn from(old: crate::core::types::CircularReferenceInfo) -> Self {
415        Self {
416            cycle_objects: old.cycle_objects,
417            detection_timestamp: old.detection_timestamp,
418            cycle_type: match old.cycle_type {
419                crate::core::types::CircularReferenceType::Direct => CircularReferenceType::Direct,
420                crate::core::types::CircularReferenceType::Indirect => {
421                    CircularReferenceType::Indirect
422                }
423                crate::core::types::CircularReferenceType::SelfReferential => {
424                    CircularReferenceType::SelfReferential
425                }
426                crate::core::types::CircularReferenceType::Complex => {
427                    CircularReferenceType::Complex
428                }
429            },
430            leak_risk: match old.leak_risk {
431                crate::core::types::LeakRiskLevel::Low => LeakRiskLevel::Low,
432                crate::core::types::LeakRiskLevel::Medium => LeakRiskLevel::Medium,
433                crate::core::types::LeakRiskLevel::High => LeakRiskLevel::High,
434                crate::core::types::LeakRiskLevel::Critical => LeakRiskLevel::Critical,
435            },
436            resolution_suggestion: old.resolution_suggestion,
437        }
438    }
439}
440
441impl From<crate::core::types::OwnershipHierarchy> for OwnershipHierarchy {
442    fn from(old: crate::core::types::OwnershipHierarchy) -> Self {
443        Self {
444            root_owners: old.root_owners.into_iter().map(Into::into).collect(),
445            max_depth: old.max_depth,
446            total_objects: old.total_objects,
447            transfer_events: old.transfer_events.into_iter().map(Into::into).collect(),
448            weak_references: old.weak_references.into_iter().map(Into::into).collect(),
449            circular_references: old
450                .circular_references
451                .into_iter()
452                .map(Into::into)
453                .collect(),
454        }
455    }
456}
457
458#[cfg(test)]
459mod tests {
460    use super::*;
461
462    #[test]
463    fn test_ownership_hierarchy() {
464        let hierarchy = OwnershipHierarchy {
465            root_owners: vec![],
466            max_depth: 3,
467            total_objects: 10,
468            transfer_events: vec![],
469            weak_references: vec![],
470            circular_references: vec![],
471        };
472
473        assert_eq!(hierarchy.max_depth, 3);
474        assert_eq!(hierarchy.total_objects, 10);
475    }
476
477    #[test]
478    fn test_ownership_type() {
479        let ownership = OwnershipType::SharedMultiThreaded;
480        assert!(matches!(ownership, OwnershipType::SharedMultiThreaded));
481    }
482
483    #[test]
484    fn test_weak_reference_info() {
485        let weak_ref = WeakReferenceInfo {
486            weak_ref_id: 1,
487            target_object_id: 100,
488            weak_ref_type: WeakReferenceType::ArcWeak,
489            target_alive: true,
490            upgrade_attempts: 5,
491            successful_upgrades: 4,
492        };
493
494        assert_eq!(weak_ref.upgrade_attempts, 5);
495        assert!(weak_ref.target_alive);
496    }
497}
memscope_rs/capture/types/ownership.rs

memscope_rs/capture/types/
ownership.rs
