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

msvc build fixes and warning fixes

This commit is contained in:
Arvid Norberg 2008-04-05 21:18:27 +00:00
parent 7ebdc27779
commit 35fd9aec61
17 changed files with 74 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/libtorrent/disk_io_thread.hpp
View File

@ -84,7 +84,7 @@ namespace libtorrent
action_t action; action_t action;
char* buffer; char* buffer;
size_type buffer_size; int buffer_size;
boost::intrusive_ptr<piece_manager> storage; boost::intrusive_ptr<piece_manager> storage;
// arguments used for read and write // arguments used for read and write
int piece, offset; int piece, offset;

8
include/libtorrent/storage.hpp
View File

@ -123,10 +123,10 @@ namespace libtorrent
virtual bool initialize(bool allocate_files) = 0; virtual bool initialize(bool allocate_files) = 0;
// negative return value indicates an error // negative return value indicates an error
virtual size_type read(char* buf, int slot, int offset, int size) = 0; virtual int read(char* buf, int slot, int offset, int size) = 0;
// negative return value indicates an error // negative return value indicates an error
virtual size_type write(const char* buf, int slot, int offset, int size) = 0; virtual int write(const char* buf, int slot, int offset, int size) = 0;
// non-zero return value indicates an error // non-zero return value indicates an error
virtual bool move_storage(fs::path save_path) = 0; virtual bool move_storage(fs::path save_path) = 0;
@ -283,13 +283,13 @@ namespace libtorrent
bool allocate_slots(int num_slots, bool abort_on_disk = false); bool allocate_slots(int num_slots, bool abort_on_disk = false);
size_type read_impl( int read_impl(
char* buf char* buf
, int piece_index , int piece_index
, int offset , int offset
, int size); , int size);
size_type write_impl( int write_impl(
const char* buf const char* buf
, int piece_index , int piece_index
, int offset , int offset

8
include/libtorrent/time.hpp
View File

@ -293,13 +293,13 @@ namespace libtorrent
inline int total_seconds(time_duration td) inline int total_seconds(time_duration td)
{ {
return aux::performance_counter_to_microseconds(td.diff) return int(aux::performance_counter_to_microseconds(td.diff)
/ 1000000; / 1000000);
} }
inline int total_milliseconds(time_duration td) inline int total_milliseconds(time_duration td)
{ {
return aux::performance_counter_to_microseconds(td.diff) return int(aux::performance_counter_to_microseconds(td.diff)
/ 1000; / 1000);
} }
inline boost::int64_t total_microseconds(time_duration td) inline boost::int64_t total_microseconds(time_duration td)
{ {

2
src/alert.cpp
View File

@ -95,7 +95,7 @@ namespace libtorrent {
nsec -= 1000000000; nsec -= 1000000000;
xt.sec += 1; xt.sec += 1;
} }
xt.nsec = nsec; xt.nsec = boost::xtime::xtime_nsec_t(nsec);
if (!m_condition.timed_wait(lock, xt)) return 0; if (!m_condition.timed_wait(lock, xt)) return 0;
TORRENT_ASSERT(!m_alerts.empty()); TORRENT_ASSERT(!m_alerts.empty());
if (m_alerts.empty()) return 0; if (m_alerts.empty()) return 0;

1
src/bt_peer_connection.cpp
View File

@ -1240,6 +1240,7 @@ namespace libtorrent
} }
catch (std::exception& exc) catch (std::exception& exc)
{ {
(void)exc;
#ifdef TORRENT_VERBOSE_LOGGING #ifdef TORRENT_VERBOSE_LOGGING
(*m_logger) << "invalid extended handshake: " << exc.what() << "\n"; (*m_logger) << "invalid extended handshake: " << exc.what() << "\n";
#endif #endif

8
src/http_tracker_connection.cpp
View File

@ -341,8 +341,8 @@ namespace libtorrent
fail(-1, "missing 'complete' or 'incomplete' entries in scrape response"); fail(-1, "missing 'complete' or 'incomplete' entries in scrape response");
return; return;
} }
cb->tracker_scrape_response(tracker_req(), complete->integer() cb->tracker_scrape_response(tracker_req(), int(complete->integer())
, incomplete->integer(), downloaded->integer()); , int(incomplete->integer()), int(downloaded->integer()));
return; return;
} }
@ -426,11 +426,11 @@ namespace libtorrent
entry const* complete_ent = e.find_key("complete"); entry const* complete_ent = e.find_key("complete");
if (complete_ent && complete_ent->type() == entry::int_t) if (complete_ent && complete_ent->type() == entry::int_t)
complete = complete_ent->integer(); complete = int(complete_ent->integer());
entry const* incomplete_ent = e.find_key("incomplete"); entry const* incomplete_ent = e.find_key("incomplete");
if (incomplete_ent && incomplete_ent->type() == entry::int_t) if (incomplete_ent && incomplete_ent->type() == entry::int_t)
incomplete = incomplete_ent->integer(); incomplete = int(incomplete_ent->integer());
cb->tracker_response(tracker_req(), peer_list, interval->integer(), complete cb->tracker_response(tracker_req(), peer_list, interval->integer(), complete
, incomplete, external_ip); , incomplete, external_ip);

