s2e-systems / dust-dds Goto Github PK

use dust_dds::infrastructure::time::{Duration, DurationKind};

#[derive(serde::Serialize, serde::Deserialize, Debug)]
enum AltDurationKind {
    Finite(Duration),
    Infinite,
}

#[test]
fn duration_kind_serde() -> anyhow::Result<()> {
    let duration_kind = DurationKind::Finite(Duration::new(0, 0));
    let alt_duration_kind = AltDurationKind::Finite(Duration::new(0, 0));

    let serialized = bincode::serialize(&duration_kind)?;
    println!("bincode serialized normal: {serialized:?}");
    let result = bincode::deserialize::<DurationKind>(&serialized);
    println!("deserialized: {result:?}");

    let serialized = bincode::serialize(&alt_duration_kind)?;
    println!("bincode serialized alt: {serialized:?}");
    let result = bincode::deserialize::<AltDurationKind>(&serialized);
    println!("deserialized: {result:?}");

    let serialized = serde_json::to_string(&duration_kind)?;
    println!("json serialized normal: {serialized:?}");
    let result = serde_json::from_str::<DurationKind>(&serialized);
    println!("deserialized: {result:?}");

    let serialized = serde_json::to_string(&alt_duration_kind)?;
    println!("json serialized alt: {serialized:?}");
    let result = serde_json::from_str::<AltDurationKind>(&serialized);
    println!("deserialized: {result:?}");

    let serialized = ron::to_string(&duration_kind)?;
    println!("ron serialized normal: {serialized:?}");
    let result = ron::from_str::<DurationKind>(&serialized);
    println!("deserialized: {result:?}");

    let serialized = ron::to_string(&alt_duration_kind)?;
    println!("ron serialized alt: {serialized:?}");
    let result = ron::from_str::<AltDurationKind>(&serialized);
    println!("deserialized: {result:?}");

    Ok(())
}

use dust_dds::{
    dds_async::{topic::TopicAsync, topic_listener::TopicListenerAsync},
    infrastructure::status::InconsistentTopicStatus,
};
use dust_dds_derive::actor_interface;
pub struct TopicListenerActor {
    listener: Option<Box<dyn TopicListenerAsync + Send>>,
}

#[actor_interface]
impl TopicListenerActor {
    async fn on_inconsistent_topic(
        &mut self,
        the_topic: TopicAsync,
        status: InconsistentTopicStatus,
    ) {
        if let Some(l) = &mut self.listener {
            l.on_inconsistent_topic(the_topic, status).await
        }
    }
}

fn main() {
    println!("Hello, world!");
}

use common::dds_message::aos::transport::cyclone::DDSMessage;
use dust_dds::{
    domain::domain_participant_factory::DomainParticipantFactory,
    infrastructure::{listeners::NoOpListener, qos::QosKind, status::NO_STATUS},
};
#[tokio::main]
async fn main() {
    let domain_id = 0;
    let participant_factory = DomainParticipantFactory::get_instance();

    let participant = participant_factory
        .create_participant(domain_id, QosKind::Default, NoOpListener::new(), NO_STATUS)
        .unwrap();
}

use dust_dds::{
    domain::domain_participant::DomainParticipant,
    domain::domain_participant_factory::DomainParticipantFactory,
    infrastructure::{
        listeners::NoOpListener,
        qos::{DataReaderQos, QosKind},
        qos_policy::{
            DurabilityQosPolicy, DurabilityQosPolicyKind, ReliabilityQosPolicy,
            ReliabilityQosPolicyKind,
        },
        status::{StatusKind, NO_STATUS},
        time::{Duration, DurationKind},
        wait_set::{Condition, WaitSet},
    },
    subscription::sample_info::{ANY_INSTANCE_STATE, ANY_SAMPLE_STATE, ANY_VIEW_STATE},
    subscription::subscriber::Subscriber,
};

mod hello_world {
    include!("target/idl/hello_world.rs");
}

fn create_reader_task(
    topic_name: String,
    participant: &DomainParticipant,
    subscriber: &Subscriber,
) {
    println!("Begin to create reader task, topic[{topic_name}]");
    let topic = participant
        .find_topic::<hello_world::HelloWorldType>(&topic_name, Duration::new(120, 0))
        .unwrap();

    let reader_qos = DataReaderQos {
        reliability: ReliabilityQosPolicy {
            kind: ReliabilityQosPolicyKind::Reliable,
            max_blocking_time: DurationKind::Finite(Duration::new(1, 0)),
        },
        durability: DurabilityQosPolicy {
            kind: DurabilityQosPolicyKind::TransientLocal,
        },
        ..Default::default()
    };
    let reader = subscriber
        .create_datareader::<hello_world::HelloWorldType>(
            &topic,
            QosKind::Specific(reader_qos),
            NoOpListener::new(),
            NO_STATUS,
        )
        .unwrap();
    let topic_name_clone = topic_name.to_string();
    std::thread::spawn(move || {
        loop {
            let sample_result = reader.take_next_sample();
            if let Err(error) = sample_result {
                std::thread::sleep(std::time::Duration::from_millis(100));
                continue;
            }
            let message = sample_result.unwrap().data().unwrap();
            println!(
                "[{}] receive message, message[{:?}]",
                topic_name_clone, message
            );
            if topic_name_clone != message.msg {
                println!(
                    "========Topic confustion, reader_topic[{}] message_topic[{}]",
                    topic_name_clone, message.msg
                );
            }
            std::thread::sleep(std::time::Duration::from_millis(100));
        } // loop
    });
    println!("Succ to create reader task, topic[{topic_name}]");
}

fn main() {
    let domain_id = 0;
    let participant_factory = DomainParticipantFactory::get_instance();

    let participant = participant_factory
        .create_participant(domain_id, QosKind::Default, NoOpListener::new(), NO_STATUS)
        .unwrap();

    let subscriber = participant
        .create_subscriber(QosKind::Default, NoOpListener::new(), NO_STATUS)
        .unwrap();
    let topics = vec!["t1", "t2"];
    for topic_name in topics {
        create_reader_task(topic_name.to_string(), &participant, &subscriber);
    }

    // Sleep to allow sending acknowledgements
    loop {
        std::thread::sleep(std::time::Duration::from_secs(2));
    }
}

let writer_qos = DataWriterQos {
    reliability: ReliabilityQosPolicy {
        kind: ReliabilityQosPolicyKind::Reliable,
        max_blocking_time: DurationKind::Finite(Duration::new(1, 0)),
    },
    durability: DurabilityQosPolicy {
        kind: DurabilityQosPolicyKind::TransientLocal,
    },
    history: HistoryQosPolicy {
        kind: HistoryQosPolicyKind::KeepLast(1),
    },
    ..Default::default()
};

use dust_dds::{
    domain::domain_participant_factory::DomainParticipantFactory,
    infrastructure::{error::DdsResult, qos::QosKind},
};
use std::{thread, time::Duration};

fn main() -> DdsResult<()> {
    let participant = DomainParticipantFactory::get_instance().create_participant(
        0,
        QosKind::Default,
        None,
        &[],
    )?;
    loop {
        println!(
            "{:?}",
            participant
                .get_discovered_topics()?
                .into_iter()
                .map(|topic_handle| participant.get_discovered_topic_data(topic_handle).unwrap())
                .collect::<Vec<_>>()
        );
        thread::sleep(Duration::from_secs(1));
    }
}

use std::{thread, time::Duration};
use anyhow::Result;
use rustdds::DomainParticipant;

fn main() -> Result<()> {
    let participant = DomainParticipant::new(0)?;
    loop {
        println!("{:?}", participant.discovered_topics());
        thread::sleep(Duration::from_secs(1));
    }
}