wornvirtue
/
premiere-libtorrent
forked from premiere/premiere-libtorrent
1
0
Fork 0
Code Pull Requests Activity

general cleanup of disk_buffer_holder and tailqueue (#1156) 

general cleanup of disk_buffer_holder and tailqueue
This commit is contained in:
Arvid Norberg 2016-09-26 14:22:38 -04:00 committed by GitHub
parent 179e238561
commit 9cebd4569f
5 changed files with 50 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
include/libtorrent/disk_buffer_holder.hpp
View File

@ -66,10 +66,10 @@ namespace libtorrent
struct TORRENT_EXTRA_EXPORT disk_buffer_holder
{
// internal
disk_buffer_holder(buffer_allocator_interface& alloc, char* buf);
disk_buffer_holder(buffer_allocator_interface& alloc, char* buf) noexcept;
disk_buffer_holder& operator=(disk_buffer_holder&&);
disk_buffer_holder(disk_buffer_holder&&);
disk_buffer_holder& operator=(disk_buffer_holder&&) noexcept;
disk_buffer_holder(disk_buffer_holder&&) noexcept;
disk_buffer_holder& operator=(disk_buffer_holder const&) = delete;
disk_buffer_holder(disk_buffer_holder const&) = delete;
@ -77,7 +77,7 @@ namespace libtorrent
// construct a buffer holder that will free the held buffer
// using a disk buffer pool directly (there's only one
// disk_buffer_pool per session)
disk_buffer_holder(buffer_allocator_interface& alloc, disk_io_job const& j);
disk_buffer_holder(buffer_allocator_interface& alloc, disk_io_job const& j) noexcept;
// frees any unreleased disk buffer held by this object
~disk_buffer_holder();
@ -85,10 +85,10 @@ namespace libtorrent
// return the held disk buffer and clear it from the
// holder. The responsibility to free it is passed on
// to the caller
char* release();
char* release() noexcept;
// return a pointer to the held buffer
char* get() const { return m_buf; }
char* get() const noexcept { return m_buf; }
// set the holder object to hold the specified buffer
// (or nullptr by default). If it's already holding a
@ -97,18 +97,18 @@ namespace libtorrent
void reset(disk_io_job const& j);
// swap pointers of two disk buffer holders.
void swap(disk_buffer_holder& h)
void swap(disk_buffer_holder& h) noexcept
{
TORRENT_ASSERT(h.m_allocator == m_allocator);
std::swap(h.m_buf, m_buf);
std::swap(h.m_ref, m_ref);
}
block_cache_reference ref() const { return m_ref; }
block_cache_reference ref() const noexcept { return m_ref; }
// implicitly convertible to true if the object is currently holding a
// buffer
explicit operator bool() const { return m_buf != nullptr; }
explicit operator bool() const noexcept { return m_buf != nullptr; }
private:

50
include/libtorrent/tailqueue.hpp
View File

@ -40,7 +40,7 @@ namespace libtorrent
template <typename T>
struct tailqueue_node
{
tailqueue_node() : next(0) {}
tailqueue_node() : next(nullptr) {}
T* next;
};
@ -81,12 +81,12 @@ namespace libtorrent
void append(tailqueue<T>& rhs)
{
TORRENT_ASSERT(m_last == 0 || m_last->next == 0);
TORRENT_ASSERT(rhs.m_last == 0 || rhs.m_last->next == 0);
TORRENT_ASSERT(m_last == nullptr || m_last->next == nullptr);
TORRENT_ASSERT(rhs.m_last == nullptr || rhs.m_last->next == nullptr);
if (rhs.m_first == 0) return;
if (rhs.m_first == nullptr) return;
if (m_first == 0)
if (m_first == nullptr)
{
swap(rhs);
return;
@ -95,21 +95,23 @@ namespace libtorrent
m_last->next = rhs.m_first;
m_last = rhs.m_last;
m_size += rhs.m_size;
rhs.m_first = 0;
rhs.m_last = 0;
rhs.m_first = nullptr;
rhs.m_last = nullptr;
rhs.m_size = 0;
TORRENT_ASSERT(m_last == 0 || m_last->next == 0);
TORRENT_ASSERT(m_last == nullptr || m_last->next == nullptr);
}
void prepend(tailqueue<T>& rhs)
{
TORRENT_ASSERT(m_last == 0 || m_last->next == 0);
TORRENT_ASSERT(rhs.m_last == 0 || rhs.m_last->next == 0);
TORRENT_ASSERT(m_last == nullptr || m_last->next == nullptr);
TORRENT_ASSERT(rhs.m_last == nullptr || rhs.m_last->next == nullptr);
TORRENT_ASSERT((m_last == nullptr) == (m_first == nullptr));
TORRENT_ASSERT((rhs.m_last == nullptr) == (rhs.m_first == nullptr));
if (rhs.m_first == 0) return;
if (rhs.m_first == nullptr) return;
if (m_first == 0)
if (m_first == nullptr)
{
swap(rhs);
return;
@ -117,22 +119,24 @@ namespace libtorrent
swap(rhs);
append(rhs);
TORRENT_ASSERT(m_last == nullptr || m_last->next == nullptr);
TORRENT_ASSERT(rhs.m_last == nullptr || rhs.m_last->next == nullptr);
}
T* pop_front()
{
TORRENT_ASSERT(m_last == 0 || m_last->next == 0);
TORRENT_ASSERT(m_last == nullptr || m_last->next == nullptr);
T* e = m_first;
m_first = m_first->next;
if (e == m_last) m_last = 0;
e->next = 0;
if (e == m_last) m_last = nullptr;
e->next = nullptr;
--m_size;
return e;
}
void push_front(T* e)
{
TORRENT_ASSERT(e->next == 0);
TORRENT_ASSERT(m_last == 0 || m_last->next == 0);
TORRENT_ASSERT(e->next == nullptr);
TORRENT_ASSERT(m_last == nullptr || m_last->next == nullptr);
e->next = m_first;
m_first = e;
if (!m_last) m_last = e;
@ -140,20 +144,20 @@ namespace libtorrent
}
void push_back(T* e)
{
TORRENT_ASSERT(e->next == 0);
TORRENT_ASSERT(m_last == 0 || m_last->next == 0);
TORRENT_ASSERT(e->next == nullptr);
TORRENT_ASSERT(m_last == nullptr || m_last->next == nullptr);
if (m_last) m_last->next = e;
else m_first = e;
m_last = e;
e->next = 0;
e->next = nullptr;
++m_size;
}
T* get_all()
{
TORRENT_ASSERT(m_last == 0 || m_last->next == 0);
TORRENT_ASSERT(m_last == nullptr || m_last->next == nullptr);
T* e = m_first;
m_first = 0;
m_last = 0;
m_first = nullptr;
m_last = nullptr;
m_size = 0;
return e;
}

8
simulation/test_checking.cpp
View File

@ -84,7 +84,7 @@ TORRENT_TEST(cache_after_checking)
p.set_int(lt::settings_pack::cache_size, 100);
},
[](lt::session& ses) {
int cache = get_cache_size(ses);
int const cache = get_cache_size(ses);
TEST_CHECK(cache > 0);
std::vector<lt::torrent_handle> tor = ses.get_torrents();
@ -102,7 +102,7 @@ TORRENT_TEST(checking_no_cache)
p.set_int(lt::settings_pack::cache_size, 0);
},
[](lt::session& ses) {
int cache = get_cache_size(ses);
int const cache = get_cache_size(ses);
TEST_EQUAL(cache, 0);
std::vector<lt::torrent_handle> tor = ses.get_torrents();
@ -121,7 +121,7 @@ TORRENT_TEST(checking_limit_volatile)
p.set_int(lt::settings_pack::cache_size_volatile, 2);
},
[](lt::session& ses) {
int cache = get_cache_size(ses);
int const cache = get_cache_size(ses);
// the cache fits 300 blocks, but only allows two volatile blocks
TEST_EQUAL(cache, 2);
@ -141,7 +141,7 @@ TORRENT_TEST(checking_volatile_limit_cache_size)
p.set_int(lt::settings_pack::cache_size_volatile, 300);
},
[](lt::session& ses) {
int cache = get_cache_size(ses);
int const cache = get_cache_size(ses);
// the cache allows 300 volatile blocks, but only fits 2 blocks
TEST_CHECK(cache > 0);
TEST_CHECK(cache <= 10);

10
src/disk_buffer_holder.cpp
View File

@ -36,7 +36,7 @@ POSSIBILITY OF SUCH DAMAGE.
namespace libtorrent
{
disk_buffer_holder::disk_buffer_holder(buffer_allocator_interface& alloc, char* buf)
disk_buffer_holder::disk_buffer_holder(buffer_allocator_interface& alloc, char* buf) noexcept
: m_allocator(&alloc), m_buf(buf)
{
m_ref.storage = nullptr;
@ -44,20 +44,20 @@ namespace libtorrent
m_ref.block = -1;
}
disk_buffer_holder& disk_buffer_holder::operator=(disk_buffer_holder&& h)
disk_buffer_holder& disk_buffer_holder::operator=(disk_buffer_holder&& h) noexcept
{
disk_buffer_holder(std::move(h)).swap(*this);
return *this;
}
disk_buffer_holder::disk_buffer_holder(disk_buffer_holder&& h)
disk_buffer_holder::disk_buffer_holder(disk_buffer_holder&& h) noexcept
: m_allocator(h.m_allocator), m_buf(h.m_buf), m_ref(h.m_ref)
{
// we own this buffer now
h.release();
}
disk_buffer_holder::disk_buffer_holder(buffer_allocator_interface& alloc, disk_io_job const& j)
disk_buffer_holder::disk_buffer_holder(buffer_allocator_interface& alloc, disk_io_job const& j) noexcept
: m_allocator(&alloc), m_buf(j.buffer.disk_block), m_ref(j.d.io.ref)
{
TORRENT_ASSERT(m_ref.storage == nullptr || m_ref.piece >= 0);
@ -94,7 +94,7 @@ namespace libtorrent
m_ref.storage = nullptr;
}
char* disk_buffer_holder::release()
char* disk_buffer_holder::release() noexcept
{
char* ret = m_buf;
m_buf = nullptr;

10
src/peer_connection.cpp
View File

@ -2748,11 +2748,11 @@ namespace libtorrent
// if the block we got is already finished, then ignore it
if (picker.is_downloaded(block_finished))
{
waste_reason reason;
if (b->timed_out) reason = waste_reason::piece_timed_out;
else if (b->not_wanted) reason = waste_reason::piece_cancelled;
else if (b->busy) reason = waste_reason::piece_end_game;
else reason = waste_reason::piece_unknown;
waste_reason const reason
= (b->timed_out) ? waste_reason::piece_timed_out
: (b->not_wanted) ? waste_reason::piece_cancelled
: (b->busy) ? waste_reason::piece_end_game
: waste_reason::piece_unknown;
t->add_redundant_bytes(p.length, reason);