template<typename T, size_t N>
class RingBuffer {
std::array<T, N> buf_;
size_t head_ = 0, tail_ = 0, count_ = 0;
public:
bool push(const T& val) {
if (count_ == N) return false;
buf_[tail_] = val;
tail_ = (tail_ + 1) % N;
++count_;
return true;
}
std::optional<T> pop() {
if (count_ == 0) return std::nullopt;
T val = std::move(buf_[head_]);
head_ = (head_ + 1) % N;
--count_;
return val;
}
};
@dataclass
class BatchProcessor:
queue: asyncio.Queue = field(default_factory=asyncio.Queue)
batch_size: int = 32
workers: int = 4
async def process(self, items):
for item in items:
await self.queue.put(item)
tasks = [
asyncio.create_task(self._worker(i))
for i in range(self.workers)
]
await self.queue.join()
for t in tasks:
t.cancel()
template<typename K, typename V>
class LRUCache {
struct Node { K key; V value; Node *prev, *next; };
std::unordered_map<K, Node*> map_;
void move_to_front(Node* node) {
if (node == head_) return;
if (node->prev) node->prev->next = node->next;
if (node->next) node->next->prev = node->prev;
if (node == tail_) tail_ = node->prev;
node->next = head_;
node->prev = nullptr;
if (head_) head_->prev = node;
head_ = node;
}
};
template<typename T, size_t N>
class RingBuffer {
std::array<T, N> buf_;
size_t head_ = 0, tail_ = 0, count_ = 0;
public:
bool push(const T& val) {
if (count_ == N) return false;
buf_[tail_] = val;
tail_ = (tail_ + 1) % N;
++count_;
return true;
}
std::optional<T> pop() {
if (count_ == 0) return std::nullopt;
T val = std::move(buf_[head_]);
head_ = (head_ + 1) % N;
--count_;
return val;
}
};
@dataclass
class BatchProcessor:
queue: asyncio.Queue = field(default_factory=asyncio.Queue)
batch_size: int = 32
workers: int = 4
async def process(self, items):
for item in items:
await self.queue.put(item)
tasks = [
asyncio.create_task(self._worker(i))
for i in range(self.workers)
]
await self.queue.join()
for t in tasks:
t.cancel()
template<typename K, typename V>
class LRUCache {
struct Node { K key; V value; Node *prev, *next; };
std::unordered_map<K, Node*> map_;
void move_to_front(Node* node) {
if (node == head_) return;
if (node->prev) node->prev->next = node->next;
if (node->next) node->next->prev = node->prev;
if (node == tail_) tail_ = node->prev;
node->next = head_;
node->prev = nullptr;
if (head_) head_->prev = node;
head_ = node;
}
};
impl ConnectionPool {
async fn acquire(&self) -> Result<Connection> {
let pool = self.inner.lock().await;
match pool.connections.pop() {
Some(conn) => Ok(conn),
None if pool.len() < self.max_size => {
self.create_connection().await
}
None => Err(PoolExhausted),
}
}
}
fn quicksort<T: Ord>(arr: &mut [T]) {
if arr.len() <= 1 { return; }
let pivot = partition(arr);
quicksort(&mut arr[..pivot]);
quicksort(&mut arr[pivot + 1..]);
}
template<typename T, size_t N>
class RingBuffer {
std::array<T, N> buf_;
size_t head_ = 0, tail_ = 0, count_ = 0;
public:
bool push(const T& val) {
if (count_ == N) return false;
buf_[tail_] = val;
tail_ = (tail_ + 1) % N;
++count_;
return true;
}
std::optional<T> pop() {
if (count_ == 0) return std::nullopt;
T val = std::move(buf_[head_]);
head_ = (head_ + 1) % N;
--count_;
return val;
}
};
@dataclass
class BatchProcessor:
queue: asyncio.Queue = field(default_factory=asyncio.Queue)
batch_size: int = 32
workers: int = 4
async def process(self, items):
for item in items:
await self.queue.put(item)
tasks = [
asyncio.create_task(self._worker(i))
for i in range(self.workers)
]
await self.queue.join()
for t in tasks:
t.cancel()
impl ConnectionPool {
async fn acquire(&self) -> Result<Connection> {
let pool = self.inner.lock().await;
match pool.connections.pop() {
Some(conn) => Ok(conn),
None if pool.len() < self.max_size => {
self.create_connection().await
}
None => Err(PoolExhausted),
}
}
}
fn quicksort<T: Ord>(arr: &mut [T]) {
if arr.len() <= 1 { return; }
let pivot = partition(arr);
quicksort(&mut arr[..pivot]);
quicksort(&mut arr[pivot + 1..]);
}
template<typename T, size_t N>
class RingBuffer {
std::array<T, N> buf_;
size_t head_ = 0, tail_ = 0, count_ = 0;
public:
bool push(const T& val) {
if (count_ == N) return false;
buf_[tail_] = val;
tail_ = (tail_ + 1) % N;
++count_;
return true;
}
std::optional<T> pop() {
if (count_ == 0) return std::nullopt;
T val = std::move(buf_[head_]);
head_ = (head_ + 1) % N;
--count_;
return val;
}
};
@dataclass
class BatchProcessor:
queue: asyncio.Queue = field(default_factory=asyncio.Queue)
batch_size: int = 32
workers: int = 4
async def process(self, items):
for item in items:
await self.queue.put(item)
tasks = [
asyncio.create_task(self._worker(i))
for i in range(self.workers)
]
await self.queue.join()
for t in tasks:
t.cancel()
@dataclass
class BatchProcessor:
queue: asyncio.Queue = field(default_factory=asyncio.Queue)
batch_size: int = 32
workers: int = 4
async def process(self, items):
for item in items:
await self.queue.put(item)
tasks = [
asyncio.create_task(self._worker(i))
for i in range(self.workers)
]
await self.queue.join()
for t in tasks:
t.cancel()
template<typename K, typename V>
class LRUCache {
struct Node { K key; V value; Node *prev, *next; };
std::unordered_map<K, Node*> map_;
void move_to_front(Node* node) {
if (node == head_) return;
if (node->prev) node->prev->next = node->next;
if (node->next) node->next->prev = node->prev;
if (node == tail_) tail_ = node->prev;
node->next = head_;
node->prev = nullptr;
if (head_) head_->prev = node;
head_ = node;
}
};
impl ConnectionPool {
async fn acquire(&self) -> Result<Connection> {
let pool = self.inner.lock().await;
match pool.connections.pop() {
Some(conn) => Ok(conn),
None if pool.len() < self.max_size => {
self.create_connection().await
}
None => Err(PoolExhausted),
}
}
}
fn quicksort<T: Ord>(arr: &mut [T]) {
if arr.len() <= 1 { return; }
let pivot = partition(arr);
quicksort(&mut arr[..pivot]);
quicksort(&mut arr[pivot + 1..]);
}
@dataclass
class BatchProcessor:
queue: asyncio.Queue = field(default_factory=asyncio.Queue)
batch_size: int = 32
workers: int = 4
async def process(self, items):
for item in items:
await self.queue.put(item)
tasks = [
asyncio.create_task(self._worker(i))
for i in range(self.workers)
]
await self.queue.join()
for t in tasks:
t.cancel()
template<typename K, typename V>
class LRUCache {
struct Node { K key; V value; Node *prev, *next; };
std::unordered_map<K, Node*> map_;
void move_to_front(Node* node) {
if (node == head_) return;
if (node->prev) node->prev->next = node->next;
if (node->next) node->next->prev = node->prev;
if (node == tail_) tail_ = node->prev;
node->next = head_;
node->prev = nullptr;
if (head_) head_->prev = node;
head_ = node;
}
};
impl ConnectionPool {
async fn acquire(&self) -> Result<Connection> {
let pool = self.inner.lock().await;
match pool.connections.pop() {
Some(conn) => Ok(conn),
None if pool.len() < self.max_size => {
self.create_connection().await
}
None => Err(PoolExhausted),
}
}
}
fn quicksort<T: Ord>(arr: &mut [T]) {
if arr.len() <= 1 { return; }
let pivot = partition(arr);
quicksort(&mut arr[..pivot]);
quicksort(&mut arr[pivot + 1..]);
}
template<typename K, typename V>
class LRUCache {
struct Node { K key; V value; Node *prev, *next; };
std::unordered_map<K, Node*> map_;
void move_to_front(Node* node) {
if (node == head_) return;
if (node->prev) node->prev->next = node->next;
if (node->next) node->next->prev = node->prev;
if (node == tail_) tail_ = node->prev;
node->next = head_;
node->prev = nullptr;
if (head_) head_->prev = node;
head_ = node;
}
};
impl ConnectionPool {
async fn acquire(&self) -> Result<Connection> {
let pool = self.inner.lock().await;
match pool.connections.pop() {
Some(conn) => Ok(conn),
None if pool.len() < self.max_size => {
self.create_connection().await
}
None => Err(PoolExhausted),
}
}
}
fn quicksort<T: Ord>(arr: &mut [T]) {
if arr.len() <= 1 { return; }
let pivot = partition(arr);
quicksort(&mut arr[..pivot]);
quicksort(&mut arr[pivot + 1..]);
}
template<typename T, size_t N>
class RingBuffer {
std::array<T, N> buf_;
size_t head_ = 0, tail_ = 0, count_ = 0;
public:
bool push(const T& val) {
if (count_ == N) return false;
buf_[tail_] = val;
tail_ = (tail_ + 1) % N;
++count_;
return true;
}
std::optional<T> pop() {
if (count_ == 0) return std::nullopt;
T val = std::move(buf_[head_]);
head_ = (head_ + 1) % N;
--count_;
return val;
}
};
template<typename K, typename V>
class LRUCache {
struct Node { K key; V value; Node *prev, *next; };
std::unordered_map<K, Node*> map_;
void move_to_front(Node* node) {
if (node == head_) return;
if (node->prev) node->prev->next = node->next;
if (node->next) node->next->prev = node->prev;
if (node == tail_) tail_ = node->prev;
node->next = head_;
node->prev = nullptr;
if (head_) head_->prev = node;
head_ = node;
}
};
impl ConnectionPool {
async fn acquire(&self) -> Result<Connection> {
let pool = self.inner.lock().await;
match pool.connections.pop() {
Some(conn) => Ok(conn),
None if pool.len() < self.max_size => {
self.create_connection().await
}
None => Err(PoolExhausted),
}
}
}
fn quicksort<T: Ord>(arr: &mut [T]) {
if arr.len() <= 1 { return; }
let pivot = partition(arr);
quicksort(&mut arr[..pivot]);
quicksort(&mut arr[pivot + 1..]);
}
template<typename T, size_t N>
class RingBuffer {
std::array<T, N> buf_;
size_t head_ = 0, tail_ = 0, count_ = 0;
public:
bool push(const T& val) {
if (count_ == N) return false;
buf_[tail_] = val;
tail_ = (tail_ + 1) % N;
++count_;
return true;
}
std::optional<T> pop() {
if (count_ == 0) return std::nullopt;
T val = std::move(buf_[head_]);
head_ = (head_ + 1) % N;
--count_;
return val;
}
};