Dynamic type discovery question

[fhhowdy]

I'm looking at the test for iec61850.rs (https://github.com/librasn/rasn/blob/main/tests/iec61850.rs) and am trying to figure out the best way to map out the values for the all_data field.

Once the message is decoded, all data has a type of Vec<Data>.

However, this doesn't get to the underlying data or get them into a form (at least obvious to me) that I can iterate and operate on them. Is there a recommended way to iterate through the items of all_data, and take specific actions based on their type? (i.e. if you didn't know the data types at compile time?

Admittedly, I'm not deeply experienced with Rust and I'm trying to learn the language as well as the intricacies of the ber encoding/decoding process.

I've created a test file that looks like this:

use rasn::{types::*, Decode, Encode};

#[derive(AsnType, Decode, Encode, Debug, PartialEq)]
#[rasn(choice)]
enum IEC61850SpecificProtocol {
    GoosePdu(IECGoosePdu),
}

#[derive(AsnType, Decode, Encode, Debug, PartialEq)]
#[rasn(tag(application, 1))]
struct IECGoosePdu {
    #[rasn(tag(0))]
    gocb_ref: VisibleString,
    #[rasn(tag(1))]
    time_allowed_to_live: Integer,
    #[rasn(tag(2))]
    dat_set: VisibleString,
    #[rasn(tag(3))]
    go_id: Option<VisibleString>,
    #[rasn(tag(4))]
    t: UtcTime,
    #[rasn(tag(5))]
    st_num: Integer,
    #[rasn(tag(6))]
    sq_num: Integer,
    #[rasn(tag(7))]
    #[rasn(default)]
    simulation: bool,
    #[rasn(tag(8))]
    conf_rev: Integer,
    #[rasn(tag(9))]
    #[rasn(default)]
    nds_com: bool,
    #[rasn(tag(10))]
    num_dat_set_entries: Integer,
    #[rasn(tag(11))]
    all_data: Vec<Data>,
}

#[derive(AsnType, Decode, Encode, Debug, PartialEq)]
#[rasn(choice)]
enum Data {
    #[rasn(tag(1))]
    Array(DataSequence),
    #[rasn(tag(2))]
    Structure(DataSequence),
    #[rasn(tag(3))]
    Boolean(bool),
    #[rasn(tag(4))]
    BitString(BitString),
    #[rasn(tag(5))]
    Integer(Integer),
    #[rasn(tag(6))]
    Unsigned(Integer),
    #[rasn(tag(7))]
    FloatingPoint(FloatingPoint),
    #[rasn(tag(9))]
    OctetString(OctetString),
    #[rasn(tag(10))]
    VisibleString(VisibleString),
    #[rasn(tag(11))]
    GeneralizedTime(GeneralizedTime),
    #[rasn(tag(12))]
    BinaryTime(TimeOfDay),
    #[rasn(tag(13))]
    Bcd(Integer),
    #[rasn(tag(14))]
    BooleanArray(BitString),
    #[rasn(tag(15))]
    ObjId(ObjectIdentifier),
    #[rasn(tag(16))]
    MMSString(MMSString),
    #[rasn(tag(17))]
    UtcTime(UtcTime),
}

type DataSequence = Vec<Data>;

type FloatingPoint = OctetString;

type UtcTime = OctetString;

type MMSString = Utf8String;

type TimeOfDay = OctetString;

fn main() {
    it_works();
}

fn it_works() {
    let data = IECGoosePdu {
        gocb_ref: String::from("").try_into().unwrap(),
        time_allowed_to_live: 200.into(),
        dat_set: String::from("").try_into().unwrap(),
        go_id: Some(String::from("events").try_into().unwrap()),
        t: UtcTime::from(vec![]),
        st_num: 1.into(),
        sq_num: 1.into(),
        simulation: true,
        conf_rev: 1.into(),
        nds_com: false,
        num_dat_set_entries: 4.into(),
        all_data: vec![
            Data::Boolean(true),
            Data::Boolean(true),
            Data::Integer(200.into()),
        ],
    };

    for item in data.all_data {
        println!("data: {:?}", item); //**
    }
}

The println! can reveal to me the types and the value, but I'm not sure how to get at that from a programmatic perspective. Everything I've tried has failed, and looking at the debug information in RustRover and vsCode at the /** line hasn't revealed good hints.

Ideas?

[fhhowdy]

Ok -- I figured it out -- I figured I'd share in case anyone else needs the info:

for item in data.all_data {
        match item {
            Data::Boolean(val) => println!("data: Boolean({}) - Special message", val),
            Data::Array(_) => println!("data: Array"),
            Data::Structure(_) => println!("data: Structure"),
            Data::BitString(_) => println!("data: BitString"),
            Data::Integer(_) => println!("data: Integer"),
            Data::Unsigned(_) => println!("data: Unsigned"),
            Data::FloatingPoint(_) => println!("data: FloatingPoint"),
            Data::OctetString(_) => println!("data: OctetString"),
            Data::VisibleString(_) => println!("data: VisibleString"),
            Data::GeneralizedTime(_) => println!("data: GeneralizedTime"),
            Data::BinaryTime(_) => println!("data: BinaryTime"),
            Data::Bcd(_) => println!("data: Bcd"),
            Data::BooleanArray(_) => println!("data: BooleanArray"),
            Data::ObjId(_) => println!("data: ObjId"),
            Data::MMSString(_) => println!("data: MMSString"),
            Data::UtcTime(_) => println!("data: UtcTime"),
        }
    }