aishell example

游雁

2024-02-19 94de39dde2e616a01683c518023d0fab72b4e103

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
#ifndef LIMONP_BOUNDED_BLOCKING_QUEUE_HPP
#define LIMONP_BOUNDED_BLOCKING_QUEUE_HPP
 
#include "BoundedQueue.hpp"
 
namespace limonp {
 
template<typename T>
class BoundedBlockingQueue : NonCopyable {
 public:
  explicit BoundedBlockingQueue(size_t maxSize)
    : mutex_(),
      notEmpty_(mutex_),
      notFull_(mutex_),
      queue_(maxSize) {
  }
 
  void Push(const T& x) {
    MutexLockGuard lock(mutex_);
    while (queue_.Full()) {
      notFull_.Wait();
    }
    assert(!queue_.Full());
    queue_.Push(x);
    notEmpty_.Notify();
  }
 
  T Pop() {
    MutexLockGuard lock(mutex_);
    while (queue_.Empty()) {
      notEmpty_.Wait();
    }
    assert(!queue_.Empty());
    T res = queue_.Pop();
    notFull_.Notify();
    return res;
  }
 
  bool Empty() const {
    MutexLockGuard lock(mutex_);
    return queue_.Empty();
  }
 
  bool Full() const {
    MutexLockGuard lock(mutex_);
    return queue_.Full();
  }
 
  size_t size() const {
    MutexLockGuard lock(mutex_);
    return queue_.size();
  }
 
  size_t capacity() const {
    return queue_.capacity();
  }
 
 private:
  mutable MutexLock          mutex_;
  Condition                  notEmpty_;
  Condition                  notFull_;
  BoundedQueue<T>  queue_;
}; // class BoundedBlockingQueue
 
} // namespace limonp
 
#endif // LIMONP_BOUNDED_BLOCKING_QUEUE_HPP