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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use super::submission::{Submission, SubmissionId};

/// Queue id.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct QueueId {
    /// Family id of the queue.
    pub family: rendy_core::hal::queue::QueueFamilyId,

    /// Index of the queue.
    pub index: usize,
}

impl QueueId {
    /// Create queue id from family id and index.
    pub fn new(family: rendy_core::hal::queue::QueueFamilyId, index: usize) -> Self {
        QueueId {
            family: family,
            index,
        }
    }

    /// Get family id.
    pub fn family(&self) -> rendy_core::hal::queue::QueueFamilyId {
        self.family
    }

    /// Get index within the family.
    pub fn index(&self) -> usize {
        self.index
    }
}

/// Instances of this type contains array of `Submission`s.
/// Those submissions are expected to be submitted in order.
#[derive(Clone, Debug)]
pub struct Queue<S> {
    id: QueueId,
    submissions: Vec<Submission<S>>,
}

impl<S> Queue<S> {
    /// Create new queue with specified id.
    pub fn new(id: QueueId) -> Self {
        Queue {
            id,
            submissions: Vec::new(),
        }
    }

    /// Get id of the queue.
    pub fn id(&self) -> QueueId {
        self.id
    }

    /// Iterate over immutable references to each submission in this queue
    pub fn iter(&self) -> impl Iterator<Item = &Submission<S>> {
        self.submissions.iter()
    }

    /// Iterate over mutable references to each submission in this queue
    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Submission<S>> {
        self.submissions.iter_mut()
    }

    // /// Iterate over mutable references to each submission in this queue
    // pub fn into_iter(self) -> QueueIntoIter<S> {
    //     QueueIntoIter {
    //         qid: self.id,
    //         iter: self.submissions.into_iter().enumerate(),
    //     }
    // }

    /// Get the number of submissions in queue.
    pub fn len(&self) -> usize {
        self.submissions.len()
    }

    /// Get reference to `Submission` instance by id.
    ///
    /// # Panic
    ///
    /// This function will panic if requested submission isn't part of this queue.
    ///
    pub fn submission(&self, sid: SubmissionId) -> Option<&Submission<S>> {
        assert_eq!(self.id, sid.queue());
        self.submissions.get(sid.index())
    }

    /// Get mutable reference to `Submission` instance by id.
    ///
    /// # Panic
    ///
    /// This function will panic if requested submission isn't part of this queue.
    ///
    pub fn submission_mut(&mut self, sid: SubmissionId) -> Option<&mut Submission<S>> {
        assert_eq!(self.id, sid.queue());
        self.submissions.get_mut(sid.index())
    }

    // /// Get reference to last `Submission` instance.
    // pub fn last_submission(&self) -> Option<&Submission<S>> {
    //     self.submissions.last()
    // }

    // /// Get mutable reference to last `Submission` instance.
    // pub fn last_submission_mut(&mut self) -> Option<&mut Submission<S>> {
    //     self.submissions.last_mut()
    // }

    /// Add `Submission` instance to the end of queue.
    /// Returns id of the added submission.
    pub fn add_submission(
        &mut self,
        node: usize,
        wait_factor: usize,
        submit_order: usize,
        sync: S,
    ) -> SubmissionId {
        let sid = SubmissionId::new(self.id, self.submissions.len());
        self.submissions
            .push(Submission::new(node, wait_factor, submit_order, sid, sync));
        sid
    }

    /// Add `Submission` instance to the end of queue.
    /// Check that submission has correct id.
    pub fn add_submission_checked(&mut self, submission: Submission<S>) {
        assert_eq!(
            submission.id(),
            SubmissionId::new(self.id, self.submissions.len())
        );
        self.submissions.push(submission);
    }
}