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
(const std::shared_ptr<DiskWriter>& diskWriter)
(std::unique_ptr<DiskWriter> diskWriter)
{
diskWriter_ = diskWriter;
diskWriter_ = std::move(diskWriter);
}
void AbstractSingleDiskAdaptor::setTotalLength(int64_t totalLength)

6
src/AbstractSingleDiskAdaptor.h
View File

@ -44,7 +44,7 @@ class FileAllocationIterator;
class AbstractSingleDiskAdaptor : public DiskAdaptor {
private:
std::shared_ptr<DiskWriter> diskWriter_;
std::unique_ptr<DiskWriter> diskWriter_;
int64_t totalLength_;
bool readOnly_;
public:
@ -89,9 +89,9 @@ public:
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_;
}

9
src/BtPostDownloadHandler.cc
View File

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

32
test/BtDependencyTest.cc
View File

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

26
test/DirectDiskAdaptorTest.cc
View File

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

8
test/UTMetadataDataExtensionMessageTest.cc
View File

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

11
test/WrDiskCacheEntryTest.cc
View File

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

9
test/WrDiskCacheTest.cc
View File

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