4
src/mapped_storage.cpp
View File

@ -256,7 +256,7 @@ namespace libtorrent
bool initialize(bool allocate_files) { return false; } bool initialize(bool allocate_files) { return false; }
size_type read(char* buf, int slot, int offset, int size) int read(char* buf, int slot, int offset, int size)
{ {
TORRENT_ASSERT(buf != 0); TORRENT_ASSERT(buf != 0);
TORRENT_ASSERT(slot >= 0 && slot < m_info->num_pieces()); TORRENT_ASSERT(slot >= 0 && slot < m_info->num_pieces());
@ -378,7 +378,7 @@ namespace libtorrent
return result; return result;
} }
size_type write(const char* buf, int slot, int offset, int size) int write(const char* buf, int slot, int offset, int size)
{ {
TORRENT_ASSERT(buf != 0); TORRENT_ASSERT(buf != 0);
TORRENT_ASSERT(slot >= 0 && slot < m_info->num_pieces()); TORRENT_ASSERT(slot >= 0 && slot < m_info->num_pieces());

2
src/metadata_transfer.cpp
View File

@ -284,7 +284,7 @@ namespace libtorrent { namespace
entry const& messages = h["m"]; entry const& messages = h["m"];
if (entry const* index = messages.find_key("LT_metadata")) if (entry const* index = messages.find_key("LT_metadata"))
{ {
m_message_index = index->integer(); m_message_index = int(index->integer());
return true; return true;
} }
else else

14
src/peer_connection.cpp
View File

@ -309,7 +309,7 @@ namespace libtorrent
t->get_policy().peer_is_interesting(*this); t->get_policy().peer_is_interesting(*this);
} }
// may throw an asio error if socket has disconnected // may throw an asio error if socket has disconnected
catch (std::exception& e) {} catch (std::exception&) {}
TORRENT_ASSERT(is_interesting() == interested); TORRENT_ASSERT(is_interesting() == interested);
} }
@ -1207,7 +1207,7 @@ namespace libtorrent
"s: " << r.start << " | " "s: " << r.start << " | "
"l: " << r.length << " | " "l: " << r.length << " | "
"i: " << m_peer_interested << " | " "i: " << m_peer_interested << " | "
"t: " << (int)t->torrent_file().piece_size(r.piece) << " | " "t: " << t->torrent_file().piece_size(r.piece) << " | "
"n: " << t->torrent_file().num_pieces() << " ]\n"; "n: " << t->torrent_file().num_pieces() << " ]\n";
(*m_logger) << time_now_string() (*m_logger) << time_now_string()
@ -1233,7 +1233,7 @@ namespace libtorrent
"s: " << r.start << " | " "s: " << r.start << " | "
"l: " << r.length << " | " "l: " << r.length << " | "
"i: " << m_peer_interested << " | " "i: " << m_peer_interested << " | "
"t: " << (int)t->torrent_file().piece_size(r.piece) << " | " "t: " << t->torrent_file().piece_size(r.piece) << " | "
"n: " << t->torrent_file().num_pieces() << " ]\n"; "n: " << t->torrent_file().num_pieces() << " ]\n";
(*m_logger) << time_now_string() (*m_logger) << time_now_string()
@ -1294,7 +1294,7 @@ namespace libtorrent
"s: " << r.start << " | " "s: " << r.start << " | "
"l: " << r.length << " | " "l: " << r.length << " | "
"i: " << m_peer_interested << " | " "i: " << m_peer_interested << " | "
"t: " << (int)t->torrent_file().piece_size(r.piece) << " | " "t: " << t->torrent_file().piece_size(r.piece) << " | "
"n: " << t->torrent_file().num_pieces() << " | " "n: " << t->torrent_file().num_pieces() << " | "
"h: " << t->have_piece(r.piece) << " | " "h: " << t->have_piece(r.piece) << " | "
"block_limit: " << t->block_size() << " ]\n"; "block_limit: " << t->block_size() << " ]\n";
@ -1873,7 +1873,7 @@ namespace libtorrent
int block_offset = block.block_index * t->block_size(); int block_offset = block.block_index * t->block_size();
int block_size int block_size
= (std::min)((int)t->torrent_file().piece_size(block.piece_index)-block_offset, = (std::min)(t->torrent_file().piece_size(block.piece_index)-block_offset,
t->block_size()); t->block_size());
TORRENT_ASSERT(block_size > 0); TORRENT_ASSERT(block_size > 0);
TORRENT_ASSERT(block_size <= t->block_size()); TORRENT_ASSERT(block_size <= t->block_size());
@ -1985,7 +1985,7 @@ namespace libtorrent
piece_block block = m_request_queue.front(); piece_block block = m_request_queue.front();
int block_offset = block.block_index * t->block_size(); int block_offset = block.block_index * t->block_size();
int block_size = (std::min)((int)t->torrent_file().piece_size( int block_size = (std::min)(t->torrent_file().piece_size(
block.piece_index) - block_offset, t->block_size()); block.piece_index) - block_offset, t->block_size());
TORRENT_ASSERT(block_size > 0); TORRENT_ASSERT(block_size > 0);
TORRENT_ASSERT(block_size <= t->block_size()); TORRENT_ASSERT(block_size <= t->block_size());
@ -2031,7 +2031,7 @@ namespace libtorrent
#endif #endif
block_offset = block.block_index * t->block_size(); block_offset = block.block_index * t->block_size();
block_size = (std::min)((int)t->torrent_file().piece_size( block_size = (std::min)(t->torrent_file().piece_size(
block.piece_index) - block_offset, t->block_size()); block.piece_index) - block_offset, t->block_size());
TORRENT_ASSERT(block_size > 0); TORRENT_ASSERT(block_size > 0);
TORRENT_ASSERT(block_size <= t->block_size()); TORRENT_ASSERT(block_size <= t->block_size());

2
src/policy.cpp
View File

@ -559,7 +559,9 @@ namespace libtorrent
if (m_torrent->has_picker()) if (m_torrent->has_picker())
p = &m_torrent->picker(); p = &m_torrent->picker();
#ifndef TORRENT_DISABLE_DHT
bool pinged = false; bool pinged = false;
#endif
ptime now = time_now(); ptime now = time_now();
// remove old disconnected peers from the list // remove old disconnected peers from the list

42
src/storage.cpp
View File

@ -365,8 +365,8 @@ namespace libtorrent
bool delete_files(); bool delete_files();
bool initialize(bool allocate_files); bool initialize(bool allocate_files);
bool move_storage(fs::path save_path); bool move_storage(fs::path save_path);
size_type read(char* buf, int slot, int offset, int size); int read(char* buf, int slot, int offset, int size);
size_type write(const char* buf, int slot, int offset, int size); int write(const char* buf, int slot, int offset, int size);
bool move_slot(int src_slot, int dst_slot); bool move_slot(int src_slot, int dst_slot);
bool swap_slots(int slot1, int slot2); bool swap_slots(int slot1, int slot2);
bool swap_slots3(int slot1, int slot2, int slot3); bool swap_slots3(int slot1, int slot2, int slot3);
@ -377,7 +377,7 @@ namespace libtorrent
std::string const& error() const { return m_error; } std::string const& error() const { return m_error; }
void clear_error() { m_error.clear(); } void clear_error() { m_error.clear(); }
size_type read_impl(char* buf, int slot, int offset, int size, bool fill_zero); int read_impl(char* buf, int slot, int offset, int size, bool fill_zero);
~storage() ~storage()
{ m_files.release(this); } { m_files.release(this); }
@ -756,8 +756,8 @@ namespace libtorrent
{ {
int piece_size = m_info->piece_size(dst_slot); int piece_size = m_info->piece_size(dst_slot);
m_scratch_buffer.resize(piece_size); m_scratch_buffer.resize(piece_size);
size_type ret1 = read_impl(&m_scratch_buffer[0], src_slot, 0, piece_size, true); int ret1 = read_impl(&m_scratch_buffer[0], src_slot, 0, piece_size, true);
size_type ret2 = write(&m_scratch_buffer[0], dst_slot, 0, piece_size); int ret2 = write(&m_scratch_buffer[0], dst_slot, 0, piece_size);
return ret1 != piece_size || ret2 != piece_size; return ret1 != piece_size || ret2 != piece_size;
} }
@ -768,10 +768,10 @@ namespace libtorrent
int piece1_size = m_info->piece_size(slot2); int piece1_size = m_info->piece_size(slot2);
int piece2_size = m_info->piece_size(slot1); int piece2_size = m_info->piece_size(slot1);
m_scratch_buffer.resize(piece_size * 2); m_scratch_buffer.resize(piece_size * 2);
size_type ret1 = read_impl(&m_scratch_buffer[0], slot1, 0, piece1_size, true); int ret1 = read_impl(&m_scratch_buffer[0], slot1, 0, piece1_size, true);
size_type ret2 = read_impl(&m_scratch_buffer[piece_size], slot2, 0, piece2_size, true); int ret2 = read_impl(&m_scratch_buffer[piece_size], slot2, 0, piece2_size, true);
size_type ret3 = write(&m_scratch_buffer[0], slot2, 0, piece1_size); int ret3 = write(&m_scratch_buffer[0], slot2, 0, piece1_size);
size_type ret4 = write(&m_scratch_buffer[piece_size], slot1, 0, piece2_size); int ret4 = write(&m_scratch_buffer[piece_size], slot1, 0, piece2_size);
return ret1 != piece1_size || ret2 != piece2_size return ret1 != piece1_size || ret2 != piece2_size
|| ret3 != piece1_size || ret4 != piece2_size; || ret3 != piece1_size || ret4 != piece2_size;
} }
@ -784,18 +784,18 @@ namespace libtorrent
int piece2_size = m_info->piece_size(slot3); int piece2_size = m_info->piece_size(slot3);
int piece3_size = m_info->piece_size(slot1); int piece3_size = m_info->piece_size(slot1);
m_scratch_buffer.resize(piece_size * 2); m_scratch_buffer.resize(piece_size * 2);
size_type ret1 = read_impl(&m_scratch_buffer[0], slot1, 0, piece1_size, true); int ret1 = read_impl(&m_scratch_buffer[0], slot1, 0, piece1_size, true);
size_type ret2 = read_impl(&m_scratch_buffer[piece_size], slot2, 0, piece2_size, true); int ret2 = read_impl(&m_scratch_buffer[piece_size], slot2, 0, piece2_size, true);
size_type ret3 = write(&m_scratch_buffer[0], slot2, 0, piece1_size); int ret3 = write(&m_scratch_buffer[0], slot2, 0, piece1_size);
size_type ret4 = read_impl(&m_scratch_buffer[0], slot3, 0, piece3_size, true); int ret4 = read_impl(&m_scratch_buffer[0], slot3, 0, piece3_size, true);
size_type ret5 = write(&m_scratch_buffer[piece_size], slot3, 0, piece2_size); int ret5 = write(&m_scratch_buffer[piece_size], slot3, 0, piece2_size);
size_type ret6 = write(&m_scratch_buffer[0], slot1, 0, piece3_size); int ret6 = write(&m_scratch_buffer[0], slot1, 0, piece3_size);
return ret1 != piece1_size || ret2 != piece2_size return ret1 != piece1_size || ret2 != piece2_size
|| ret3 != piece1_size || ret4 != piece3_size || ret3 != piece1_size || ret4 != piece3_size
|| ret5 != piece2_size || ret6 != piece3_size; || ret5 != piece2_size || ret6 != piece3_size;
} }
size_type storage::read( int storage::read(
char* buf char* buf
, int slot , int slot
, int offset , int offset
@ -804,7 +804,7 @@ namespace libtorrent
return read_impl(buf, slot, offset, size, false); return read_impl(buf, slot, offset, size, false);
} }
size_type storage::read_impl( int storage::read_impl(
char* buf char* buf
, int slot , int slot
, int offset , int offset
@ -904,7 +904,7 @@ namespace libtorrent
== file_iter->path); == file_iter->path);
#endif #endif
size_type actual_read = in->read(buf + buf_pos, read_bytes); int actual_read = int(in->read(buf + buf_pos, read_bytes));
if (read_bytes != actual_read) if (read_bytes != actual_read)
{ {
@ -956,7 +956,7 @@ namespace libtorrent
} }
// throws file_error if it fails to write // throws file_error if it fails to write
size_type storage::write( int storage::write(
const char* buf const char* buf
, int slot , int slot
, int offset , int offset
@ -1317,7 +1317,7 @@ namespace libtorrent
m_free_slots.push_back(slot_index); m_free_slots.push_back(slot_index);
} }
size_type piece_manager::read_impl( int piece_manager::read_impl(
char* buf char* buf
, int piece_index , int piece_index
, int offset , int offset
@ -1330,7 +1330,7 @@ namespace libtorrent
return m_storage->read(buf, slot, offset, size); return m_storage->read(buf, slot, offset, size);
} }
size_type piece_manager::write_impl( int piece_manager::write_impl(
const char* buf const char* buf
, int piece_index , int piece_index
, int offset , int offset

17
src/torrent.cpp
View File

@ -102,7 +102,7 @@ namespace
// if pieces are too small, adjust the block size // if pieces are too small, adjust the block size
if (i.piece_length() < default_block_size) if (i.piece_length() < default_block_size)
{ {
return static_cast<int>(i.piece_length()); return i.piece_length();
} }
// otherwise, go with the default // otherwise, go with the default
@ -343,7 +343,7 @@ namespace libtorrent
peer_request torrent::to_req(piece_block const& p) peer_request torrent::to_req(piece_block const& p)
{ {
int block_offset = p.block_index * m_block_size; int block_offset = p.block_index * m_block_size;
int block_size = (std::min)((int)torrent_file().piece_size( int block_size = (std::min)(torrent_file().piece_size(
p.piece_index) - block_offset, m_block_size); p.piece_index) - block_offset, m_block_size);
TORRENT_ASSERT(block_size > 0); TORRENT_ASSERT(block_size > 0);
TORRENT_ASSERT(block_size <= m_block_size); TORRENT_ASSERT(block_size <= m_block_size);
@ -410,8 +410,8 @@ namespace libtorrent
m_storage = m_owning_storage.get(); m_storage = m_owning_storage.get();
m_block_size = calculate_block_size(*m_torrent_file, m_default_block_size); m_block_size = calculate_block_size(*m_torrent_file, m_default_block_size);
m_picker.reset(new piece_picker( m_picker.reset(new piece_picker(
static_cast<int>(m_torrent_file->piece_length() / m_block_size) m_torrent_file->piece_length() / m_block_size
, static_cast<int>((m_torrent_file->total_size()+m_block_size-1)/m_block_size))); , int((m_torrent_file->total_size()+m_block_size-1)/m_block_size)));
std::vector<std::string> const& url_seeds = m_torrent_file->url_seeds(); std::vector<std::string> const& url_seeds = m_torrent_file->url_seeds();
std::copy(url_seeds.begin(), url_seeds.end(), std::inserter(m_web_seeds std::copy(url_seeds.begin(), url_seeds.end(), std::inserter(m_web_seeds
@ -1014,8 +1014,7 @@ namespace libtorrent
const std::vector<piece_picker::downloading_piece>& dl_queue const std::vector<piece_picker::downloading_piece>& dl_queue
= m_picker->get_download_queue(); = m_picker->get_download_queue();
const int blocks_per_piece = static_cast<int>( const int blocks_per_piece = piece_size / m_block_size;
piece_size / m_block_size);
for (std::vector<piece_picker::downloading_piece>::const_iterator i = for (std::vector<piece_picker::downloading_piece>::const_iterator i =
dl_queue.begin(); i != dl_queue.end(); ++i) dl_queue.begin(); i != dl_queue.end(); ++i)
@ -1971,7 +1970,7 @@ namespace libtorrent
m_host_resolver.async_resolve(q, m_host_resolver.async_resolve(q,
bind(&torrent::on_name_lookup, shared_from_this(), _1, _2, url, a)); bind(&torrent::on_name_lookup, shared_from_this(), _1, _2, url, a));
} }
catch (std::exception& exc) catch (std::exception&)
{ {
TORRENT_ASSERT(false); TORRENT_ASSERT(false);
}; };
@ -2260,7 +2259,7 @@ namespace libtorrent
pi.finished = (int)i->finished; pi.finished = (int)i->finished;
pi.writing = (int)i->writing; pi.writing = (int)i->writing;
pi.requested = (int)i->requested; pi.requested = (int)i->requested;
int piece_size = torrent_file().piece_size(i->index); int piece_size = int(torrent_file().piece_size(i->index));
for (int j = 0; j < pi.blocks_in_piece; ++j) for (int j = 0; j < pi.blocks_in_piece; ++j)
{ {
block_info& bi = pi.blocks[j]; block_info& bi = pi.blocks[j];
@ -3484,7 +3483,7 @@ namespace libtorrent
st.progress = m_progress; st.progress = m_progress;
else if (st.total_wanted == 0) st.progress = 1.f; else if (st.total_wanted == 0) st.progress = 1.f;
else st.progress = st.total_wanted_done else st.progress = st.total_wanted_done
/ static_cast<double>(st.total_wanted); / static_cast<float>(st.total_wanted);
st.pieces = &m_have_pieces; st.pieces = &m_have_pieces;
st.num_pieces = m_num_pieces; st.num_pieces = m_num_pieces;

2
src/torrent_handle.cpp
View File

@ -433,7 +433,7 @@ namespace libtorrent
if (m_ses == 0) return false; if (m_ses == 0) return false;
session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex);
boost::shared_ptr<torrent> t = m_ses->find_torrent(m_info_hash).lock(); boost::shared_ptr<torrent> t = m_ses->find_torrent(m_info_hash).lock();
return t; return t != 0;
} }
entry torrent_handle::write_resume_data() const entry torrent_handle::write_resume_data() const

13
src/torrent_info.cpp
View File

@ -361,7 +361,7 @@ namespace libtorrent
error = "invalid or missing 'piece length' entry in torrent file"; error = "invalid or missing 'piece length' entry in torrent file";
return false; return false;
} }
m_piece_length = (int)piece_length->integer(); m_piece_length = int(piece_length->integer());
if (m_piece_length <= 0) if (m_piece_length <= 0)
{ {
error = "invalid torrent. piece length <= 0"; error = "invalid torrent. piece length <= 0";
@ -563,7 +563,7 @@ namespace libtorrent
++iter; ++iter;
int port = 6881; int port = 6881;
if (iter->type() != entry::int_t) continue; if (iter->type() != entry::int_t) continue;
if (l.end() != iter) port = iter->integer(); if (l.end() != iter) port = int(iter->integer());
m_nodes.push_back(std::make_pair(hostname, port)); m_nodes.push_back(std::make_pair(hostname, port));
} }
} }
@ -895,7 +895,7 @@ namespace libtorrent
- (num_pieces() - 1) * piece_length()); - (num_pieces() - 1) * piece_length());
TORRENT_ASSERT(size > 0); TORRENT_ASSERT(size > 0);
TORRENT_ASSERT(size <= piece_length()); TORRENT_ASSERT(size <= piece_length());
return size; return int(size);
} }
else else
return piece_length(); return piece_length();
@ -951,12 +951,13 @@ namespace libtorrent
} }
std::vector<file_slice> torrent_info::map_block(int piece, size_type offset std::vector<file_slice> torrent_info::map_block(int piece, size_type offset
, int size, bool storage) const , int size_, bool storage) const
{ {
TORRENT_ASSERT(num_files() > 0); TORRENT_ASSERT(num_files() > 0);
std::vector<file_slice> ret; std::vector<file_slice> ret;
size_type start = piece * (size_type)m_piece_length + offset; size_type start = piece * (size_type)m_piece_length + offset;
size_type size = size_;
TORRENT_ASSERT(start + size <= m_total_size); TORRENT_ASSERT(start + size <= m_total_size);
// find the file iterator and file offset // find the file iterator and file offset
@ -995,8 +996,8 @@ namespace libtorrent
size_type offset = file_offset + file_at(file_index, storage).offset; size_type offset = file_offset + file_at(file_index, storage).offset;
peer_request ret; peer_request ret;
ret.piece = offset / piece_length(); ret.piece = int(offset / piece_length());
ret.start = offset - ret.piece * piece_length(); ret.start = int(offset - ret.piece * piece_length());
ret.length = size; ret.length = size;
return ret; return ret;
} }

