MockPieceStorage.h 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289
  1. #ifndef D_MOCK_PIECE_STORAGE_H
  2. #define D_MOCK_PIECE_STORAGE_H
  3. #include "PieceStorage.h"
  4. #include <algorithm>
  5. #include "BitfieldMan.h"
  6. #include "Piece.h"
  7. #include "DiskAdaptor.h"
  8. namespace aria2 {
  9. class MockPieceStorage : public PieceStorage {
  10. private:
  11. uint64_t totalLength;
  12. uint64_t filteredTotalLength;
  13. uint64_t completedLength;
  14. uint64_t filteredCompletedLength;
  15. BitfieldMan* bitfieldMan;
  16. bool selectiveDownloadingMode;
  17. bool endGame;
  18. SharedHandle<DiskAdaptor> diskAdaptor;
  19. std::deque<size_t> pieceLengthList;
  20. std::deque<SharedHandle<Piece> > inFlightPieces;
  21. bool downloadFinished_;
  22. bool allDownloadFinished_;
  23. public:
  24. MockPieceStorage():totalLength(0),
  25. filteredTotalLength(0),
  26. completedLength(0),
  27. filteredCompletedLength(0),
  28. bitfieldMan(0),
  29. selectiveDownloadingMode(false),
  30. endGame(false),
  31. downloadFinished_(false),
  32. allDownloadFinished_(false) {}
  33. virtual ~MockPieceStorage() {}
  34. #ifdef ENABLE_BITTORRENT
  35. virtual bool hasMissingPiece(const SharedHandle<Peer>& peer) {
  36. return false;
  37. }
  38. virtual void getMissingPiece
  39. (std::vector<SharedHandle<Piece> >& pieces,
  40. size_t minMissingBlocks,
  41. const SharedHandle<Peer>& peer,
  42. cuid_t cuid)
  43. {}
  44. virtual void getMissingPiece
  45. (std::vector<SharedHandle<Piece> >& pieces,
  46. size_t minMissingBlocks,
  47. const SharedHandle<Peer>& peer,
  48. const std::vector<size_t>& excludedIndexes,
  49. cuid_t cuid)
  50. {}
  51. virtual void getMissingFastPiece
  52. (std::vector<SharedHandle<Piece> >& pieces,
  53. size_t minMissingBlocks,
  54. const SharedHandle<Peer>& peer,
  55. cuid_t cuid)
  56. {}
  57. virtual void getMissingFastPiece
  58. (std::vector<SharedHandle<Piece> >& pieces,
  59. size_t minMissingBlocks,
  60. const SharedHandle<Peer>& peer,
  61. const std::vector<size_t>& excludedIndexes,
  62. cuid_t cuid)
  63. {}
  64. virtual SharedHandle<Piece> getMissingPiece
  65. (const SharedHandle<Peer>& peer,
  66. cuid_t cuid)
  67. {
  68. return SharedHandle<Piece>(new Piece());
  69. }
  70. virtual SharedHandle<Piece> getMissingPiece
  71. (const SharedHandle<Peer>& peer,
  72. const std::vector<size_t>& excludedIndexes,
  73. cuid_t cuid)
  74. {
  75. return SharedHandle<Piece>(new Piece());
  76. }
  77. #endif // ENABLE_BITTORRENT
  78. virtual bool hasMissingUnusedPiece()
  79. {
  80. return false;
  81. }
  82. virtual SharedHandle<Piece> getMissingPiece
  83. (size_t minSplitSize,
  84. const unsigned char* ignoreBitfield,
  85. size_t length,
  86. cuid_t cuid)
  87. {
  88. return SharedHandle<Piece>(new Piece());
  89. }
  90. virtual SharedHandle<Piece> getMissingPiece(size_t index, cuid_t cuid)
  91. {
  92. return SharedHandle<Piece>(new Piece());
  93. }
  94. virtual bool isPieceUsed(size_t index)
  95. {
  96. return false;
  97. }
  98. virtual void markPieceMissing(size_t index) {}
  99. virtual void markPiecesDone(uint64_t) {}
  100. virtual SharedHandle<Piece> getPiece(size_t index) {
  101. return SharedHandle<Piece>(new Piece());
  102. }
  103. virtual void completePiece(const SharedHandle<Piece>& piece) {}
  104. virtual void cancelPiece(const SharedHandle<Piece>& piece, cuid_t cuid) {}
  105. virtual bool hasPiece(size_t index) {
  106. return false;
  107. }
  108. virtual uint64_t getTotalLength() {
  109. return totalLength;
  110. }
  111. void setTotalLength(uint64_t totalLength) {
  112. this->totalLength = totalLength;
  113. }
  114. virtual uint64_t getFilteredTotalLength() {
  115. return filteredTotalLength;
  116. }
  117. void setFilteredTotalLength(uint64_t totalLength) {
  118. this->filteredTotalLength = totalLength;
  119. }
  120. virtual uint64_t getCompletedLength() {
  121. return completedLength;
  122. }
  123. void setCompletedLength(uint64_t completedLength) {
  124. this->completedLength = completedLength;
  125. }
  126. virtual uint64_t getFilteredCompletedLength() {
  127. return filteredCompletedLength;
  128. }
  129. void setFilteredCompletedLength(uint64_t completedLength) {
  130. this->filteredCompletedLength = completedLength;
  131. }
  132. virtual void setupFileFilter() {}
  133. virtual void clearFileFilter() {}
  134. virtual bool downloadFinished() {
  135. return downloadFinished_;
  136. }
  137. void setDownloadFinished(bool f)
  138. {
  139. downloadFinished_ = f;
  140. }
  141. virtual bool allDownloadFinished() {
  142. return allDownloadFinished_;
  143. }
  144. void setAllDownloadFinished(bool f)
  145. {
  146. allDownloadFinished_ = f;
  147. }
  148. virtual void initStorage() {}
  149. virtual const unsigned char* getBitfield() {
  150. return bitfieldMan->getBitfield();
  151. }
  152. virtual void setBitfield(const unsigned char* bitfield,
  153. size_t bitfieldLength) {
  154. bitfieldMan->setBitfield(bitfield, bitfieldLength);
  155. }
  156. virtual size_t getBitfieldLength() {
  157. return bitfieldMan->getBitfieldLength();
  158. }
  159. void setBitfield(BitfieldMan* bitfieldMan) {
  160. this->bitfieldMan = bitfieldMan;
  161. }
  162. virtual bool isSelectiveDownloadingMode() {
  163. return selectiveDownloadingMode;
  164. }
  165. void setSelectiveDownloadingMode(bool flag) {
  166. this->selectiveDownloadingMode = flag;
  167. }
  168. virtual bool isEndGame() {
  169. return endGame;
  170. }
  171. virtual void setEndGamePieceNum(size_t num) {}
  172. virtual void enterEndGame() {
  173. this->endGame = true;
  174. }
  175. virtual SharedHandle<DiskAdaptor> getDiskAdaptor() {
  176. return diskAdaptor;
  177. }
  178. void setDiskAdaptor(const SharedHandle<DiskAdaptor>& adaptor) {
  179. this->diskAdaptor = adaptor;
  180. }
  181. virtual size_t getPieceLength(size_t index) {
  182. return pieceLengthList.at(index);
  183. }
  184. void addPieceLengthList(size_t length) {
  185. pieceLengthList.push_back(length);
  186. }
  187. virtual void advertisePiece(cuid_t cuid, size_t index) {}
  188. virtual void getAdvertisedPieceIndexes(std::vector<size_t>& indexes,
  189. cuid_t myCuid,
  190. const Timer& lastCheckTime)
  191. {}
  192. virtual void removeAdvertisedPiece(time_t elapsed) {}
  193. virtual void markAllPiecesDone() {}
  194. virtual void addInFlightPiece(const std::vector<SharedHandle<Piece> >& pieces)
  195. {
  196. std::copy(pieces.begin(), pieces.end(), back_inserter(inFlightPieces));
  197. }
  198. virtual size_t countInFlightPiece()
  199. {
  200. return inFlightPieces.size();
  201. }
  202. virtual void getInFlightPieces(std::vector<SharedHandle<Piece> >& pieces)
  203. {
  204. pieces.insert(pieces.end(), inFlightPieces.begin(), inFlightPieces.end());
  205. }
  206. virtual void addPieceStats(size_t index) {}
  207. virtual void addPieceStats(const unsigned char* bitfield,
  208. size_t bitfieldLength) {}
  209. virtual void subtractPieceStats(const unsigned char* bitfield,
  210. size_t bitfieldLength) {}
  211. virtual void updatePieceStats(const unsigned char* newBitfield,
  212. size_t newBitfieldLength,
  213. const unsigned char* oldBitfield) {}
  214. virtual size_t getNextUsedIndex(size_t index)
  215. {
  216. return 0;
  217. }
  218. virtual void onDownloadIncomplete() {}
  219. };
  220. } // namespace aria2
  221. #endif // D_MOCK_PIECE_STORAGE_H