vb6parse 1.2.1

vb6parse is a library for parsing and analyzing VB6 code, from projects, to controls, to modules, and forms.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Custom control properties.
//!
//! This module defines the `CustomControlProperties` struct, which represents
//! the properties of a custom control in a VB6 form. Custom controls are
//! non-standard controls that are not part of the standard VB6 controls, and
//! can include third-party controls and user-defined controls.
//!
//! The `CustomControlProperties` struct stores the properties of a custom
//! control in a `HashMap<String, String>`, where the keys are the property
//! names and the values are the property values.
//!
//! This struct is used as an enum variant of
//! [`ControlKind::CustomControl`](crate::language::controls::ControlKind::Custom).
//!
//! The `tag`, `name`, and `index` of the control are not included in this
//! struct, but are instead part of the parent
//! [`Control`](crate::language::controls::Control) struct.
//!

use crate::files::common::Properties;

use std::collections::HashMap;

/// Properties for a `Custom` control.
///
/// This is used to represent a non-standard control that is not part of the
/// standard VB6 controls. This can include third-party controls and user-defined
/// controls.
///
/// This is used as an enum variant of
/// [`ControlKind::CustomControl`](crate::language::controls::ControlKind::Custom).
/// tag, name, and index are not included in this struct, but instead are part
/// of the parent [`Control`](crate::language::controls::Control) struct.
#[derive(Debug, PartialEq, Clone, Default)]
pub struct CustomControlProperties {
    /// A store for the properties of the custom control.
    pub property_store: HashMap<String, String>,
}

impl serde::Serialize for CustomControlProperties {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;

        let mut state = serializer.serialize_struct("CustomControlProperties", 1)?;

        // Sort the properties by key for deterministic serialization
        let sorted_properties: std::collections::BTreeMap<_, _> =
            self.property_store.iter().collect();

        state.serialize_field("property_store", &sorted_properties)?;
        state.end()
    }
}

impl From<Properties> for CustomControlProperties {
    fn from(prop: Properties) -> Self {
        let mut custom_prop = CustomControlProperties::default();

        for (key, value) in &prop {
            custom_prop
                .property_store
                .insert(key.clone(), value.clone());
        }

        custom_prop
    }
}

impl CustomControlProperties {
    /// Get the number of properties in the custom control.
    #[must_use]
    pub fn len(&self) -> usize {
        self.property_store.len()
    }

    /// Check if the custom control has no properties.
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.property_store.is_empty()
    }
}