github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

Implement IndexedList::iterator 

It is dangerous to expose internal iterator to the outside, which is
easily misused.
pull/57/head
Tatsuhiro Tsujikawa 2013-03-01 23:13:24 +09:00
parent 421ae13d40
commit d4ba562710
11 changed files with 583 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/ConsoleStatCalc.cc
View File

@ -142,9 +142,9 @@ void printProgressCompact(std::ostream& o, const DownloadEngine* e,
e->getRequestGroupMan()->getRequestGroups();
size_t cnt = 0;
const size_t MAX_ITEM = 5;
for(RequestGroupList::SeqType::const_iterator i = groups.begin(),
for(RequestGroupList::const_iterator i = groups.begin(),
eoi = groups.end(); i != eoi && cnt < MAX_ITEM; ++i, ++cnt) {
const SharedHandle<RequestGroup>& rg = (*i).second;
const SharedHandle<RequestGroup>& rg = *i;
TransferStat stat = rg->calculateStat();
o << "[#" << GroupId::toAbbrevHex(rg->getGID()) << " ";
printSizeProgress(o, rg, stat, sizeFormatter);
@ -209,9 +209,8 @@ public:
const SizeFormatter& sizeFormatter):
cols_(cols), e_(e), sizeFormatter_(sizeFormatter) {}
void operator()(const RequestGroupList::SeqType::value_type& val)
void operator()(const RequestGroupList::value_type& rg)
{
const SharedHandle<RequestGroup>& rg = val.second;
const char SEP_CHAR = '-';
std::stringstream o;
printProgress(o, rg, e_, sizeFormatter_);
@ -323,7 +322,7 @@ ConsoleStatCalc::calculateStat(const DownloadEngine* e)
size_t numGroup = e->getRequestGroupMan()->countRequestGroup();
if(numGroup == 1) {
const SharedHandle<RequestGroup>& rg =
(*e->getRequestGroupMan()->getRequestGroups().begin()).second;
*e->getRequestGroupMan()->getRequestGroups().begin();
printProgress(o, rg, e, sizeFormatter);
} else if(numGroup > 1) {
// For more than 2 RequestGroups, use compact readout form

4
src/HaveEraseCommand.cc
View File

@ -57,9 +57,9 @@ void HaveEraseCommand::process()
{
const RequestGroupList& groups =
getDownloadEngine()->getRequestGroupMan()->getRequestGroups();
for(RequestGroupList::SeqType::const_iterator i = groups.begin(),
for(RequestGroupList::const_iterator i = groups.begin(),
eoi = groups.end(); i != eoi; ++i) {
const SharedHandle<PieceStorage>& ps = (*i).second->getPieceStorage();
const SharedHandle<PieceStorage>& ps = (*i)->getPieceStorage();
if(ps) {
ps->removeAdvertisedPiece(5);
}

425
src/IndexedList.h
View File

@ -50,14 +50,319 @@ enum A2_HOW {
A2_POS_END
};
template<typename SeqType, typename ValueType, typename ReferenceType,
typename PointerType, typename SeqIteratorType>
struct IndexedListIterator {
typedef IndexedListIterator<SeqType,
ValueType,
ValueType&,
ValueType*,
typename SeqType::iterator> iterator;
typedef IndexedListIterator<SeqType,
ValueType,
const ValueType&,
const ValueType*,
typename SeqType::const_iterator> const_iterator;
typedef typename SeqIteratorType::iterator_category iterator_category;
typedef ValueType value_type;
typedef PointerType pointer;
typedef ReferenceType reference;
typedef typename SeqIteratorType::size_type size_type;
typedef typename SeqIteratorType::difference_type difference_type;
typedef IndexedListIterator SelfType;
IndexedListIterator() {}
IndexedListIterator(const iterator& other)
: p(other.p) {}
IndexedListIterator(const SeqIteratorType& p)
: p(p) {}
reference operator*() const
{
return (*p).second;
}
pointer operator->() const
{
return &(*p).second;
}
SelfType& operator++()
{
++p;
return *this;
}
SelfType operator++(int)
{
SelfType copy = *this;
++*this;
return copy;
}
SelfType& operator--()
{
--p;
return *this;
}
SelfType& operator--(int)
{
SelfType copy = *this;
--*this;
return copy;
}
SelfType& operator+=(difference_type n)
{
std::advance(p, n);
return *this;
}
SelfType operator+(difference_type n) const
{
SelfType copy = *this;
return copy += n;
}
SelfType& operator-=(difference_type n)
{
std::advance(p, -n);
return *this;
}
SelfType operator-(difference_type n) const
{
SelfType copy = *this;
return copy -= n;
}
reference operator[](size_type n) const
{
return p[n].second;
}
SeqIteratorType p;
};
template<typename SeqType, typename ValueType, typename ReferenceType,
typename PointerType, typename SeqIteratorType>
bool operator==(const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& rhs)
{
return lhs.p == rhs.p;
}
template<typename SeqType, typename ValueType,
typename ReferenceTypeL, typename PointerTypeL,
typename SeqIteratorTypeL,
typename ReferenceTypeR, typename PointerTypeR,
typename SeqIteratorTypeR>
bool operator==(const IndexedListIterator<SeqType, ValueType, ReferenceTypeL,
PointerTypeL, SeqIteratorTypeL>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceTypeR,
PointerTypeR, SeqIteratorTypeR>& rhs)
{
return lhs.p == rhs.p;
}
template<typename SeqType, typename ValueType, typename ReferenceType,
typename PointerType, typename SeqIteratorType>
bool operator!=(const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& rhs)
{
return lhs.p != rhs.p;
}
template<typename SeqType, typename ValueType,
typename ReferenceTypeL, typename PointerTypeL,
typename SeqIteratorTypeL,
typename ReferenceTypeR, typename PointerTypeR,
typename SeqIteratorTypeR>
bool operator!=(const IndexedListIterator<SeqType, ValueType, ReferenceTypeL,
PointerTypeL, SeqIteratorTypeL>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceTypeR,
PointerTypeR, SeqIteratorTypeR>& rhs)
{
return lhs.p != rhs.p;
}
template<typename SeqType, typename ValueType, typename ReferenceType,
typename PointerType, typename SeqIteratorType>
bool operator<(const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& rhs)
{
return lhs.p < rhs.p;
}
template<typename SeqType, typename ValueType,
typename ReferenceTypeL, typename PointerTypeL,
typename SeqIteratorTypeL,
typename ReferenceTypeR, typename PointerTypeR,
typename SeqIteratorTypeR>
bool operator<(const IndexedListIterator<SeqType, ValueType, ReferenceTypeL,
PointerTypeL, SeqIteratorTypeL>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceTypeR,
PointerTypeR, SeqIteratorTypeR>& rhs)
{
return lhs.p < rhs.p;
}
template<typename SeqType, typename ValueType, typename ReferenceType,
typename PointerType, typename SeqIteratorType>
bool operator>(const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& rhs)
{
return lhs.p > rhs.p;
}
template<typename SeqType, typename ValueType,
typename ReferenceTypeL, typename PointerTypeL,
typename SeqIteratorTypeL,
typename ReferenceTypeR, typename PointerTypeR,
typename SeqIteratorTypeR>
bool operator>(const IndexedListIterator<SeqType, ValueType, ReferenceTypeL,
PointerTypeL, SeqIteratorTypeL>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceTypeR,
PointerTypeR, SeqIteratorTypeR>& rhs)
{
return lhs.p > rhs.p;
}
template<typename SeqType, typename ValueType, typename ReferenceType,
typename PointerType, typename SeqIteratorType>
bool operator<=(const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& rhs)
{
return lhs.p <= rhs.p;
}
template<typename SeqType, typename ValueType,
typename ReferenceTypeL, typename PointerTypeL,
typename SeqIteratorTypeL,
typename ReferenceTypeR, typename PointerTypeR,
typename SeqIteratorTypeR>
bool operator<=(const IndexedListIterator<SeqType, ValueType, ReferenceTypeL,
PointerTypeL, SeqIteratorTypeL>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceTypeR,
PointerTypeR, SeqIteratorTypeR>& rhs)
{
return lhs.p <= rhs.p;
}
template<typename SeqType, typename ValueType, typename ReferenceType,
typename PointerType, typename SeqIteratorType>
bool operator>=(const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& rhs)
{
return lhs.p >= rhs.p;
}
template<typename SeqType, typename ValueType,
typename ReferenceTypeL, typename PointerTypeL,
typename SeqIteratorTypeL,
typename ReferenceTypeR, typename PointerTypeR,
typename SeqIteratorTypeR>
bool operator>=(const IndexedListIterator<SeqType, ValueType, ReferenceTypeL,
PointerTypeL, SeqIteratorTypeL>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceTypeR,
PointerTypeR, SeqIteratorTypeR>& rhs)
{
return lhs.p >= rhs.p;
}
template<typename SeqType, typename ValueType, typename ReferenceType,
typename PointerType, typename SeqIteratorType>
IndexedListIterator<SeqType, ValueType, ReferenceType, PointerType,
SeqIteratorType>
operator+(typename IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>::difference_type n,
const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& lhs)
{
return lhs + n;
}
template<typename SeqType, typename ValueType, typename ReferenceType,
typename PointerType, typename SeqIteratorType>
typename IndexedListIterator<SeqType, ValueType, ReferenceType, PointerType,
SeqIteratorType>::difference_type
operator-(const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType, SeqIteratorType>& rhs)
{
return typename IndexedListIterator<SeqType, ValueType, ReferenceType,
PointerType,
SeqIteratorType>::difference_type
(lhs.p - rhs.p);
}
template<typename SeqType, typename ValueType,
typename ReferenceTypeL, typename PointerTypeL,
typename SeqIteratorTypeL,
typename ReferenceTypeR, typename PointerTypeR,
typename SeqIteratorTypeR>
typename IndexedListIterator<SeqType, ValueType, ReferenceTypeL, PointerTypeL,
SeqIteratorTypeL>::difference_type
operator-(const IndexedListIterator<SeqType, ValueType, ReferenceTypeL,
PointerTypeL, SeqIteratorTypeL>& lhs,
const IndexedListIterator<SeqType, ValueType, ReferenceTypeR,
PointerTypeR, SeqIteratorTypeR>& rhs)
{
return typename IndexedListIterator<SeqType, ValueType, ReferenceTypeL,
PointerTypeL,
SeqIteratorTypeL>::difference_type
(lhs.p - rhs.p);
}
template<typename KeyType, typename ValuePtrType>
class IndexedList {
public:
IndexedList() {}
~IndexedList() {}
typedef std::deque<std::pair<KeyType, ValuePtrType> > SeqType;
typedef KeyType key_type;
typedef ValuePtrType value_type;
typedef std::map<KeyType, ValuePtrType> IndexType;
typedef std::deque<std::pair<typename IndexType::iterator,
ValuePtrType> > SeqType;
typedef IndexedListIterator<SeqType,
ValuePtrType,
ValuePtrType&,
ValuePtrType*,
typename SeqType::iterator> iterator;
typedef IndexedListIterator<SeqType,
ValuePtrType,
const ValuePtrType&,
const ValuePtrType*,
typename SeqType::const_iterator> const_iterator;
ValuePtrType& operator[](size_t n)
{
return seq_[n].second;
}
const ValuePtrType& operator[](size_t n) const
{
return seq_[n].second;
}
// Inserts (|key|, |value|) to the end of the list. If the same key
// has been already added, this function fails. This function
@ -66,9 +371,8 @@ public:
{
typename IndexType::iterator i = index_.lower_bound(key);
if(i == index_.end() || (*i).first != key) {
std::pair<KeyType, ValuePtrType> p(key, value);
seq_.push_back(p);
index_.insert(i, p);
i = index_.insert(i, std::make_pair(key, value));
seq_.push_back(std::make_pair(i, value));
return true;
} else {
return false;
@ -82,9 +386,8 @@ public:
{
typename IndexType::iterator i = index_.lower_bound(key);
if(i == index_.end() || (*i).first != key) {
std::pair<KeyType, ValuePtrType> p(key, value);
seq_.push_front(p);
index_.insert(i, p);
i = index_.insert(i, std::make_pair(key, value));
seq_.push_front(std::make_pair(i, value));
return true;
} else {
return false;
@ -95,8 +398,7 @@ public:
// has been already added, this function fails. This function
// returns the iterator to the newly added element if it is
// succeeds, or end(). Complexity: O(N)
typename SeqType::iterator insert(size_t dest, KeyType key,
ValuePtrType value)
iterator insert(size_t dest, KeyType key, ValuePtrType value)
{
if(dest > size()) {
return seq_.end();
@ -105,12 +407,11 @@ public:
if(i == index_.end() || (*i).first != key) {
typename SeqType::iterator j = seq_.begin();
std::advance(j, dest);
std::pair<KeyType, ValuePtrType> p(key, value);
j = seq_.insert(j, p);
index_.insert(i, p);
return j;
i = index_.insert(i, std::make_pair(key, value));
j = seq_.insert(j, std::make_pair(i, value));
return iterator(j);
} else {
return seq_.end();
return iterator(seq_.end());
}
}
@ -119,18 +420,14 @@ public:
// returns the iterator to the newly added element if it is
// succeeds, or end(). Complexity: O(logN) if inserted to the first
// or last, otherwise O(N)
typename SeqType::iterator insert(typename SeqType::iterator dest,
KeyType key,
ValuePtrType value)
iterator insert(iterator dest, KeyType key, ValuePtrType value)
{
typename IndexType::iterator i = index_.lower_bound(key);
if(i == index_.end() || (*i).first != key) {
std::pair<KeyType, ValuePtrType> p(key, value);
dest = seq_.insert(dest, p);
index_.insert(i, p);
return dest;
i = index_.insert(i, std::make_pair(key, value));
return iterator(seq_.insert(dest.p, std::make_pair(i, value)));
} else {
return seq_.end();
return iterator(seq_.end());
}
}
@ -138,7 +435,7 @@ public:
// value is retrieved by functor |keyFunc|. The insertion position
// is given by |dest|.
template<typename KeyFunc, typename InputIterator>
void insert(typename SeqType::iterator dest, KeyFunc keyFunc,
void insert(iterator dest, KeyFunc keyFunc,
InputIterator first, InputIterator last)
{
std::vector<typename SeqType::value_type> v;
@ -147,12 +444,31 @@ public:
KeyType key = keyFunc(*first);
typename IndexType::iterator i = index_.lower_bound(key);
if(i == index_.end() || (*i).first != key) {
std::pair<KeyType, ValuePtrType> p(key, *first);
v.push_back(p);
index_.insert(i, p);
i = index_.insert(i, std::make_pair(key, *first));
v.push_back(std::make_pair(i, *first));
}
}
seq_.insert(dest, v.begin(), v.end());
seq_.insert(dest.p, v.begin(), v.end());
}
template<typename KeyFunc, typename InputIterator>
void insert(size_t pos, KeyFunc keyFunc,
InputIterator first, InputIterator last)
{
if(pos > size()) {
return;
}
std::vector<typename SeqType::value_type> v;
v.reserve(std::distance(first, last));
for(; first != last; ++first) {
KeyType key = keyFunc(*first);
typename IndexType::iterator i = index_.lower_bound(key);
if(i == index_.end() || (*i).first != key) {
i = index_.insert(i, std::make_pair(key, *first));
v.push_back(std::make_pair(i, *first));
}
}
seq_.insert(seq_.begin() + pos, v.begin(), v.end());
}
// Removes |key| from the list. If the element is not found, this
@ -164,14 +480,14 @@ public:
if(i == index_.end()) {
return false;
}
index_.erase(i);
for(typename SeqType::iterator j = seq_.begin(), eoj = seq_.end();
j != eoj; ++j) {
if((*j).first == key) {
if((*j).first == i) {
seq_.erase(j);
break;
}
}
index_.erase(i);
return true;
}
@ -179,10 +495,33 @@ public:
// iterator must be valid. This function returns the iterator
// pointing to the element following the erased element. Complexity:
// O(N)
typename SeqType::iterator erase(typename SeqType::iterator k)
iterator erase(iterator k)
{
index_.erase((*k).first);
return seq_.erase(k);
index_.erase((*k.p).first);
return iterator(seq_.erase(k.p));
}
// Removes elements for which Pred returns true. The pred is called
// against each each element once per each.
template<typename Pred>
void remove_if(Pred pred)
{
typename SeqType::iterator first = seq_.begin(), last = seq_.end();
for(; first != last && !pred((*first).second); ++first);
if(first == last) {
return;
}
index_.erase((*first).first);
typename SeqType::iterator store = first;
++first;
for(; first != last; ++first) {
if(pred((*first).second)) {
index_.erase((*first).first);
} else {
*store++ = *first;
}
}
seq_.erase(store, last);
}
// Removes element at the front of the list. If the list is empty,
@ -193,8 +532,8 @@ public:
if(seq_.empty()) {
return false;
}
KeyType key = seq_.front().first;
index_.erase(key);
typename IndexType::iterator i = seq_.front().first;
index_.erase(i);
seq_.pop_front();
return true;
}
@ -216,7 +555,7 @@ public:
}
typename SeqType::iterator x = seq_.begin(), eseq = seq_.end();
for(; x != eseq; ++x) {
if((*x).first == key) {
if((*x).first == idxent) {
break;
}
}
@ -271,24 +610,24 @@ public:
return index_.empty();
}
typename SeqType::iterator begin()
iterator begin()
{
return seq_.begin();
return iterator(seq_.begin());
}
typename SeqType::iterator end()
iterator end()
{
return seq_.end();
return iterator(seq_.end());
}
typename SeqType::const_iterator begin() const
const_iterator begin() const
{
return seq_.begin();
return const_iterator(seq_.begin());
}
typename SeqType::const_iterator end() const
const_iterator end() const
{
return seq_.end();
return const_iterator(seq_.end());
}
// Removes all elements from the list.

52
src/RequestGroupMan.cc
View File

@ -165,9 +165,7 @@ void RequestGroupMan::insertReservedGroup
{
requestQueueCheck();
pos = std::min(reservedGroups_.size(), pos);
RequestGroupList::SeqType::iterator dest = reservedGroups_.begin();
std::advance(dest, pos);
reservedGroups_.insert(dest, RequestGroupKeyFunc(),
reservedGroups_.insert(pos, RequestGroupKeyFunc(),
groups.begin(), groups.end());
}
@ -282,9 +280,8 @@ public:
reservedGroups_(reservedGroups)
{}
void operator()(const RequestGroupList::SeqType::value_type& val)
void operator()(const RequestGroupList::value_type& group)
{
const SharedHandle<RequestGroup>& group = val.second;
if(group->getNumCommand() == 0) {
const SharedHandle<DownloadContext>& dctx = group->getDownloadContext();
// DownloadContext::resetDownloadStopTime() is only called when
@ -385,9 +382,8 @@ public:
CollectServerStat(RequestGroupMan* requestGroupMan):
requestGroupMan_(requestGroupMan) {}
void operator()(const RequestGroupList::SeqType::value_type& val)
void operator()(const RequestGroupList::value_type& group)
{
const SharedHandle<RequestGroup>& group = val.second;
if(group->getNumCommand() == 0) {
// Collect statistics during download in PeerStats and update/register
// ServerStatMan
@ -436,9 +432,9 @@ void RequestGroupMan::removeStoppedGroup(DownloadEngine* e)
std::for_each(requestGroups_.begin(), requestGroups_.end(),
ProcessStoppedRequestGroup(e, reservedGroups_));
for(RequestGroupList::SeqType::iterator i = requestGroups_.begin(),
for(RequestGroupList::iterator i = requestGroups_.begin(),
eoi = requestGroups_.end(); i != eoi;) {
const SharedHandle<RequestGroup>& rg = (*i).second;
const SharedHandle<RequestGroup>& rg = *i;
if(rg->getNumCommand() == 0) {
i = requestGroups_.erase(i);
eoi = requestGroups_.end();
@ -505,7 +501,7 @@ void RequestGroupMan::fillRequestGroupFromReserver(DownloadEngine* e)
}
}
}
SharedHandle<RequestGroup> groupToAdd = (*reservedGroups_.begin()).second;
SharedHandle<RequestGroup> groupToAdd = *reservedGroups_.begin();
reservedGroups_.pop_front();
if((rpc_ && groupToAdd->isPauseRequested()) ||
!groupToAdd->isDependencyResolved()) {
@ -556,9 +552,9 @@ void RequestGroupMan::fillRequestGroupFromReserver(DownloadEngine* e)
void RequestGroupMan::save()
{
for(RequestGroupList::SeqType::iterator itr = requestGroups_.begin(),
for(RequestGroupList::iterator itr = requestGroups_.begin(),
eoi = requestGroups_.end(); itr != eoi; ++itr) {
const SharedHandle<RequestGroup>& rg = (*itr).second;
const SharedHandle<RequestGroup>& rg = *itr;
if(rg->allDownloadFinished() &&
!rg->getDownloadContext()->isChecksumVerificationNeeded()) {
rg->removeControlFile();
@ -574,9 +570,9 @@ void RequestGroupMan::save()
void RequestGroupMan::closeFile()
{
for(RequestGroupList::SeqType::iterator itr = requestGroups_.begin(),
for(RequestGroupList::iterator itr = requestGroups_.begin(),
eoi = requestGroups_.end(); itr != eoi; ++itr) {
(*itr).second->closeFile();
(*itr)->closeFile();
}
}
@ -587,10 +583,10 @@ RequestGroupMan::DownloadStat RequestGroupMan::getDownloadStat() const
int inprogress = 0;
int removed = 0;
error_code::Value lastError = removedLastErrorResult_;
for(DownloadResultList::SeqType::const_iterator itr =
for(DownloadResultList::const_iterator itr =
downloadResults_.begin(), eoi = downloadResults_.end(); itr != eoi;
++itr) {
const SharedHandle<DownloadResult>& dr = (*itr).second;
const SharedHandle<DownloadResult>& dr = *itr;
if(dr->belongsTo != 0) {
continue;
}
@ -676,10 +672,10 @@ void RequestGroupMan::showDownloadResults(OutputFile& o, bool full) const
int err = 0;
int inpr = 0;
int rm = 0;
for(DownloadResultList::SeqType::const_iterator itr =
for(DownloadResultList::const_iterator itr =
downloadResults_.begin(), eoi = downloadResults_.end(); itr != eoi;
++itr) {
const SharedHandle<DownloadResult>& dr = (*itr).second;
const SharedHandle<DownloadResult>& dr = *itr;
if(dr->belongsTo != 0) {
continue;
}
@ -826,9 +822,9 @@ bool RequestGroupMan::isSameFileBeingDownloaded(RequestGroup* requestGroup) cons
return false;
}
std::vector<std::string> files;
for(RequestGroupList::SeqType::const_iterator itr = requestGroups_.begin(),
for(RequestGroupList::const_iterator itr = requestGroups_.begin(),
eoi = requestGroups_.end(); itr != eoi; ++itr) {
const SharedHandle<RequestGroup>& rg = (*itr).second;
const SharedHandle<RequestGroup>& rg = *itr;
if(rg.get() != requestGroup) {
const std::vector<SharedHandle<FileEntry> >& entries =
rg->getDownloadContext()->getFileEntries();
@ -846,17 +842,17 @@ bool RequestGroupMan::isSameFileBeingDownloaded(RequestGroup* requestGroup) cons
void RequestGroupMan::halt()
{
for(RequestGroupList::SeqType::const_iterator i = requestGroups_.begin(),
for(RequestGroupList::const_iterator i = requestGroups_.begin(),
eoi = requestGroups_.end(); i != eoi; ++i) {
(*i).second->setHaltRequested(true);
(*i)->setHaltRequested(true);
}
}
void RequestGroupMan::forceHalt()
{
for(RequestGroupList::SeqType::const_iterator i = requestGroups_.begin(),
for(RequestGroupList::const_iterator i = requestGroups_.begin(),
eoi = requestGroups_.end(); i != eoi; ++i) {
(*i).second->setForceHaltRequested(true);
(*i)->setForceHaltRequested(true);
}
}
@ -882,10 +878,10 @@ void RequestGroupMan::addDownloadResult(const SharedHandle<DownloadResult>& dr)
bool rv = downloadResults_.push_back(dr->gid->getNumericId(), dr);
assert(rv);
while(downloadResults_.size() > maxDownloadResult_){
DownloadResultList::SeqType::iterator i = downloadResults_.begin();
DownloadResultList::iterator i = downloadResults_.begin();
// Save last encountered error code so that we can report it
// later.
const SharedHandle<DownloadResult>& dr = (*i).second;
const SharedHandle<DownloadResult>& dr = *i;
if(dr->belongsTo == 0 && dr->result != error_code::FINISHED) {
removedLastErrorResult_ = dr->result;
++removedErrorResult_;
@ -958,9 +954,9 @@ void RequestGroupMan::getUsedHosts
// speed. We use -download speed so that we can sort them using
// operator<().
std::vector<Triplet<size_t, int, std::string> > tempHosts;
for(RequestGroupList::SeqType::const_iterator i = requestGroups_.begin(),
for(RequestGroupList::const_iterator i = requestGroups_.begin(),
eoi = requestGroups_.end(); i != eoi; ++i) {
const SharedHandle<RequestGroup>& rg = (*i).second;
const SharedHandle<RequestGroup>& rg = *i;
const FileEntry::InFlightRequestSet& inFlightReqs =
rg->getDownloadContext()->getFirstFileEntry()->getInFlightRequests();
for(FileEntry::InFlightRequestSet::iterator j =

10
src/RpcMethodImpl.cc
View File

@ -485,7 +485,7 @@ void pauseRequestGroups
(InputIterator first, InputIterator last, bool reserved, bool forcePause)
{
for(; first != last; ++first) {
pauseRequestGroup((*first).second, reserved, forcePause);
pauseRequestGroup(*first, reserved, forcePause);
}
}
} // namespace
@ -540,9 +540,9 @@ SharedHandle<ValueBase> UnpauseAllRpcMethod::process
{
const RequestGroupList& groups =
e->getRequestGroupMan()->getReservedGroups();
for(RequestGroupList::SeqType::const_iterator i = groups.begin(),
for(RequestGroupList::const_iterator i = groups.begin(),
eoi = groups.end(); i != eoi; ++i) {
(*i).second->setPauseRequested(false);
(*i)->setPauseRequested(false);
}
e->getRequestGroupMan()->requestQueueCheck();
return VLB_OK;
@ -1039,13 +1039,13 @@ SharedHandle<ValueBase> TellActiveRpcMethod::process
toStringList(std::back_inserter(keys), keysParam);
SharedHandle<List> list = List::g();
const RequestGroupList& groups = e->getRequestGroupMan()->getRequestGroups();
for(RequestGroupList::SeqType::const_iterator i = groups.begin(),
for(RequestGroupList::const_iterator i = groups.begin(),
eoi = groups.end(); i != eoi; ++i) {
SharedHandle<Dict> entryDict = Dict::g();
if(requested_key(keys, KEY_STATUS)) {
entryDict->put(KEY_STATUS, VLB_ACTIVE);
}
gatherProgress(entryDict, (*i).second, e, keys);
gatherProgress(entryDict, *i, e, keys);
list->append(entryDict);
}
return list;

6
src/RpcMethodImpl.h
View File

@ -388,13 +388,13 @@ protected:
std::vector<std::string> keys;
toStringList(std::back_inserter(keys), keysParam);
const ItemListType& items = getItems(e);
std::pair<typename ItemListType::SeqType::const_iterator,
typename ItemListType::SeqType::const_iterator> range =
std::pair<typename ItemListType::const_iterator,
typename ItemListType::const_iterator> range =
getPaginationRange(offset, num, items.begin(), items.end());
SharedHandle<List> list = List::g();
for(; range.first != range.second; ++range.first) {
SharedHandle<Dict> entryDict = Dict::g();
createEntry(entryDict, (*range.first).second, e, keys);
createEntry(entryDict, *range.first, e, keys);
list->append(entryDict);
}
if(offset < 0) {

12
src/SessionSerializer.cc
View File

@ -216,9 +216,9 @@ bool SessionSerializer::save(BufferedFile& fp) const
{
std::set<a2_gid_t> metainfoCache;
const DownloadResultList& results = rgman_->getDownloadResults();
for(DownloadResultList::SeqType::const_iterator itr = results.begin(),
for(DownloadResultList::const_iterator itr = results.begin(),
eoi = results.end(); itr != eoi; ++itr) {
const SharedHandle<DownloadResult>& dr = (*itr).second;
const SharedHandle<DownloadResult>& dr = *itr;
if(dr->result == error_code::FINISHED ||
dr->result == error_code::REMOVED) {
if(dr->option->getAsBool(PREF_FORCE_SAVE)) {
@ -246,9 +246,9 @@ bool SessionSerializer::save(BufferedFile& fp) const
{
// Save active downloads.
const RequestGroupList& groups = rgman_->getRequestGroups();
for(RequestGroupList::SeqType::const_iterator itr = groups.begin(),
for(RequestGroupList::const_iterator itr = groups.begin(),
eoi = groups.end(); itr != eoi; ++itr) {
const SharedHandle<RequestGroup>& rg = (*itr).second;
const SharedHandle<RequestGroup>& rg = *itr;
SharedHandle<DownloadResult> dr = rg->createDownloadResult();
bool stopped = dr->result == error_code::FINISHED ||
dr->result == error_code::REMOVED;
@ -262,9 +262,9 @@ bool SessionSerializer::save(BufferedFile& fp) const
}
if(saveWaiting_) {
const RequestGroupList& groups = rgman_->getReservedGroups();
for(RequestGroupList::SeqType::const_iterator itr = groups.begin(),
for(RequestGroupList::const_iterator itr = groups.begin(),
eoi = groups.end(); itr != eoi; ++itr) {
const SharedHandle<RequestGroup>& rg = (*itr).second;
const SharedHandle<RequestGroup>& rg = *itr;
SharedHandle<DownloadResult> result = rg->createDownloadResult();
if(!writeDownloadResult(fp, metainfoCache, result)) {
return false;

177
test/IndexedListTest.cc
View File

@ -24,6 +24,8 @@ class IndexedListTest:public CppUnit::TestFixture {
CPPUNIT_TEST(testGet);
CPPUNIT_TEST(testInsert);
CPPUNIT_TEST(testInsert_keyFunc);
CPPUNIT_TEST(testIterator);
CPPUNIT_TEST(testRemoveIf);
CPPUNIT_TEST_SUITE_END();
public:
void setUp()
@ -38,6 +40,8 @@ public:
void testGet();
void testInsert();
void testInsert_keyFunc();
void testIterator();
void testRemoveIf();
};
CPPUNIT_TEST_SUITE_REGISTRATION( IndexedListTest );
@ -53,9 +57,9 @@ void IndexedListTest::testPushBack()
CPPUNIT_ASSERT_EQUAL(a[i], *list.get(i));
}
int ai = 0;
for(IndexedList<int, int*>::SeqType::iterator i = list.begin();
for(IndexedList<int, int*>::iterator i = list.begin();
i != list.end(); ++i) {
CPPUNIT_ASSERT_EQUAL(a[ai++], *((*i).second));
CPPUNIT_ASSERT_EQUAL(a[ai++], **i);
}
}
@ -70,9 +74,9 @@ void IndexedListTest::testPushFront()
CPPUNIT_ASSERT_EQUAL(a[i], *list.get(i));
}
int ai = 4;
for(IndexedList<int, int*>::SeqType::iterator i = list.begin();
for(IndexedList<int, int*>::iterator i = list.begin();
i != list.end(); ++i) {
CPPUNIT_ASSERT_EQUAL(a[ai--], *((*i).second));
CPPUNIT_ASSERT_EQUAL(a[ai--], **i);
}
}
@ -100,15 +104,14 @@ void IndexedListTest::testErase()
list.push_back(i, &a[i]);
}
int* p = a;
for(IndexedList<int, int*>::SeqType::iterator i = list.begin();
i != list.end();) {
for(IndexedList<int, int*>::iterator i = list.begin(); i != list.end();) {
i = list.erase(i);
CPPUNIT_ASSERT_EQUAL((size_t)(std::distance(i, list.end())), list.size());
int* pp = ++p;
for(IndexedList<int, int*>::SeqType::iterator j = list.begin();
for(IndexedList<int, int*>::iterator j = list.begin();
j != list.end(); ++j, ++pp) {
CPPUNIT_ASSERT_EQUAL(*pp, *(*j).second);
CPPUNIT_ASSERT_EQUAL(*pp, **j);
}
}
}
@ -132,9 +135,9 @@ void IndexedListTest::testPopFront()
#define LIST_CHECK(a, list) \
{ \
int ai = 0; \
for(IndexedList<int, int*>::SeqType::iterator i = list.begin(); \
for(IndexedList<int, int*>::iterator i = list.begin(); \
i != list.end(); ++i) { \
CPPUNIT_ASSERT_EQUAL(a[ai++], *((*i).second)); \
CPPUNIT_ASSERT_EQUAL(a[ai++], **i); \
} \
}
@ -261,48 +264,48 @@ void IndexedListTest::testInsert_keyFunc()
for(size_t i = slen; i < slen*2; ++i) {
CPPUNIT_ASSERT_EQUAL(*s[i - slen], *list.get(i));
}
IndexedList<int, SharedHandle<std::string> >::SeqType::iterator itr;
IndexedList<int, SharedHandle<std::string> >::iterator itr;
itr = list.begin();
CPPUNIT_ASSERT_EQUAL(std::string("a"), *(*itr++).second);
CPPUNIT_ASSERT_EQUAL(std::string("b"), *(*itr++).second);
CPPUNIT_ASSERT_EQUAL(std::string("a"), *(*itr++).second);
CPPUNIT_ASSERT_EQUAL(std::string("b"), *(*itr++).second);
CPPUNIT_ASSERT_EQUAL(std::string("c"), *(*itr++).second);
CPPUNIT_ASSERT_EQUAL(std::string("d"), *(*itr++).second);
CPPUNIT_ASSERT_EQUAL(std::string("c"), *(*itr++).second);
CPPUNIT_ASSERT_EQUAL(std::string("d"), *(*itr++).second);
CPPUNIT_ASSERT_EQUAL(std::string("a"), *(*itr++));
CPPUNIT_ASSERT_EQUAL(std::string("b"), *(*itr++));
CPPUNIT_ASSERT_EQUAL(std::string("a"), *(*itr++));
CPPUNIT_ASSERT_EQUAL(std::string("b"), *(*itr++));
CPPUNIT_ASSERT_EQUAL(std::string("c"), *(*itr++));
CPPUNIT_ASSERT_EQUAL(std::string("d"), *(*itr++));
CPPUNIT_ASSERT_EQUAL(std::string("c"), *(*itr++));
CPPUNIT_ASSERT_EQUAL(std::string("d"), *(*itr++));
list.insert(list.begin(), KeyFunc(2*slen-1), vbegin(s), vend(s));
CPPUNIT_ASSERT_EQUAL((size_t)slen*3-1, list.size());
itr = list.begin();
CPPUNIT_ASSERT_EQUAL(std::string("b"), *(*itr++).second);
CPPUNIT_ASSERT_EQUAL(std::string("c"), *(*itr++).second);
CPPUNIT_ASSERT_EQUAL(std::string("d"), *(*itr++).second);
CPPUNIT_ASSERT_EQUAL(std::string("a"), *(*itr++).second);
CPPUNIT_ASSERT_EQUAL(std::string("b"), *(*itr++));
CPPUNIT_ASSERT_EQUAL(std::string("c"), *(*itr++));
CPPUNIT_ASSERT_EQUAL(std::string("d"), *(*itr++));
CPPUNIT_ASSERT_EQUAL(std::string("a"), *(*itr++));
}
void IndexedListTest::testInsert()
{
int a[] = {0,1,2,3,4,5,6,7,8,9};
IndexedList<int, int*> list;
IndexedList<int, int*>::SeqType::iterator itr;
IndexedList<int, int*>::iterator itr;
CPPUNIT_ASSERT(list.end() == list.insert(1, 0, &a[5]));
itr = list.insert(0, 5, &a[5]);
CPPUNIT_ASSERT_EQUAL(5, *(*itr).second);
CPPUNIT_ASSERT_EQUAL(5, **itr);
itr = list.insert(1, 3, &a[3]);
CPPUNIT_ASSERT_EQUAL(3, *(*itr).second);
CPPUNIT_ASSERT_EQUAL(3, **itr);
itr = list.insert(1, 4, &a[4]);
CPPUNIT_ASSERT_EQUAL(4, *(*itr).second);
CPPUNIT_ASSERT_EQUAL(4, **itr);
itr = list.insert(0, 9, &a[9]);
CPPUNIT_ASSERT_EQUAL(9, *(*itr).second);
CPPUNIT_ASSERT_EQUAL(9, **itr);
int a1[] = { 9,5,4,3 };
LIST_CHECK(a1, list);
// use iterator to insert
itr = list.insert(itr, 2, &a[2]);
CPPUNIT_ASSERT_EQUAL(2, *(*itr).second);
CPPUNIT_ASSERT_EQUAL(2, **itr);
itr = list.insert(list.end(), 1, &a[1]);
CPPUNIT_ASSERT_EQUAL(1, *(*itr).second);
CPPUNIT_ASSERT_EQUAL(1, **itr);
int a2[] = { 2,9,5,4,3,1 };
LIST_CHECK(a2, list);
@ -310,4 +313,118 @@ void IndexedListTest::testInsert()
CPPUNIT_ASSERT(list.end() == list.insert(list.end(), 2, &a[2]));
}
void IndexedListTest::testIterator()
{
int a[] = {0,1,2,3,4,5,6,7,8,9};
IndexedList<int, int*> list;
IndexedList<int, int*>::iterator itr;
IndexedList<int, int*>::const_iterator citr;
for(int *i = vbegin(a); i < vend(a); ++i) {
CPPUNIT_ASSERT(list.push_back(*i, i));
}
CPPUNIT_ASSERT(list.begin() == list.begin());
itr = list.begin();
citr = list.begin();
// operator*()
CPPUNIT_ASSERT_EQUAL(&a[0], *itr);
CPPUNIT_ASSERT_EQUAL(&a[0], *citr);
// operator==(iterator, iterator)
CPPUNIT_ASSERT(itr == list.begin());
CPPUNIT_ASSERT(!(itr == list.end()));
CPPUNIT_ASSERT(citr == list.begin());
CPPUNIT_ASSERT(!(citr == list.end()));
// operator++()
++itr;
++citr;
// operator!=(iterator, iterator)
CPPUNIT_ASSERT(itr != list.begin());
CPPUNIT_ASSERT(!(itr != itr));
CPPUNIT_ASSERT(citr != list.begin());
CPPUNIT_ASSERT(!(citr != citr));
// operator+(difference_type)
CPPUNIT_ASSERT(itr == list.begin() + 1);
CPPUNIT_ASSERT(citr == list.begin() + 1);
// operator-(difference_type)
CPPUNIT_ASSERT(itr - 1 == list.begin());
CPPUNIT_ASSERT(citr - 1 == list.begin());
// operator++(int)
IndexedList<int, int*>::iterator itr2 = itr++;
IndexedList<int, int*>::const_iterator citr2 = citr++;
CPPUNIT_ASSERT(itr2 + 1 == itr);
CPPUNIT_ASSERT(citr2 + 1 == citr);
// operator+(difference_type, iterator)
CPPUNIT_ASSERT(-1 + itr == itr2);
CPPUNIT_ASSERT(-1 + citr == citr2);
// operator<(iterator, iterator)
CPPUNIT_ASSERT(list.begin() < itr);
CPPUNIT_ASSERT(!(itr < list.begin()));
CPPUNIT_ASSERT(list.begin() < citr);
CPPUNIT_ASSERT(!(citr < list.begin()));
// operator>(iterator, iterator)
CPPUNIT_ASSERT(itr > list.begin());
CPPUNIT_ASSERT(!(list.begin() > itr));
CPPUNIT_ASSERT(citr > list.begin());
CPPUNIT_ASSERT(!(list.begin() > citr));
// operator<=(iterator, iterator)
CPPUNIT_ASSERT(itr <= itr);
CPPUNIT_ASSERT(list.begin() <= itr);
CPPUNIT_ASSERT(!(itr <= list.begin()));
CPPUNIT_ASSERT(citr <= citr);
CPPUNIT_ASSERT(list.begin() <= citr);
CPPUNIT_ASSERT(!(citr <= list.begin()));
// operator>=(iterator, iterator)
CPPUNIT_ASSERT(itr >= itr);
CPPUNIT_ASSERT(itr >= list.begin());
CPPUNIT_ASSERT(!(list.begin() >= itr));
CPPUNIT_ASSERT(citr >= citr);
CPPUNIT_ASSERT(citr >= list.begin());
CPPUNIT_ASSERT(!(list.begin() >= citr));
// operator-(iterator, iterator)
CPPUNIT_ASSERT(2 == itr - list.begin());
CPPUNIT_ASSERT(-2 == list.begin() - itr);
CPPUNIT_ASSERT(2 == citr - list.begin());
CPPUNIT_ASSERT(-2 == list.begin() - citr);
// operator+=(difference_type)
itr = list.begin();
itr += 2;
CPPUNIT_ASSERT(itr == list.begin() + 2);
citr = list.begin();
citr += 2;
CPPUNIT_ASSERT(citr == list.begin() + 2);
// operator-=(difference_type)
itr -= 2;
CPPUNIT_ASSERT(itr == list.begin());
citr -= 2;
CPPUNIT_ASSERT(citr == list.begin());
// operator[](size_type)
itr = list.begin();
itr += 3;
CPPUNIT_ASSERT_EQUAL(*(itr[1]), a[4]);
citr = list.begin();
citr += 3;
CPPUNIT_ASSERT_EQUAL(*(citr[1]), a[4]);
}
namespace {
struct RemoveOdd {
bool operator()(int* p) const
{
return *p % 2 == 1;
}
};
}
void IndexedListTest::testRemoveIf()
{
int a[] = {0,1,2,3,4,5,6,7,8,9};
IndexedList<int, int*> list;
for(int *i = vbegin(a); i < vend(a); ++i) {
CPPUNIT_ASSERT(list.push_back(*i, i));
}
list.remove_if(RemoveOdd());
CPPUNIT_ASSERT_EQUAL((size_t)5, list.size());
for(int i = 0; i < 5; ++i) {
CPPUNIT_ASSERT_EQUAL(i*2, *list[i]);
}
}
} // namespace aria2

14
test/RequestGroupManTest.cc
View File

@ -253,10 +253,10 @@ void RequestGroupManTest::testFillRequestGroupFromReserver_uriParser()
rgman_->fillRequestGroupFromReserver(e_.get());
RequestGroupList::SeqType::const_iterator itr;
RequestGroupList::const_iterator itr;
CPPUNIT_ASSERT_EQUAL((size_t)1, rgman_->getReservedGroups().size());
itr = rgman_->getReservedGroups().begin();
CPPUNIT_ASSERT_EQUAL(rgs[0]->getGID(), (*itr).second->getGID());
CPPUNIT_ASSERT_EQUAL(rgs[0]->getGID(), (*itr)->getGID());
CPPUNIT_ASSERT_EQUAL((size_t)3, rgman_->getRequestGroups().size());
}
@ -277,18 +277,18 @@ void RequestGroupManTest::testInsertReservedGroup()
std::vector<SharedHandle<RequestGroup> > groups(vbegin(rgs1), vend(rgs1));
rgman_->insertReservedGroup(0, groups);
CPPUNIT_ASSERT_EQUAL((size_t)2, rgman_->getReservedGroups().size());
RequestGroupList::SeqType::const_iterator itr;
RequestGroupList::const_iterator itr;
itr = rgman_->getReservedGroups().begin();
CPPUNIT_ASSERT_EQUAL(rgs1[0]->getGID(), (*itr++).second->getGID());
CPPUNIT_ASSERT_EQUAL(rgs1[1]->getGID(), (*itr++).second->getGID());
CPPUNIT_ASSERT_EQUAL(rgs1[0]->getGID(), (*itr++)->getGID());
CPPUNIT_ASSERT_EQUAL(rgs1[1]->getGID(), (*itr++)->getGID());
groups.assign(vbegin(rgs2), vend(rgs2));
rgman_->insertReservedGroup(1, groups);
CPPUNIT_ASSERT_EQUAL((size_t)4, rgman_->getReservedGroups().size());
itr = rgman_->getReservedGroups().begin();
++itr;
CPPUNIT_ASSERT_EQUAL(rgs2[0]->getGID(), (*itr++).second->getGID());
CPPUNIT_ASSERT_EQUAL(rgs2[1]->getGID(), (*itr++).second->getGID());
CPPUNIT_ASSERT_EQUAL(rgs2[0]->getGID(), (*itr++)->getGID());
CPPUNIT_ASSERT_EQUAL(rgs2[1]->getGID(), (*itr++)->getGID());
}
void RequestGroupManTest::testAddDownloadResult()

2
test/RpcMethodTest.cc
View File

@ -165,7 +165,7 @@ void RpcMethodTest::testAddUri()
e_->getRequestGroupMan()->getReservedGroups();
CPPUNIT_ASSERT_EQUAL((size_t)1, rgs.size());
CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/"),
(*rgs.begin()).second->getDownloadContext()->
(*rgs.begin())->getDownloadContext()->
getFirstFileEntry()->getRemainingUris().front());
}
// with options

5
test/TestUtil.cc
View File

@ -122,10 +122,9 @@ SharedHandle<RequestGroup> getReservedGroup
(const SharedHandle<RequestGroupMan>& rgman, size_t index)
{
assert(rgman->getReservedGroups().size() > index);
RequestGroupList::SeqType::const_iterator i =
rgman->getReservedGroups().begin();
RequestGroupList::const_iterator i = rgman->getReservedGroups().begin();
std::advance(i, index);
return (*i).second;
return *i;
}
SharedHandle<RequestGroup> createRequestGroup(int32_t pieceLength,