Struct ShapeType 

pub struct ShapeType {
    pub color: String,
    pub x: i32,
    pub y: i32,
    pub shapesize: i32,
}

RTI / Cyclone / Fast-DDS ShapesDemo-kompatibler Application-Type.

Siehe Modul-Doku fuer Spec und Layout. Farbe ist Instance-Key, x/y/shapesize sind die typischen Formen-Koordinaten.

Fields

color: String

Farbe / Instance-Key. In ShapesDemo-Implementierungen typisch "BLUE", "RED", "GREEN", "YELLOW", "MAGENTA", "CYAN", "ORANGE", "PURPLE". Keine inhaltliche Validierung hier — beliebige UTF-8-Strings sind zulaessig.

x: i32

X-Koordinate in Pixeln (ShapesDemo-Canvas ist ~240×270).

y: i32

Y-Koordinate.

shapesize: i32

Formen-Groesse in Pixeln. Typisch 30.

Implementations

impl ShapeType

pub fn new(color: impl Into<String>, x: i32, y: i32, shapesize: i32) -> Self

Konstruktor.

Examples found in repository

examples/zerodds_perf.rs (line 62)

fn run_pub(size: usize, runtime: Duration) -> Result<(), Box<dyn std::error::Error>> {
    let factory = DomainParticipantFactory::instance();
    let participant = factory.create_participant(0, DomainParticipantQos::default())?;
    let topic = participant.create_topic::<ShapeType>(PERF_TOPIC, TopicQos::default())?;
    let publisher = participant.create_publisher(PublisherQos::default());
    let writer = publisher.create_datawriter::<ShapeType>(&topic, DataWriterQos::default())?;

    // Discovery-Wait
    let _ = writer.wait_for_matched_subscription(1, Duration::from_secs(5));

    let payload_color = "X".repeat(size.saturating_sub(4 * 4)); // size minus i32-Felder approx
    let start = Instant::now();
    let mut total = 0u64;
    let mut last_report = start;
    let mut samples_since_report = 0u64;

    while start.elapsed() < runtime {
        let s = ShapeType::new(payload_color.clone(), 0, 0, total as i32);
        if writer.write(&s).is_ok() {
            total += 1;
            samples_since_report += 1;
        }
        // Report jede Sekunde
        if last_report.elapsed() >= Duration::from_secs(1) {
            let elapsed_s = last_report.elapsed().as_secs_f64();
            let rate_ks = (samples_since_report as f64 / elapsed_s) / 1000.0;
            let rate_mb =
                (samples_since_report as f64 * size as f64 * 8.0 / elapsed_s) / 1_000_000.0;
            println!(
                "{:.3}  size {} total {} rate {:.2} kS/s {:.2} Mb/s",
                start.elapsed().as_secs_f64(),
                size,
                total,
                rate_ks,
                rate_mb
            );
            last_report = Instant::now();
            samples_since_report = 0;
        }
    }
    println!(
        "# pub-done: total={total} runtime={:.3}s",
        start.elapsed().as_secs_f64()
    );
    Ok(())
}

fn run_sub(runtime: Duration) -> Result<(), Box<dyn std::error::Error>> {
    let factory = DomainParticipantFactory::instance();
    let participant = factory.create_participant(0, DomainParticipantQos::default())?;
    let topic = participant.create_topic::<ShapeType>(PERF_TOPIC, TopicQos::default())?;
    let subscriber = participant.create_subscriber(SubscriberQos::default());
    let reader = subscriber.create_datareader::<ShapeType>(&topic, DataReaderQos::default())?;

    let total = Arc::new(AtomicU64::new(0));
    let start = Instant::now();
    let mut last_report = start;
    let mut last_total = 0u64;

    while start.elapsed() < runtime {
        if let Ok(samples) = reader.take() {
            for _ in samples {
                total.fetch_add(1, Ordering::Relaxed);
            }
        }
        if last_report.elapsed() >= Duration::from_secs(1) {
            let now_total = total.load(Ordering::Relaxed);
            let delta = now_total - last_total;
            let elapsed_s = last_report.elapsed().as_secs_f64();
            let rate_ks = (delta as f64 / elapsed_s) / 1000.0;
            println!(
                "{:.3}  size N total {} delta {} rate {:.2} kS/s",
                start.elapsed().as_secs_f64(),
                now_total,
                delta,
                rate_ks
            );
            last_report = Instant::now();
            last_total = now_total;
        }
        std::thread::sleep(Duration::from_millis(1));
    }
    println!(
        "# sub-done: total={} runtime={:.3}s",
        total.load(Ordering::Relaxed),
        start.elapsed().as_secs_f64()
    );
    Ok(())
}

