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),
1102  _outgoing(bound),
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: