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

extern crate lossyq;
extern crate libc;

pub mod scheduler;
pub mod elem;

// re-exports
pub use lossyq::spsc::{Sender,Receiver};
pub use elem::{source, sink, filter, scatter, gather, ymerge, ysplit, connectable};
pub use scheduler::Scheduler;

#[derive(Copy, Clone, Debug)]
pub enum ChannelState {
  ReceiverNotConnected,
  ConnectedReceiver,
  SenderNotConnected,
  ConnectedSender,
}

#[derive(Copy, Clone, Debug)]
pub struct ExpectedChannelState (pub ChannelState);

#[derive(Copy, Clone, Debug)]
pub struct ActualChannelState (pub ChannelState);

#[derive(Copy, Clone, Debug)]
pub enum Error {
  Busy,
  NonExistent,
  Stopping,
  AlreadyExists,
  InvalidChannelState(ExpectedChannelState, ActualChannelState)
}

#[derive(Copy,Clone,Debug,PartialEq,Eq)]
pub struct InclusiveMessageRange {
  pub from: usize,
  pub to:   usize,
}

#[derive(Copy,Clone,Debug,PartialEq,Eq)]
pub struct ChannelPosition (pub usize);

#[derive(Copy, Clone,Debug)]
pub enum Message<ValueType: Send, ErrorType: Send> {
  Value(ValueType),
  Ack(InclusiveMessageRange),
  Error(ChannelPosition, ErrorType),
}

#[derive(Copy,Clone,Debug,PartialEq,Eq)]
pub struct SenderChannelId (pub usize);

#[derive(Copy,Clone,Debug,PartialEq,Eq)]
pub struct ReceiverChannelId (pub usize);

#[derive(Copy,Clone,Debug,PartialEq,Eq)]
pub struct ChannelId {
  pub sender_id:    SenderChannelId,
  pub receiver_id:  ReceiverChannelId,
}

#[derive(Copy,Clone,Debug,PartialEq,Eq)]
pub struct PeriodLengthInUsec (pub usize);

#[derive(Copy,Clone,Debug)]
pub enum SchedulingRule {
  Loop,
  OnMessage,
  Periodic(PeriodLengthInUsec),
  OnExternalEvent,
}

#[derive(Copy,Clone,Debug,PartialEq,Eq,Hash)]
pub struct TaskId (usize);


#[derive(Clone,Debug,PartialEq,Eq)]
pub struct SenderName (pub String);

#[derive(Clone,Debug,PartialEq,Eq)]
pub struct ReceiverName (pub String);

pub trait Task {
  fn execute(&mut self, stop: &mut bool);
  fn name(&self) -> &String;
  fn input_count(&self) -> usize;
  fn output_count(&self) -> usize;
  fn input_id(&self, ch_id: ReceiverChannelId) -> Option<(ChannelId, SenderName)>;
  fn input_channel_pos(&self, ch_id: ReceiverChannelId) -> ChannelPosition;
  fn output_channel_pos(&self, ch_id: SenderChannelId) -> ChannelPosition;
}

pub enum ChannelWrapper<Value: Send, Error: Send> {
  ReceiverNotConnected(ReceiverChannelId, ReceiverName),
  ConnectedReceiver(ChannelId, Receiver<Message<Value, Error>>, SenderName),
  SenderNotConnected(SenderChannelId, Receiver<Message<Value, Error>>, SenderName),
  ConnectedSender(ChannelId, ReceiverName),
}

#[cfg(test)]
pub mod tests;

#[cfg(any(test, feature = "bench"))]
pub mod sample;

#[cfg(any(test, feature = "bench"))]
pub mod bench;