fn run_pingpong(runtime: Duration) -> Result<(), Box<dyn std::error::Error>> {
    // Beide Rollen in einem Prozess via zwei Topics; Pinger schreibt
    // PerfPing (mit "send-time"-Marker als shapesize-i32-Diff), Ponger
    // (zweiter Prozess) liest und echot auf PerfPong. Dieser Prozess
    // ist der PINGER.
    let factory = DomainParticipantFactory::instance();
    let participant = factory.create_participant(0, DomainParticipantQos::default())?;
    let ping_topic = participant.create_topic::<ShapeType>(PING_TOPIC, TopicQos::default())?;
    let pong_topic = participant.create_topic::<ShapeType>(PONG_TOPIC, TopicQos::default())?;
    let publisher = participant.create_publisher(PublisherQos::default());
    let subscriber = participant.create_subscriber(SubscriberQos::default());
    let writer = publisher.create_datawriter::<ShapeType>(&ping_topic, DataWriterQos::default())?;
    let reader =
        subscriber.create_datareader::<ShapeType>(&pong_topic, DataReaderQos::default())?;

    let _ = writer.wait_for_matched_subscription(1, Duration::from_secs(5));
    let _ = reader.wait_for_matched_publication(1, Duration::from_secs(5));

    let mut rtts_us: Vec<u64> = Vec::new();
    let start = Instant::now();
    let mut seq = 0i32;
    while start.elapsed() < runtime {
        let send_us = now_micros();
        // shapesize codiert die unteren 32 bit von send_us als pseudo-id
        // (kollisionsanfaellig, aber nur fuer matching im Pong); echte
        // RTT-Berechnung passiert lokal via timestamp-storage.
        let _ = writer.write(&ShapeType::new("PING", 0, 0, seq));
        seq = seq.wrapping_add(1);

        // Wartet bis 50ms auf Pong
        let deadline = Instant::now() + Duration::from_millis(50);
        while Instant::now() < deadline {
            if let Ok(samples) = reader.take() {
                for s in samples {
                    if s.color == "PONG" && s.shapesize == seq.wrapping_sub(1) {
                        let recv_us = now_micros();
                        rtts_us.push(recv_us - send_us);
                        break;
                    }
                }
                if !rtts_us.is_empty() && rtts_us.last().is_some() {
                    break;
                }
            }
            std::thread::sleep(Duration::from_micros(100));
        }
        std::thread::sleep(Duration::from_millis(100)); // 10Hz ping rate
    }

    if rtts_us.is_empty() {
        println!("# pingpong: no RTTs collected — pong missing?");
        return Ok(());
    }
    rtts_us.sort_unstable();
    let n = rtts_us.len();
    let mean = rtts_us.iter().sum::<u64>() / n as u64;
    let p50 = rtts_us[n / 2];
    let p90 = rtts_us[(n * 9) / 10];
    let p99 = rtts_us[(n * 99) / 100];
    println!(
        "{:.3}  rtt mean {}us min {} 50% {} 90% {} 99% {} max {} cnt {}",
        start.elapsed().as_secs_f64(),
        mean,
        rtts_us.first().copied().unwrap_or(0),
        p50,
        p90,
        p99,
        rtts_us.last().copied().unwrap_or(0),
        n
    );
    Ok(())
}

fn run_pong(runtime: Duration) -> Result<(), Box<dyn std::error::Error>> {
    // Liest PerfPing, schreibt PerfPong mit gleichem shapesize.
    let factory = DomainParticipantFactory::instance();
    let participant = factory.create_participant(0, DomainParticipantQos::default())?;
    let ping_topic = participant.create_topic::<ShapeType>(PING_TOPIC, TopicQos::default())?;
    let pong_topic = participant.create_topic::<ShapeType>(PONG_TOPIC, TopicQos::default())?;
    let publisher = participant.create_publisher(PublisherQos::default());
    let subscriber = participant.create_subscriber(SubscriberQos::default());
    let reader =
        subscriber.create_datareader::<ShapeType>(&ping_topic, DataReaderQos::default())?;
    let writer = publisher.create_datawriter::<ShapeType>(&pong_topic, DataWriterQos::default())?;
    let _ = writer.wait_for_matched_subscription(1, Duration::from_secs(5));
    let _ = reader.wait_for_matched_publication(1, Duration::from_secs(5));

    let start = Instant::now();
    let mut echoed = 0u64;
    while start.elapsed() < runtime {
        if let Ok(samples) = reader.take() {
            for s in samples {
                if s.color == "PING" {
                    let _ = writer.write(&ShapeType::new("PONG", s.x, s.y, s.shapesize));
                    echoed += 1;
                }
            }
        }
        std::thread::sleep(Duration::from_micros(100));
    }
    println!(
        "# pong-done: echoed={echoed} runtime={:.3}s",
        start.elapsed().as_secs_f64()
    );
    Ok(())
}

