3pp-mirror/snapcast
1
0
Fork 0
mirror of https://github.com/badaix/snapcast.git synced 2025-07-19 01:18:17 +02:00
Code Issues Projects Releases Packages Wiki Activity

add clang-format file

Browse source 
reformat code
This commit is contained in:
badaix 2019-09-24 22:42:36 +02:00
parent b733f646ea
commit b20add3815
105 changed files with 7773 additions and 7723 deletions
Download patch file Download diff file Expand all files Collapse all files

223
common/queue.h
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2018 Johannes Pohl
Copyright (C) 2014-2019 Johannes Pohl
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -19,147 +19,144 @@
#ifndef QUEUE_H
#define QUEUE_H
#include <deque>
#include <atomic>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <deque>
#include <mutex>
#include <thread>
template <typename T>
class Queue
{
public:
T pop()
{
std::unique_lock<std::mutex> mlock(mutex_);
while (queue_.empty())
cond_.wait(mlock);
T pop()
{
std::unique_lock<std::mutex> mlock(mutex_);
while (queue_.empty())
cond_.wait(mlock);
// std::lock_guard<std::mutex> lock(mutex_);
auto val = queue_.front();
queue_.pop_front();
return val;
}
// std::lock_guard<std::mutex> lock(mutex_);
auto val = queue_.front();
queue_.pop_front();
return val;
}
T front()
{
std::unique_lock<std::mutex> mlock(mutex_);
while (queue_.empty())
cond_.wait(mlock);
T front()
{
std::unique_lock<std::mutex> mlock(mutex_);
while (queue_.empty())
cond_.wait(mlock);
return queue_.front();
}
return queue_.front();
}
void abort_wait()
{
{
std::lock_guard<std::mutex> mlock(mutex_);
abort_ = true;
}
cond_.notify_one();
}
void abort_wait()
{
{
std::lock_guard<std::mutex> mlock(mutex_);
abort_ = true;
}
cond_.notify_one();
}
bool wait_for(std::chrono::milliseconds timeout) const
{
std::unique_lock<std::mutex> mlock(mutex_);
abort_ = false;
if (!cond_.wait_for(mlock, timeout, [this] { return (!queue_.empty() || abort_); }))
return false;
bool wait_for(std::chrono::milliseconds timeout) const
{
std::unique_lock<std::mutex> mlock(mutex_);
abort_ = false;
if (!cond_.wait_for(mlock, timeout, [this] { return (!queue_.empty() || abort_); }))
return false;
return !queue_.empty() && !abort_;
}
return !queue_.empty() && !abort_;
}
bool try_pop(T& item, std::chrono::microseconds timeout)
{
std::unique_lock<std::mutex> mlock(mutex_);
abort_ = false;
if (!cond_.wait_for(mlock, timeout, [this] { return (!queue_.empty() || abort_); }))
return false;
if (queue_.empty() || abort_)
return false;
bool try_pop(T& item, std::chrono::microseconds timeout)
{
std::unique_lock<std::mutex> mlock(mutex_);
abort_ = false;
if (!cond_.wait_for(mlock, timeout, [this] { return (!queue_.empty() || abort_); }))
return false;
item = std::move(queue_.front());
queue_.pop_front();
if (queue_.empty() || abort_)
return false;
return true;
}
item = std::move(queue_.front());
queue_.pop_front();
bool try_pop(T& item, std::chrono::milliseconds timeout)
{
return try_pop(item, std::chrono::duration_cast<std::chrono::microseconds>(timeout));
}
return true;
}
void pop(T& item)
{
std::unique_lock<std::mutex> mlock(mutex_);
while (queue_.empty())
cond_.wait(mlock);
bool try_pop(T& item, std::chrono::milliseconds timeout)
{
return try_pop(item, std::chrono::duration_cast<std::chrono::microseconds>(timeout));
}
item = queue_.front();
queue_.pop_front();
}
void pop(T& item)
{
std::unique_lock<std::mutex> mlock(mutex_);
while (queue_.empty())
cond_.wait(mlock);
void push_front(const T& item)
{
{
std::lock_guard<std::mutex> mlock(mutex_);
queue_.push_front(item);
}
cond_.notify_one();
}
item = queue_.front();
queue_.pop_front();
}
void push_front(T&& item)
{
{
std::lock_guard<std::mutex> mlock(mutex_);
queue_.push_front(std::move(item));
}
cond_.notify_one();
}
void push_front(const T& item)
{
{
std::lock_guard<std::mutex> mlock(mutex_);
queue_.push_front(item);
}
cond_.notify_one();
}
void push(const T& item)
{
{
std::lock_guard<std::mutex> mlock(mutex_);
queue_.push_back(item);
}
cond_.notify_one();
}
void push_front(T&& item)
{
{
std::lock_guard<std::mutex> mlock(mutex_);
queue_.push_front(std::move(item));
}
cond_.notify_one();
}
void push(T&& item)
{
{
std::lock_guard<std::mutex> mlock(mutex_);
queue_.push_back(std::move(item));
}
cond_.notify_one();
}
void push(const T& item)
{
{
std::lock_guard<std::mutex> mlock(mutex_);
queue_.push_back(item);
}
cond_.notify_one();
}
size_t size() const
{
std::lock_guard<std::mutex> mlock(mutex_);
return queue_.size();
}
void push(T&& item)
{
{
std::lock_guard<std::mutex> mlock(mutex_);
queue_.push_back(std::move(item));
}
cond_.notify_one();
}
bool empty() const
{
return (size() == 0);
}
size_t size() const
{
std::lock_guard<std::mutex> mlock(mutex_);
return queue_.size();
}
Queue()=default;
Queue(const Queue&) = delete; // disable copying
Queue& operator=(const Queue&) = delete; // disable assignment
bool empty() const
{
return (size() == 0);
}
Queue() = default;
Queue(const Queue&) = delete; // disable copying
Queue& operator=(const Queue&) = delete; // disable assignment
private:
std::deque<T> queue_;
mutable std::atomic<bool> abort_;
mutable std::mutex mutex_;
mutable std::condition_variable cond_;
std::deque<T> queue_;
mutable std::atomic<bool> abort_;
mutable std::mutex mutex_;
mutable std::condition_variable cond_;
};
#endif