My Project
Data Structures | Public Member Functions | Private Member Functions | Private Attributes | Friends
vspace::Queue< T > Class Template Reference

#include <vspace.h>

Data Structures

struct  Node
 

Public Member Functions

 Queue (size_t bound=0)
 
void enqueue (T item)
 
bool try_enqueue (T item)
 
T dequeue ()
 
Result< Ttry_dequeue ()
 

Private Member Functions

VRef< Nodepop ()
 
void push (VRef< Node > node)
 
void enqueue_nowait (T item)
 
T dequeue_nowait ()
 

Private Attributes

Semaphore _incoming
 
Semaphore _outgoing
 
bool _bounded
 
FastLock _lock
 
VRef< Node_head
 
VRef< Node_tail
 

Friends

template<typename U >
class EnqueueEvent
 
template<typename U >
class DequeueEvent
 

Detailed Description

template<typename T>
class vspace::Queue< T >

Definition at line 1045 of file vspace.h.


Data Structure Documentation

◆ vspace::Queue::Node

struct vspace::Queue::Node
template<typename T>
struct vspace::Queue< T >::Node

Definition at line 1047 of file vspace.h.

Data Fields
T data
VRef< Node > next

Constructor & Destructor Documentation

◆ Queue()

template<typename T >
vspace::Queue< T >::Queue ( size_t  bound = 0)
inline

Definition at line 1100 of file vspace.h.

1100 :
1101 _incoming(0),
1103 _bounded(bound != 0),
1104 _head(),
1105 _tail(),
1106 _lock() {
1107 }
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
Semaphore _incoming
Definition: vspace.h:1051
Semaphore _outgoing
Definition: vspace.h:1052
bool _bounded
Definition: vspace.h:1053
VRef< Node > _head
Definition: vspace.h:1055
VRef< Node > _tail
Definition: vspace.h:1055
FastLock _lock
Definition: vspace.h:1054

Member Function Documentation

◆ dequeue()

template<typename T >
T vspace::Queue< T >::dequeue ( )
inline

Definition at line 1121 of file vspace.h.

1121 {
1122 _incoming.wait();
1123 return dequeue_nowait();
1124 }
T dequeue_nowait()
Definition: vspace.h:1087

◆ dequeue_nowait()

template<typename T >
T vspace::Queue< T >::dequeue_nowait ( )
inlineprivate

Definition at line 1087 of file vspace.h.

1087 {
1088 _lock.lock();
1089 VRef<Node> node = pop();
1090 T result;
1091 result = node->data;
1092 node.free();
1093 _lock.unlock();
1094 if (_bounded)
1095 _outgoing.post();
1096 return result;
1097 }
VRef< Node > pop()
Definition: vspace.h:1056
return result
Definition: facAbsBiFact.cc:75
STATIC_VAR jList * T
Definition: janet.cc:30

◆ enqueue()

template<typename T >
void vspace::Queue< T >::enqueue ( T  item)
inline

Definition at line 1108 of file vspace.h.

1108 {
1109 if (_bounded)
1110 _outgoing.wait();
1111 enqueue_nowait(item);
1112 }
void enqueue_nowait(T item)
Definition: vspace.h:1079

◆ enqueue_nowait()

template<typename T >
void vspace::Queue< T >::enqueue_nowait ( T  item)
inlineprivate

Definition at line 1079 of file vspace.h.

1079 {
1080 _lock.lock();
1081 VRef<Node> node = vnew<Node>();
1082 node->data = item;
1083 push(node);
1084 _lock.unlock();
1085 _incoming.post();
1086 }
void push(VRef< Node > node)
Definition: vspace.h:1065

◆ pop()

template<typename T >
VRef< Node > vspace::Queue< T >::pop ( )
inlineprivate

Definition at line 1056 of file vspace.h.

1056 {
1057 VRef<Node> result = _head;
1058 if (_head->next.is_null()) {
1059 _head = _tail = vnull<Node>();
1060 } else {
1061 _head = _head->next;
1062 }
1063 return result;
1064 }

◆ push()

template<typename T >
void vspace::Queue< T >::push ( VRef< Node node)
inlineprivate

Definition at line 1065 of file vspace.h.

1065 {
1066 node->next = vnull<Node>();
1067 if (_tail.is_null()) {
1068 _head = _tail = node;
1069 } else {
1070 _tail->next = node;
1071 _tail = node;
1072 }
1073 }

◆ try_dequeue()

template<typename T >
Result< T > vspace::Queue< T >::try_dequeue ( )
inline

Definition at line 1125 of file vspace.h.

1125 {
1126 if (_incoming.try_wait())
1127 return Result<T>(dequeue_nowait());
1128 else
1129 return Result<T>();
1130 }
bool try_wait()
Definition: vspace.cc:467

◆ try_enqueue()

template<typename T >
bool vspace::Queue< T >::try_enqueue ( T  item)
inline

Definition at line 1113 of file vspace.h.

1113 {
1114 if (_bounded && _outgoing.try_wait()) {
1115 enqueue_nowait(item);
1116 return true;
1117 } else {
1118 return false;
1119 }
1120 }

Friends And Related Function Documentation

◆ DequeueEvent

template<typename T >
template<typename U >
friend class DequeueEvent
friend

Definition at line 1077 of file vspace.h.

◆ EnqueueEvent

template<typename T >
template<typename U >
friend class EnqueueEvent
friend

Definition at line 1075 of file vspace.h.

Field Documentation

◆ _bounded

template<typename T >
bool vspace::Queue< T >::_bounded
private

Definition at line 1053 of file vspace.h.

◆ _head

template<typename T >
VRef<Node> vspace::Queue< T >::_head
private

Definition at line 1055 of file vspace.h.

◆ _incoming

template<typename T >
Semaphore vspace::Queue< T >::_incoming
private

Definition at line 1051 of file vspace.h.

◆ _lock

template<typename T >
FastLock vspace::Queue< T >::_lock
private

Definition at line 1054 of file vspace.h.

◆ _outgoing

template<typename T >
Semaphore vspace::Queue< T >::_outgoing
private

Definition at line 1052 of file vspace.h.

◆ _tail

template<typename T >
VRef<Node> vspace::Queue< T >::_tail
private

Definition at line 1055 of file vspace.h.


The documentation for this class was generated from the following file: