# 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_to_head(q) | q.add_at_head(c) | c enters q at the head |

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[0] 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
```