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

AbstractSingleDiskAdaptor: Use std::unique_ptr for diskWriter_

pull/106/head
Tatsuhiro Tsujikawa 2013-07-05 22:40:29 +09:00
parent f8d305fe63
commit ae84ff26e2
9 changed files with 60 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/AbstractSingleDiskAdaptor.cc
View File

@ -188,9 +188,9 @@ void AbstractSingleDiskAdaptor::cutTrailingGarbage()
} }
void AbstractSingleDiskAdaptor::setDiskWriter void AbstractSingleDiskAdaptor::setDiskWriter
(const std::shared_ptr<DiskWriter>& diskWriter) (std::unique_ptr<DiskWriter> diskWriter)
{ {
diskWriter_ = diskWriter; diskWriter_ = std::move(diskWriter);
} }
void AbstractSingleDiskAdaptor::setTotalLength(int64_t totalLength) void AbstractSingleDiskAdaptor::setTotalLength(int64_t totalLength)

6
src/AbstractSingleDiskAdaptor.h
View File

@ -44,7 +44,7 @@ class FileAllocationIterator;
class AbstractSingleDiskAdaptor : public DiskAdaptor { class AbstractSingleDiskAdaptor : public DiskAdaptor {
private: private:
std::shared_ptr<DiskWriter> diskWriter_; std::unique_ptr<DiskWriter> diskWriter_;
int64_t totalLength_; int64_t totalLength_;
bool readOnly_; bool readOnly_;
public: public:
@ -89,9 +89,9 @@ public:
virtual const std::string& getFilePath() = 0; virtual const std::string& getFilePath() = 0;
void setDiskWriter(const std::shared_ptr<DiskWriter>& diskWriter); void setDiskWriter(std::unique_ptr<DiskWriter> diskWriter);
const std::shared_ptr<DiskWriter>& getDiskWriter() const const std::unique_ptr<DiskWriter>& getDiskWriter() const
{ {
return diskWriter_; return diskWriter_;
} }

9
src/BtPostDownloadHandler.cc
View File

@ -73,11 +73,10 @@ void BtPostDownloadHandler::getNextRequestGroups
requestGroup->getFirstFilePath().c_str())); requestGroup->getFirstFilePath().c_str()));
std::shared_ptr<ValueBase> torrent; std::shared_ptr<ValueBase> torrent;
if(requestGroup->inMemoryDownload()) { if(requestGroup->inMemoryDownload()) {
const std::shared_ptr<DiskWriter>& dw = auto& dw = static_cast<AbstractSingleDiskAdaptor*>
std::static_pointer_cast<AbstractSingleDiskAdaptor> (requestGroup->getPieceStorage()->getDiskAdaptor().get())
(requestGroup->getPieceStorage()->getDiskAdaptor())->getDiskWriter(); ->getDiskWriter();
const std::shared_ptr<bittorrent::BencodeDiskWriter>& bdw = auto bdw = static_cast<bittorrent::BencodeDiskWriter*>(dw.get());
std::static_pointer_cast<bittorrent::BencodeDiskWriter>(dw);
int error = bdw->finalize(); int error = bdw->finalize();
if(error == 0) { if(error == 0) {
torrent = bdw->getResult(); torrent = bdw->getResult();

32
test/BtDependencyTest.cc
View File

@ -181,14 +181,16 @@ void BtDependencyTest::testResolve_metadata()
std::shared_ptr<RequestGroup> dependee = std::shared_ptr<RequestGroup> dependee =
createDependee(option_, "metadata", 0); createDependee(option_, "metadata", 0);
std::shared_ptr<DirectDiskAdaptor> diskAdaptor(new DirectDiskAdaptor()); auto diskAdaptor = std::make_shared<DirectDiskAdaptor>();
std::shared_ptr<ByteArrayDiskWriter> diskWriter(new ByteArrayDiskWriter()); {
diskAdaptor->setDiskWriter(diskWriter); auto diskWriter = make_unique<ByteArrayDiskWriter>();
diskWriter->setString diskWriter->setString
("d4:name19:aria2-0.8.2.tar.bz26:lengthi384e12:piece lengthi128e" ("d4:name19:aria2-0.8.2.tar.bz26:lengthi384e12:piece lengthi128e"
"6:pieces60:AAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCC" "6:pieces60:AAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCC"
"e"); "e");
std::shared_ptr<MockPieceStorage> pieceStorage(new MockPieceStorage()); diskAdaptor->setDiskWriter(std::move(diskWriter));
}
auto pieceStorage = std::make_shared<MockPieceStorage>();
pieceStorage->setDiskAdaptor(diskAdaptor); pieceStorage->setDiskAdaptor(diskAdaptor);
pieceStorage->setDownloadFinished(true); pieceStorage->setDownloadFinished(true);
dependee->setPieceStorage(pieceStorage); dependee->setPieceStorage(pieceStorage);
@ -206,9 +208,8 @@ void BtDependencyTest::testResolve_metadata()
void BtDependencyTest::testResolve_loadError() void BtDependencyTest::testResolve_loadError()
{ {
std::shared_ptr<RequestGroup> dependant = createDependant(option_); auto dependant = createDependant(option_);
std::shared_ptr<RequestGroup> dependee = auto dependee = createDependee(option_, "notExist", 40);
createDependee(option_, "notExist", 40);
dependee->getPieceStorage()->markAllPiecesDone(); dependee->getPieceStorage()->markAllPiecesDone();
BtDependency dep(dependant.get(), dependee); BtDependency dep(dependant.get(), dependee);
@ -222,8 +223,8 @@ void BtDependencyTest::testResolve_loadError()
void BtDependencyTest::testResolve_dependeeFailure() void BtDependencyTest::testResolve_dependeeFailure()
{ {
std::shared_ptr<RequestGroup> dependant = createDependant(option_); auto dependant = createDependant(option_);
std::shared_ptr<RequestGroup> dependee = createDependee(option_, "notExist", 40); auto dependee = createDependee(option_, "notExist", 40);
BtDependency dep(dependant.get(), dependee); BtDependency dep(dependant.get(), dependee);
CPPUNIT_ASSERT(dep.resolve()); CPPUNIT_ASSERT(dep.resolve());
@ -237,9 +238,8 @@ void BtDependencyTest::testResolve_dependeeFailure()
void BtDependencyTest::testResolve_dependeeInProgress() void BtDependencyTest::testResolve_dependeeInProgress()
{ {
std::string filename = A2_TEST_DIR"/single.torrent"; std::string filename = A2_TEST_DIR"/single.torrent";
std::shared_ptr<RequestGroup> dependant = createDependant(option_); auto dependant = createDependant(option_);
std::shared_ptr<RequestGroup> dependee = auto dependee = createDependee(option_, filename, File(filename).size());
createDependee(option_, filename, File(filename).size());
dependee->increaseNumCommand(); dependee->increaseNumCommand();
BtDependency dep(dependant.get(), dependee); BtDependency dep(dependant.get(), dependee);

26
test/DirectDiskAdaptorTest.cc
View File

@ -33,17 +33,13 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DirectDiskAdaptorTest);
void DirectDiskAdaptorTest::testCutTrailingGarbage() void DirectDiskAdaptorTest::testCutTrailingGarbage()
{ {
std::string dir = A2_TEST_OUT_DIR; std::string dir = A2_TEST_OUT_DIR;
std::shared_ptr<FileEntry> entry auto entry = std::make_shared<FileEntry>
(new FileEntry(dir+"/aria2_DirectDiskAdaptorTest_testCutTrailingGarbage", (dir+"/aria2_DirectDiskAdaptorTest_testCutTrailingGarbage",
256, 0)); 256, 0);
createFile(entry->getPath(), entry->getLength()+100); createFile(entry->getPath(), entry->getLength()+100);
auto fileEntries = std::vector<std::shared_ptr<FileEntry>>{entry};
std::vector<std::shared_ptr<FileEntry> > fileEntries;
fileEntries.push_back(entry);
DirectDiskAdaptor adaptor; DirectDiskAdaptor adaptor;
adaptor.setDiskWriter adaptor.setDiskWriter(make_unique<DefaultDiskWriter>(entry->getPath()));
(std::shared_ptr<DiskWriter>(new DefaultDiskWriter(entry->getPath())));
adaptor.setTotalLength(entry->getLength()); adaptor.setTotalLength(entry->getLength());
adaptor.setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor.setFileEntries(fileEntries.begin(), fileEntries.end());
adaptor.openFile(); adaptor.openFile();
@ -56,10 +52,14 @@ void DirectDiskAdaptorTest::testCutTrailingGarbage()
void DirectDiskAdaptorTest::testWriteCache() void DirectDiskAdaptorTest::testWriteCache()
{ {
std::shared_ptr<DirectDiskAdaptor> adaptor(new DirectDiskAdaptor()); auto adaptor = std::make_shared<DirectDiskAdaptor>();
std::shared_ptr<ByteArrayDiskWriter> dw(new ByteArrayDiskWriter()); ByteArrayDiskWriter* dw;
adaptor->setDiskWriter(dw); {
WrDiskCacheEntry cache(adaptor); auto sdw = make_unique<ByteArrayDiskWriter>();
dw = sdw.get();
adaptor->setDiskWriter(std::move(sdw));
}
WrDiskCacheEntry cache{adaptor};
std::string data1(4096, '1'), data2(4094, '2'); std::string data1(4096, '1'), data2(4094, '2');
cache.cacheData(createDataCell(5, data1.c_str())); cache.cacheData(createDataCell(5, data1.c_str()));
cache.cacheData(createDataCell(5+data1.size(), data2.c_str())); cache.cacheData(createDataCell(5+data1.size(), data2.c_str()));

9
test/PieceTest.cc
View File

@ -28,13 +28,14 @@ class PieceTest:public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE_END(); CPPUNIT_TEST_SUITE_END();
private: private:
std::shared_ptr<DirectDiskAdaptor> adaptor_; std::shared_ptr<DirectDiskAdaptor> adaptor_;
std::shared_ptr<ByteArrayDiskWriter> writer_; ByteArrayDiskWriter* writer_;
public: public:
void setUp() void setUp()
{ {
adaptor_.reset(new DirectDiskAdaptor()); adaptor_ = std::make_shared<DirectDiskAdaptor>();
writer_.reset(new ByteArrayDiskWriter()); auto dw = make_unique<ByteArrayDiskWriter>();
adaptor_->setDiskWriter(writer_); writer_ = dw.get();
adaptor_->setDiskWriter(std::move(dw));
} }
void testCompleteBlock(); void testCompleteBlock();

8
test/UTMetadataDataExtensionMessageTest.cc
View File

@ -66,8 +66,12 @@ void UTMetadataDataExtensionMessageTest::testToString()
void UTMetadataDataExtensionMessageTest::testDoReceivedAction() void UTMetadataDataExtensionMessageTest::testDoReceivedAction()
{ {
auto diskAdaptor = std::make_shared<DirectDiskAdaptor>(); auto diskAdaptor = std::make_shared<DirectDiskAdaptor>();
auto diskWriter = std::make_shared<ByteArrayDiskWriter>(); ByteArrayDiskWriter* diskWriter;
diskAdaptor->setDiskWriter(diskWriter); {
auto dw = make_unique<ByteArrayDiskWriter>();
diskWriter = dw.get();
diskAdaptor->setDiskWriter(std::move(dw));
}
auto pieceStorage = make_unique<MockPieceStorage>(); auto pieceStorage = make_unique<MockPieceStorage>();
pieceStorage->setDiskAdaptor(diskAdaptor); pieceStorage->setDiskAdaptor(diskAdaptor);
auto tracker = make_unique<UTMetadataRequestTracker>(); auto tracker = make_unique<UTMetadataRequestTracker>();

11
test/WrDiskCacheEntryTest.cc
View File

@ -19,13 +19,14 @@ class WrDiskCacheEntryTest:public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE_END(); CPPUNIT_TEST_SUITE_END();
std::shared_ptr<DirectDiskAdaptor> adaptor_; std::shared_ptr<DirectDiskAdaptor> adaptor_;
std::shared_ptr<ByteArrayDiskWriter> writer_; ByteArrayDiskWriter* writer_;
public: public:
void setUp() void setUp()
{ {
adaptor_.reset(new DirectDiskAdaptor()); adaptor_ = std::make_shared<DirectDiskAdaptor>();
writer_.reset(new ByteArrayDiskWriter()); auto dw = make_unique<ByteArrayDiskWriter>();
adaptor_->setDiskWriter(writer_); writer_ = dw.get();
adaptor_->setDiskWriter(std::move(dw));
} }
void testWriteToDisk(); void testWriteToDisk();
@ -48,7 +49,7 @@ void WrDiskCacheEntryTest::testWriteToDisk()
void WrDiskCacheEntryTest::testAppend() void WrDiskCacheEntryTest::testAppend()
{ {
WrDiskCacheEntry e(adaptor_); WrDiskCacheEntry e(adaptor_);
WrDiskCacheEntry::DataCell* cell = new WrDiskCacheEntry::DataCell(); auto cell = new WrDiskCacheEntry::DataCell{};
cell->goff = 0; cell->goff = 0;
size_t capacity = 6; size_t capacity = 6;
size_t offset = 2; size_t offset = 2;

9
test/WrDiskCacheTest.cc
View File

@ -17,13 +17,14 @@ class WrDiskCacheTest:public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE_END(); CPPUNIT_TEST_SUITE_END();
std::shared_ptr<DirectDiskAdaptor> adaptor_; std::shared_ptr<DirectDiskAdaptor> adaptor_;
std::shared_ptr<ByteArrayDiskWriter> writer_; ByteArrayDiskWriter* writer_;
public: public:
void setUp() void setUp()
{ {
adaptor_.reset(new DirectDiskAdaptor()); adaptor_ = std::make_shared<DirectDiskAdaptor>();
writer_.reset(new ByteArrayDiskWriter()); auto dw = make_unique<ByteArrayDiskWriter>();
adaptor_->setDiskWriter(writer_); writer_ = dw.get();
adaptor_->setDiskWriter(std::move(dw));
} }
void testAdd(); void testAdd();