qubit-codec 0.14.0

Core codec traits and buffer conversion primitives for Rust
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// =============================================================================
//    Copyright (c) 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================
//! Owned output from a complete single-value decode lifecycle.

/// Values produced by decode reset, the main decode, and decode finish.
///
/// This result keeps lifecycle output in phase order without allowing finish
/// output to overwrite reset output.
///
/// # Type Parameters
///
/// - `V`: Logical value type produced by the codec.
///
/// # Examples
///
/// ```
/// use qubit_codec::DecodeLifecycleOutput;
///
/// fn inspect<V>(output: &DecodeLifecycleOutput<V>) -> usize {
///     output.reset().len() + output.finish().len()
/// }
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[must_use]
pub struct DecodeLifecycleOutput<V> {
    /// Values emitted while resetting decode state.
    reset: Vec<V>,
    /// Main value decoded from the supplied input.
    value: V,
    /// Values emitted while finishing decode state.
    finish: Vec<V>,
}

impl<V> DecodeLifecycleOutput<V> {
    /// Creates owned output from the three decode lifecycle phases.
    ///
    /// # Parameters
    ///
    /// - `reset`: Values emitted while resetting decode state.
    /// - `value`: Main value decoded from the supplied input.
    /// - `finish`: Values emitted while finishing decode state.
    ///
    /// # Returns
    ///
    /// Returns output preserving all three lifecycle phases.
    #[inline(always)]
    pub(crate) fn new(reset: Vec<V>, value: V, finish: Vec<V>) -> Self {
        Self { reset, value, finish }
    }

    /// Returns values emitted while resetting decode state.
    ///
    /// # Returns
    ///
    /// Returns the reset output in emission order.
    #[inline(always)]
    #[must_use]
    pub fn reset(&self) -> &[V] {
        &self.reset
    }

    /// Returns the main value decoded from the supplied input.
    ///
    /// # Returns
    ///
    /// Returns a shared reference to the main decoded value.
    #[inline(always)]
    #[must_use]
    pub const fn value(&self) -> &V {
        &self.value
    }

    /// Returns values emitted while finishing decode state.
    ///
    /// # Returns
    ///
    /// Returns the finish output in emission order.
    #[inline(always)]
    #[must_use]
    pub fn finish(&self) -> &[V] {
        &self.finish
    }

    /// Consumes this result and returns all lifecycle phases.
    ///
    /// # Returns
    ///
    /// Returns reset values, the main decoded value, and finish values.
    #[inline(always)]
    #[must_use]
    pub fn into_parts(self) -> (Vec<V>, V, Vec<V>) {
        (self.reset, self.value, self.finish)
    }
}