premiere
/
premiere-libtorrent
2
2
Fork 1
Code Issues Pull Requests Releases Wiki Activity

auto loop, consts and minor cleanup refactor

This commit is contained in:
Alden Torres 2016-11-15 12:03:11 -05:00 committed by Arvid Norberg
parent c4f1a928a4
commit 9e1305ed75
7 changed files with 57 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/libtorrent/create_torrent.hpp
View File

@ -44,10 +44,6 @@ POSSIBILITY OF SUCH DAMAGE.
#include <string>
#include <utility>
#include "libtorrent/aux_/disable_warnings_push.hpp"
#include <boost/config.hpp>
#include "libtorrent/aux_/disable_warnings_pop.hpp"
// OVERVIEW
//
// This section describes the functions and classes that are used
@ -303,8 +299,7 @@ namespace libtorrent
entry m_info_dict;
// the urls to the trackers
typedef std::pair<std::string, int> announce_entry;
std::vector<announce_entry> m_urls;
std::vector<std::pair<std::string, int>> m_urls;
std::vector<std::string> m_url_seeds;
std::vector<std::string> m_http_seeds;
@ -322,8 +317,7 @@ namespace libtorrent
mutable std::vector<sha1_hash> m_merkle_tree;
// dht nodes to add to the routing table/bootstrap from
using nodes_t = std::vector<std::pair<std::string, int>>;
nodes_t m_nodes;
std::vector<std::pair<std::string, int>> m_nodes;
// the hash that identifies this torrent
// is mutable because it's calculated
@ -485,4 +479,3 @@ namespace libtorrent
}
#endif

1
include/libtorrent/magnet_uri.hpp
View File

@ -81,4 +81,3 @@ namespace libtorrent
}
#endif

57
src/create_torrent.cpp
View File

