# Queue¶

Salabim has a class Queue for queue handling of components. The advantage over the standard list and deque are:

• double linked, resulting in easy and efficient insertion and deletion at any place
• builtin data collection and statistics
• priority sorting

Salabim uses queues internally for resources and states as well.

Definition of a queue is simple:

```waitingline=sim.Queue('waitingline')
```

The name of a queue can retrieved with `q.name()`.

There is a set of methods for components to enter and leave a queue and retrieval:

Component Queue Description
c.enter(q) q.add(c) or q.append(c) c enters q at the tail
c.enter_in_front(q, c1) q.add_in_front_of(c, c1) c enters q in front of c1
c.enter_behind(q, c1) q.add_behind(c, c1)` c enters q behind c1
c.enter_sorted(q, p) q.add_sorted(c, p) c enters q according to priority p
c.leave(q) q.remove(c) q.insert(c,i) q.pop() q.pop(i) q.head() or q q.tail() or q[-1] q.index(c) q.component_with_name(n) c leaves q insert c just before the i-th component in q removes head of q and returns it removes i-th component in q and returns it returns head of q returns tail of q returns the position of c in q returns the component with name n in q
c.successor(q) q.successor(c) successor of c in q
c.predecessor(q) q.predecessor(c) predecessor of c in q
c.count(q) q.count(c) returns 1 if c in q, 0 otherwise
c.queues()   returns a set with all queues where c is in
c.count() returns number of queues c is in

Queue is a standard ABC class, which means that the following methods are supported:

• `len(q)` to retrieve the length of a queue, alternatively via the level monitor with `q.length()`
• `c in q` to check whether a component is in a queue
• `for c in q:` to traverse a queue (Note that it is even possible to remove and add components in the for body).
• `reversed(q)` for the components in the queue in reverse order
• slicing is supported, so it is possible to get the 2nd, 3rd and 4th component in a queue with `q[1:4]` or `q[::-1]` for all elements in reverse order.
• `del q[i]` removes the i’th component. Also slicing is supported, so e.g. to delete the last three elements from queue, `del q[-1:-4:-1]`
• `q.append(c)` is equivalent to `q.add(c)`

It is possible to do a number of operations that work on the queues:

• `q.intersection(q1)` or `q & q1` returns a new queue with components that are both in q and q1
• `q.difference(q1)` or `q - q1`` returns a new queue with components that are in q1 but not in q2
• `q.union(q1)` or `q | q1` or `q + q1` returns a new queue with components that are in q or q1
• `q.symmetric_difference(q)` or `q ^ q1` returns a queue with components that are in q or q1, but not both
• `q.clear()` empties a queue
• `q.copy()` copies all components in q to a new queue. The queue q is untouched.
• `q.move()` copies all components in q to a new queue. The queue q is emptied.
• `q.extend(q1)` extends the q with elements in q1, that are not yet in q

Note that it is possible to rename a queue (particularly those created with +, -, ^, | or sum) with the rename() method:

```(q0 | q1 | q2 | q3).rename('q0 - q3).print_info()
```

Salabim keeps track of the enter time in a queue: `c.enter_time (q)`

Unless disabled explicitly, the length of the queue and length of stay of components are monitored in `q.length` and `q.length_of_stay`. It is possible to obtain a number of statistics on these monitors (cf. Monitor).

With `q.print_statistics()` the key statistics of these two monitors are printed.

E.g.:

```-------------------------------------------- -------------- ------------ ------------ ------------
Length of waitingline                        duration          50000        48499.381     1500.619
mean                  8.427        8.687
std.deviation         4.852        4.691

minimum               0            1
median                9           10
90% percentile       14           14
95% percentile       16           16
maximum              21           21

Length of stay in waitingline                entries            4995         4933           62
mean                 84.345       85.405
std.deviation        48.309       47.672

minimum               0            0.006
median               94.843       95.411
90% percentile      142.751      142.975
95% percentile      157.467      157.611
maximum             202.153      202.153
```

The arrival rate and departure rate (number of arrivals, departures per time unit) can be found with:

• q.arrival_rate()
• q.departur_rate()

With `q.print_info()` a summary of the contents of a queue can be printed.

E.g.

```Queue 0x20e116153c8
name=waitingline
component(s):
customer.4995        enter_time 49978.472 priority=0
customer.4996        enter_time 49991.298 priority=0
```