2
src/upnp.cpp
View File

@ -208,6 +208,7 @@ void upnp::resend_request(asio::error_code const& e)
} }
catch (std::exception& e) catch (std::exception& e)
{ {
(void)e;
#ifdef TORRENT_UPNP_LOGGING #ifdef TORRENT_UPNP_LOGGING
m_log << time_now_string() m_log << time_now_string()
<< " *** Connection failed to: " << d.url << " *** Connection failed to: " << d.url
@ -434,6 +435,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
} }
catch (std::exception& e) catch (std::exception& e)
{ {
(void)e;
#ifdef TORRENT_UPNP_LOGGING #ifdef TORRENT_UPNP_LOGGING
m_log << time_now_string() m_log << time_now_string()
<< " *** Connection failed to: " << d.url << " *** Connection failed to: " << d.url

2
src/ut_pex.cpp
View File

@ -205,7 +205,7 @@ namespace libtorrent { namespace
entry const* index = messages->find_key(extension_name); entry const* index = messages->find_key(extension_name);
if (!index || index->type() != entry::int_t) return false; if (!index || index->type() != entry::int_t) return false;
m_message_index = index->integer(); m_message_index = int(index->integer());
return true; return true;
} }

9
test/test_primitives.cpp
View File

@ -6,10 +6,11 @@
#include "libtorrent/entry.hpp" #include "libtorrent/entry.hpp"
#include "libtorrent/torrent_info.hpp" #include "libtorrent/torrent_info.hpp"
#include "libtorrent/escape_string.hpp" #include "libtorrent/escape_string.hpp"
#include "libtorrent/broadcast_socket.hpp"
#ifndef TORRENT_DISABLE_DHT
#include "libtorrent/kademlia/node_id.hpp" #include "libtorrent/kademlia/node_id.hpp"
#include "libtorrent/kademlia/routing_table.hpp" #include "libtorrent/kademlia/routing_table.hpp"
#include "libtorrent/broadcast_socket.hpp" #endif
#include <boost/tuple/tuple.hpp> #include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp> #include <boost/tuple/tuple_comparison.hpp>
#include <boost/bind.hpp> #include <boost/bind.hpp>
@ -64,6 +65,7 @@ void parser_callback(std::string& out, int token, char const* s, char const* val
} }
} }
#ifndef TORRENT_DISABLE_DHT
void add_and_replace(libtorrent::dht::node_id& dst, libtorrent::dht::node_id const& add) void add_and_replace(libtorrent::dht::node_id& dst, libtorrent::dht::node_id const& add)
{ {
bool carry = false; bool carry = false;
@ -74,6 +76,7 @@ void add_and_replace(libtorrent::dht::node_id& dst, libtorrent::dht::node_id con
carry = sum > 255; carry = sum > 255;
} }
} }
#endif
int test_main() int test_main()
{ {
@ -318,6 +321,7 @@ int test_main()
std::cerr << ti3.name() << std::endl; std::cerr << ti3.name() << std::endl;
TEST_CHECK(ti3.name() == "test2/test3/test4"); TEST_CHECK(ti3.name() == "test2/test3/test4");
#ifndef TORRENT_DISABLE_DHT
// test kademlia functions // test kademlia functions
using namespace libtorrent::dht; using namespace libtorrent::dht;
@ -417,6 +421,7 @@ int test_main()
} }
TEST_CHECK(hits > int(temp.size()) / 2); TEST_CHECK(hits > int(temp.size()) / 2);
#endif