@ -32,8 +32,6 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/create_torrent.hpp"
#include "libtorrent/utf8.hpp"
#include "libtorrent/file_pool.hpp"
#include "libtorrent/storage.hpp"
#include "libtorrent/aux_/escape_string.hpp" // for convert_to_wstring
#include "libtorrent/disk_io_thread.hpp"
#include "libtorrent/aux_/merkle.hpp" // for merkle_*()
@ -112,7 +110,8 @@ namespace libtorrent
}
void add_files_impl(file_storage& fs, std::string const& p
, std::string const& l, std::function<bool(std::string)> pred, std::uint32_t flags)
, std::string const& l, std::function<bool(std::string)> pred
, std::uint32_t const flags)
{
std::string f = combine_path(p, l);
if (!pred(f)) return;
@ -420,12 +419,11 @@ namespace libtorrent
{
entry& nodes = dict["nodes"];
entry::list_type& nodes_list = nodes.list();
for (nodes_t::const_iterator i = m_nodes.begin()
, end(m_nodes.end()); i != end; ++i)
for (auto const& n : m_nodes)
{
entry::list_type node;
node.push_back(entry(i->first));
node.push_back(entry(i->second));
node.push_back(entry(n.first));
node.push_back(entry(n.second));
nodes_list.push_back(entry(node));
}
}
@ -435,16 +433,15 @@ namespace libtorrent
entry trackers(entry::list_t);
entry tier(entry::list_t);
int current_tier = m_urls.front().second;
for (std::vector<announce_entry>::const_iterator i = m_urls.begin();
i != m_urls.end(); ++i)
for (auto const& url : m_urls)
{
if (i->second != current_tier)
if (url.second != current_tier)
{
current_tier = i->second;
current_tier = url.second;
trackers.list().push_back(tier);
tier.list().clear();
}
tier.list().push_back(entry(i->first));
tier.list().push_back(entry(url.first));
}
trackers.list().push_back(tier);
dict["announce-list"] = trackers;
@ -467,10 +464,9 @@ namespace libtorrent
else
{
entry& list = dict["url-list"];
for (std::vector<std::string>::const_iterator i
= m_url_seeds.begin(); i != m_url_seeds.end(); ++i)
for (auto const& url : m_url_seeds)
{
list.list().push_back(entry(*i));
list.list().push_back(entry(url));
}
}
}
@ -484,10 +480,9 @@ namespace libtorrent
else
{
entry& list = dict["httpseeds"];
for (std::vector<std::string>::const_iterator i
= m_http_seeds.begin(); i != m_http_seeds.end(); ++i)
for (auto const& url : m_http_seeds)
{
list.list().push_back(entry(*i));
list.list().push_back(entry(url));
}
}
}
@ -503,20 +498,18 @@ namespace libtorrent
if (!m_collections.empty())
{
entry& list = info["collections"];
for (std::vector<std::string>::const_iterator i
= m_collections.begin(); i != m_collections.end(); ++i)
for (auto const& c : m_collections)
{
list.list().push_back(entry(*i));
list.list().push_back(entry(c));
}
}
if (!m_similar.empty())
{
entry& list = info["similar"];
for (std::vector<sha1_hash>::const_iterator i
= m_similar.begin(); i != m_similar.end(); ++i)
for (auto const& ih : m_similar)
{
list.list().push_back(entry(i->to_string()));
list.list().push_back(entry(ih.to_string()));
}
}
@ -582,7 +575,7 @@ namespace libtorrent
path_e.list().push_back(entry(e));
}
int flags = m_files.file_flags(i);
int const flags = m_files.file_flags(i);
if (flags != 0)
{
std::string& attr = file_e["attr"].string();
@ -612,16 +605,15 @@ namespace libtorrent
info["piece length"] = m_files.piece_length();
if (m_merkle_torrent)
{
int num_leafs = merkle_num_leafs(m_files.num_pieces());
int num_nodes = merkle_num_nodes(num_leafs);
int first_leaf = num_nodes - num_leafs;
int const num_leafs = merkle_num_leafs(m_files.num_pieces());
int const num_nodes = merkle_num_nodes(num_leafs);
int const first_leaf = num_nodes - num_leafs;
m_merkle_tree.resize(num_nodes);
int num_pieces = int(m_piece_hash.size());
int const num_pieces = int(m_piece_hash.size());
for (int i = 0; i < num_pieces; ++i)
m_merkle_tree[first_leaf + i] = m_piece_hash[i];
sha1_hash filler(nullptr);
for (int i = num_pieces; i < num_leafs; ++i)
m_merkle_tree[first_leaf + i] = filler;
m_merkle_tree[first_leaf + i].clear();
// now that we have initialized all leaves, build
// each level bottom-up
@ -634,7 +626,7 @@ namespace libtorrent
{
hasher h;
h.update(m_merkle_tree[i]);
h.update(m_merkle_tree[i+1]);
h.update(m_merkle_tree[i + 1]);
m_merkle_tree[parent] = h.final();
}
level_start = merkle_get_parent(level_start);
@ -660,6 +652,7 @@ namespace libtorrent
void create_torrent::add_tracker(string_view url, int const tier)
{
using announce_entry = std::pair<std::string, int>;
auto i = std::find_if(m_urls.begin(), m_urls.end()
, [&url](announce_entry const& ae) { return ae.first == url.to_string(); });
if (i != m_urls.end()) return;

12
src/disk_io_thread.cpp
View File

@ -276,7 +276,7 @@ namespace libtorrent
// flush all blocks that are below p->hash.offset, since we've
// already hashed those blocks, they won't cause any read-back
int disk_io_thread::try_flush_hashed(cached_piece_entry* p, int cont_block
int disk_io_thread::try_flush_hashed(cached_piece_entry* p, int const cont_block
, jobqueue_t& completed_jobs, std::unique_lock<std::mutex>& l)
{
TORRENT_ASSERT(m_magic == 0x1337);
@ -297,7 +297,7 @@ namespace libtorrent
// end is one past the end
// round offset up to include the last block, which might
// have an odd size
int block_size = m_disk_cache.block_size();
int const block_size = m_disk_cache.block_size();
int end = p->hashing_done ? p->blocks_in_piece : (p->hash->offset + block_size - 1) / block_size;
// nothing has been hashed yet, don't flush anything
@ -602,7 +602,7 @@ namespace libtorrent
// first piece, if the iovec spans multiple pieces
void disk_io_thread::flush_iovec(cached_piece_entry* pe
, span<file::iovec_t const> iov, span<int const> flushing
, int num_blocks, storage_error& error)
, int const num_blocks, storage_error& error)
{
TORRENT_PIECE_ASSERT(!error, pe);
TORRENT_PIECE_ASSERT(num_blocks > 0, pe);
@ -672,7 +672,7 @@ namespace libtorrent
// build_iovec, to reset their state to not being flushed anymore
// the cache needs to be locked when calling this function
void disk_io_thread::iovec_flushed(cached_piece_entry* pe
, int* flushing, int num_blocks, int block_offset
, int* flushing, int const num_blocks, int const block_offset
, storage_error const& error
, jobqueue_t& completed_jobs)
{
@ -812,7 +812,7 @@ namespace libtorrent
}
}
void disk_io_thread::flush_cache(storage_interface* storage, std::uint32_t flags
void disk_io_thread::flush_cache(storage_interface* storage, std::uint32_t const flags
, jobqueue_t& completed_jobs, std::unique_lock<std::mutex>& l)
{
if (storage)
@ -1509,7 +1509,7 @@ namespace libtorrent
void disk_io_thread::async_read(storage_interface* storage, peer_request const& r
, std::function<void(disk_io_job const*)> handler, void* requester
, int flags)
, int const flags)
{
TORRENT_ASSERT(r.length <= m_disk_cache.block_size());
TORRENT_ASSERT(r.length <= 16 * 1024);

4
src/magnet_uri.cpp
View File

@ -39,8 +39,6 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/hex.hpp" // to_hex, from_hex
#include "libtorrent/socket_io.hpp"
#include <string>
namespace libtorrent
{
std::string make_magnet_uri(torrent_handle const& handle)
@ -287,5 +285,3 @@ namespace libtorrent
if (!name.empty()) p.name = name;
}
}

5
src/session_impl.cpp
View File

@ -4724,11 +4724,8 @@ namespace aux {
#ifndef TORRENT_DISABLE_DHT
// add params.dht_nodes to the DHT, if enabled
if (!params.dht_nodes.empty())
{
for (auto const& n : params.dht_nodes)
add_dht_node_name(n);
}
#endif
INVARIANT_CHECK;
@ -4755,7 +4752,7 @@ namespace aux {
}
#endif
if (params.info_hash == sha1_hash(nullptr))
if (params.info_hash.is_all_zeros())
{
ec = errors::missing_info_hash_in_uri;
return std::make_pair(ptr_t(), false);

48
src/torrent.cpp
View File

@ -368,7 +368,7 @@ namespace libtorrent
m_total_uploaded = p.total_uploaded;
m_total_downloaded = p.total_downloaded;
// the numeber of seconds this torrent has spent in started, finished and
// the number of seconds this torrent has spent in started, finished and
// seeding state so far, respectively.
m_active_time = p.active_time;
m_finished_time = p.finished_time;
@ -456,17 +456,16 @@ namespace libtorrent
// if the user added any trackers while downloading the
// .torrent file, merge them into the new tracker list
std::vector<announce_entry> new_trackers = m_torrent_file->trackers();
for (std::vector<announce_entry>::iterator i = m_trackers.begin()
, end(m_trackers.end()); i != end; ++i)
for (auto const& tr : m_trackers)
{
// if we already have this tracker, ignore it
if (std::any_of(new_trackers.begin(), new_trackers.end()
, [i] (announce_entry const& ae) { return ae.url == i->url; }))
, [&tr] (announce_entry const& ae) { return ae.url == tr.url; }))
continue;
// insert the tracker ordered by tier
new_trackers.insert(std::find_if(new_trackers.begin(), new_trackers.end()
, [i] (announce_entry const& ae) { return ae.tier >= i->tier; }), *i);
, [&tr] (announce_entry const& ae) { return ae.tier >= tr.tier; }), tr);
}
m_trackers.swap(new_trackers);
@ -780,9 +779,8 @@ namespace libtorrent
if (!settings().get_bool(settings_pack::use_dht_as_fallback)) return true;
int verified_trackers = 0;
for (std::vector<announce_entry>::const_iterator i = m_trackers.begin()
, end(m_trackers.end()); i != end; ++i)
if (i->verified) ++verified_trackers;
for (auto const& tr : m_trackers)
if (tr.verified) ++verified_trackers;
return verified_trackers == 0;
}
@ -1821,13 +1819,13 @@ namespace libtorrent
piece_block pb(pr.piece, pr.start / block);
for (; pr.length >= block; pr.length -= block, ++pb.block_index)
{
if (int(pb.block_index) == blocks_per_piece) { pb.block_index = 0; ++pb.piece_index; }
if (pb.block_index == blocks_per_piece) { pb.block_index = 0; ++pb.piece_index; }
m_picker->mark_as_finished(pb, nullptr);
}
// ugly edge case where padfiles are not used they way they're
// supposed to be. i.e. added back-to back or at the end
if (pb.block_index == blocks_per_piece) { pb.block_index = 0; ++pb.piece_index; }
if (pr.length > 0 && ((i+1 != fs.num_files() && fs.pad_file_at(i+1))
if (pr.length > 0 && ((i+1 != fs.num_files() && fs.pad_file_at(i + 1))
|| i + 1 == fs.num_files()))
{
m_picker->mark_as_finished(pb, nullptr);
@ -1844,20 +1842,18 @@ namespace libtorrent
std::vector<int> have_pieces;
for (std::vector<piece_picker::downloading_piece>::const_iterator i
= dq.begin(); i != dq.end(); ++i)
for (auto const& p : dq)
{
int num_blocks = m_picker->blocks_in_piece(i->index);
if (i->finished < num_blocks) continue;
have_pieces.push_back(i->index);
int num_blocks = m_picker->blocks_in_piece(p.index);
if (p.finished < num_blocks) continue;
have_pieces.push_back(p.index);
}
for (std::vector<int>::iterator i = have_pieces.begin();
i != have_pieces.end(); ++i)
for (auto const i : have_pieces)
{
picker().piece_passed(*i);
TORRENT_ASSERT(picker().have_piece(*i));
we_have(*i);
picker().piece_passed(i);
TORRENT_ASSERT(picker().have_piece(i));
we_have(i);
}
}
@ -1871,11 +1867,9 @@ namespace libtorrent
{
resolve_links res(m_torrent_file);
std::vector<sha1_hash> s = m_torrent_file->similar_torrents();
for (std::vector<sha1_hash>::iterator i = s.begin(), end(s.end());
i != end; ++i)
for (auto const& ih : m_torrent_file->similar_torrents())
{
std::shared_ptr<torrent> t = m_ses.find_torrent(*i).lock();
std::shared_ptr<torrent> t = m_ses.find_torrent(ih).lock();
if (!t) continue;
// Only attempt to reuse files from torrents that are seeding.
@ -1885,11 +1879,9 @@ namespace libtorrent
res.match(t->get_torrent_copy(), t->save_path());
}
std::vector<std::string> c = m_torrent_file->collections();
for (std::vector<std::string>::iterator i = c.begin(), end(c.end());
i != end; ++i)
for (auto const& c : m_torrent_file->collections())
{
std::vector<std::shared_ptr<torrent>> ts = m_ses.find_collection(*i);
std::vector<std::shared_ptr<torrent>> ts = m_ses.find_collection(c);
for (std::vector<std::shared_ptr<torrent>>::iterator k = ts.begin()
, end2(ts.end()); k != end2; ++k)