examples/shapes_demo_publisher.rs (line 63)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<String> = env::args().collect();
    let topic_name = args.get(1).map_or("Square", String::as_str);
    let color = args.get(2).map_or("BLUE", String::as_str);
    let domain_id: i32 = args.get(3).and_then(|s| s.parse().ok()).unwrap_or(0);

    if !["Square", "Circle", "Triangle"].contains(&topic_name) {
        eprintln!(
            "warning: topic '{topic_name}' ist kein Standard-ShapesDemo-Topic (Square/Circle/Triangle)",
        );
    }

    let factory = DomainParticipantFactory::instance();
    let participant = factory.create_participant(domain_id, DomainParticipantQos::default())?;
    let topic = participant.create_topic::<ShapeType>(topic_name, TopicQos::default())?;
    let publisher = participant.create_publisher(PublisherQos::default());
    let writer = publisher.create_datawriter::<ShapeType>(&topic, DataWriterQos::default())?;

    println!(
        "shapes_demo_publisher: Topic={topic_name} Color={color} Domain={domain_id} — Ctrl-C to stop"
    );

    // Discovery-Wait — bis mindestens 1 Subscriber gematched hat.
    let matched = writer.wait_for_matched_subscription(1, Duration::from_secs(10));
    match matched {
        Ok(()) => println!("matched subscriber found, starting publication"),
        Err(_) => println!("no subscriber in 10s — publishing anyway, samples may drop"),
    }

    // Sinus-Bewegung auf 240x270-Canvas (ShapesDemo-Default).
    let shapesize = 30;
    let mut t: f32 = 0.0;
    loop {
        let x = (120.0 + 80.0 * (t).sin()) as i32;
        let y = (135.0 + 90.0 * (t * 1.3).cos()) as i32;
        let sample = ShapeType::new(color, x, y, shapesize);
        writer.write(&sample)?;
        println!("  -> color={color} x={x} y={y} size={shapesize}");
        t += 0.15;
        thread::sleep(Duration::from_millis(100));
    }
}

examples/multi_endpoint_perf.rs (line 60)

fn run_pub_n(count: usize, runtime: Duration) -> Result<(), Box<dyn std::error::Error>> {
    let factory = DomainParticipantFactory::instance();
    let participant = factory.create_participant(0, DomainParticipantQos::default())?;
    let publisher = participant.create_publisher(PublisherQos::default());

    let mut writers = Vec::with_capacity(count);
    println!("[multi_pub] creating {count} writers");
    let create_start = Instant::now();
    for i in 0..count {
        let topic = participant.create_topic::<ShapeType>(&topic_name(i), TopicQos::default())?;
        let writer = publisher.create_datawriter::<ShapeType>(&topic, DataWriterQos::default())?;
        writers.push(writer);
    }
    println!(
        "[multi_pub] created {count} writers in {:.2}s",
        create_start.elapsed().as_secs_f64()
    );

    let start = Instant::now();
    let mut tick = 0u64;
    let mut total_writes = 0u64;
    while start.elapsed() < runtime {
        let tick_start = Instant::now();
        for (i, w) in writers.iter().enumerate() {
            let s = ShapeType::new(format!("MEP{i:04}"), tick as i32, 0, 30);
            if w.write(&s).is_ok() {
                total_writes += 1;
            }
        }
        tick += 1;
        // 1 Hz pro Writer — schlaeft bis zur naechsten Sekunde
        if tick % 60 == 0 {
            println!(
                "{:.3}  multi_pub tick={} writers={} total_writes={} loop_us={}",
                start.elapsed().as_secs_f64(),
                tick,
                count,
                total_writes,
                tick_start.elapsed().as_micros()
            );
        }
        let elapsed = tick_start.elapsed();
        if elapsed < Duration::from_secs(1) {
            std::thread::sleep(Duration::from_secs(1) - elapsed);
        }
    }
    println!(
        "# multi_pub-done: writers={count} total_writes={} runtime={:.3}s",
        total_writes,
        start.elapsed().as_secs_f64()
    );
    Ok(())
}

Trait Implementations

impl Clone for ShapeType

fn clone(&self) -> ShapeType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DdsType for ShapeType

