1 /* <!-- copyright */ 2 /* 3 * aria2 - The high speed download utility 4 * 5 * Copyright (C) 2006 Tatsuhiro Tsujikawa 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 * 21 * In addition, as a special exception, the copyright holders give 22 * permission to link the code of portions of this program with the 23 * OpenSSL library under certain conditions as described in each 24 * individual source file, and distribute linked combinations 25 * including the two. 26 * You must obey the GNU General Public License in all respects 27 * for all of the code used other than OpenSSL. If you modify 28 * file(s) with this exception, you may extend this exception to your 29 * version of the file(s), but you are not obligated to do so. If you 30 * do not wish to do so, delete this exception statement from your 31 * version. If you delete this exception statement from all source 32 * files in the program, then also delete it here. 33 */ 34 /* copyright --> */ 35 #ifndef D_REQUEST_SLOT_H 36 #define D_REQUEST_SLOT_H 37 38 #include "common.h" 39 #include "TimerA2.h" 40 #include "Piece.h" 41 #include "wallclock.h" 42 43 namespace aria2 { 44 45 class RequestSlot { 46 public: 47 RequestSlot(size_t index, int32_t begin, int32_t length, size_t blockIndex, 48 std::shared_ptr<Piece> piece = nullptr) dispatchedTime_(global::wallclock ())49 : dispatchedTime_(global::wallclock()), 50 index_(index), 51 begin_(begin), 52 length_(length), 53 blockIndex_(blockIndex), 54 piece_(std::move(piece)) 55 { 56 } 57 RequestSlot()58 RequestSlot() 59 : dispatchedTime_(Timer::zero()), 60 index_(0), 61 begin_(0), 62 length_(0), 63 blockIndex_(0) 64 { 65 } 66 67 bool operator==(const RequestSlot& requestSlot) const 68 { 69 return index_ == requestSlot.index_ && begin_ == requestSlot.begin_ && 70 length_ == requestSlot.length_; 71 } 72 73 bool operator!=(const RequestSlot& requestSlot) const 74 { 75 return !(*this == requestSlot); 76 } 77 78 bool operator<(const RequestSlot& requestSlot) const 79 { 80 if (index_ == requestSlot.index_) { 81 return begin_ < requestSlot.begin_; 82 } 83 else { 84 return index_ < requestSlot.index_; 85 } 86 } 87 88 bool isTimeout(const std::chrono::seconds& t) const; 89 getIndex()90 size_t getIndex() const { return index_; } setIndex(size_t index)91 void setIndex(size_t index) { index_ = index; } 92 getBegin()93 int32_t getBegin() const { return begin_; } setBegin(int32_t begin)94 void setBegin(int32_t begin) { begin_ = begin; } 95 getLength()96 int32_t getLength() const { return length_; } setLength(int32_t length)97 void setLength(int32_t length) { length_ = length; } 98 getBlockIndex()99 size_t getBlockIndex() const { return blockIndex_; } setBlockIndex(size_t blockIndex)100 void setBlockIndex(size_t blockIndex) { blockIndex_ = blockIndex; } 101 getPiece()102 const std::shared_ptr<Piece>& getPiece() const { return piece_; } 103 104 // For unit test setDispatchedTime(Timer t)105 void setDispatchedTime(Timer t) { dispatchedTime_ = std::move(t); } 106 107 private: 108 Timer dispatchedTime_; 109 size_t index_; 110 int32_t begin_; 111 int32_t length_; 112 size_t blockIndex_; 113 114 // This is the piece whose index is index of this RequestSlot has. 115 // To detect duplicate RequestSlot, we have to find the piece using 116 // PieceStorage::getPiece() repeatedly. It turns out that this process 117 // takes time(about 1.7% of processing time). To reduce it, we put piece here 118 // at the construction of RequestSlot as a cache. 119 std::shared_ptr<Piece> piece_; 120 }; 121 122 } // namespace aria2 123 124 #endif // D_REQUEST_SLOT_H 125