const TYPE_NAME: &'static str = "ShapeType"

Type-Name exakt wie RTI/Cyclone/Fast-DDS ShapesDemo. Aendern wuerde Matching mit jedem anderen ShapesDemo-Client brechen.

const HAS_KEY: bool = true

ShapesDemo-IDL: @key string color. ShapeType ist keyed — Per-Instance-QoS (TimeBasedFilter, Ownership, Lifecycle) haengt davon ab.

fn encode_key_holder_be(&self, holder: &mut PlainCdr2BeKeyHolder)

Serialisiert die @key-Member-Werte im PLAIN_CDR2-BE-Format in den uebergebenen PlainCdr2BeKeyHolder. Reihenfolge: nach member_id aufsteigend (XTypes 1.3 §7.6.8.3.1.b).

fn encode(&self, out: &mut Vec<u8>) -> Result<(), EncodeError>

Serialisiert self in den XCDR2-Payload, der in einer DATA-Submessage als serialized_payload gesendet wird. Default-Endianness: Little-Endian (RTPS 2.5 §10.5 RepresentationIdentifier = CDR2_LE = 0x0010).

fn decode(bytes: &[u8]) -> Result<Self, DecodeError>

Deserialisiert einen XCDR2-Payload. Der Caller stellt sicher, dass bytes den vollen Sample-Payload enthaelt.

const EXTENSIBILITY: Extensibility = Extensibility::Final

XTypes 1.3 §7.4.5 Struct-Extensibility-Kind. Default Final fuer Backwards-Kompat zu pre-EXTENSIBILITY-Codegen-Outputs. Spec: zerodds-xcdr2-rust §2.3.

const IS_KEYED: bool = Self::HAS_KEY

Spec-aligned Alias fuer Self::HAS_KEY. zerodds-xcdr2-rust §2 referenziert das als IS_KEYED.

const KEY_HOLDER_MAX_SIZE: Option<usize> = None

Maximale Groesse des PLAIN_CDR2-BE-KeyHolder-Streams in Bytes (XTypes 1.3 §7.6.8.4 Step 5). None = nicht keyed oder unbounded (MD5-Pfad). Some(n) mit n <= 16 = zero-pad-Pfad.

const IS_NESTED: bool = false

true wenn der Type mit @nested annotiert ist (XTypes 1.3 §7.4.6.3.5). Nested-Types sind nur als Member anderer Types gedacht und MUESSEN nicht als DDS-Topic-Type registriert werden. DomainParticipant::create_topic lehnt registration von nested-Types mit PreconditionNotMet ab.

const TYPE_IDENTIFIER: TypeIdentifier = zerodds_types::TypeIdentifier::None

XTypes 1.3 §7.3.4.2 — TypeIdentifier des Types fuer XTypes-aware Discovery + Compatibility-Matching. Default TypeIdentifier::None signalisiert “type-id nicht bereitgestellt; Reader-Writer-Match faellt zurueck auf reinen type_name-Vergleich (DDS 1.4 §2.2.3 Default-Path)”.

fn encode_be(&self, out: &mut Vec<u8>) -> Result<(), EncodeError>

Big-Endian-Variante von Self::encode. Default-Implementation delegiert auf Self::encode (kein Byte-Swap), da generischer BE-Re-Encode ohne Type-Reflection nicht moeglich ist. Codegen ueberschreibt das fuer Strukturen, die echt BE auf die Wire gehen sollen. Spec: zerodds-xcdr2-rust §2.4.

fn field_value(&self, _path: &str) -> Option<Value>

Liefert den Wert eines Feldpfads (dotted, z.B. "a.b") als zerodds_sql_filter::Value fuer SQL-Filter-Evaluation in QueryCondition / ContentFilteredTopic. Default: None (kein Feld erreichbar — der Filter denied dann jedes Sample, sofern es einen Feldzugriff enthaelt).

fn compute_key_hash(&self) -> Option<[u8; 16]>

Berechnet den 16-Byte KeyHash dieser Instanz nach XTypes 1.3 §7.6.8.4. None wenn HAS_KEY = false.

fn key_hash(&self) -> Option<[u8; 16]>

Spec-aligned Alias fuer Self::compute_key_hash. zerodds-xcdr2-rust §2.5 nutzt den Namen key_hash; der Implementations-Name behaelt compute_key_hash aus historischer Kompat. Beide liefern denselben Wert.

impl Debug for ShapeType

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

Formats the value using the given formatter.

impl PartialEq for ShapeType

fn eq(&self, other: &ShapeType) -> 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 Eq for ShapeType

impl StructuralPartialEq for ShapeType