Merge branch 'main' into v2

acoustid · Feb 25, 2024 · f0228e6 · f0228e6
2 parents 9e2a66b + c432e9c
commit f0228e6
Show file tree

Hide file tree

Showing 16 changed files with 27 additions and 31 deletions.
diff --git a/src/index/index_reader.cpp b/src/index/index_reader.cpp
@@ -33,9 +33,9 @@ IndexReader::~IndexReader()
 	}
 }
 
-SegmentDataReader* IndexReader::segmentDataReader(const SegmentInfo& segment)
+std::unique_ptr<SegmentDataReader> IndexReader::segmentDataReader(const SegmentInfo& segment)
 {
-	return new SegmentDataReader(m_dir->openFile(segment.dataFileName()), BLOCK_SIZE);
+	return std::make_unique<SegmentDataReader>(m_dir->openFile(segment.dataFileName()), BLOCK_SIZE);
 }
 
 bool IndexReader::containsDocument(uint32_t docId)

diff --git a/src/index/index_reader.h b/src/index/index_reader.h
@@ -34,7 +34,7 @@ class IndexReader
 
     std::vector<SearchResult> search(const std::vector<uint32_t> &fingerprint, int64_t timeoutInMSecs = 0);
 
-	SegmentDataReader* segmentDataReader(const SegmentInfo& segment);
+    std::unique_ptr<SegmentDataReader> segmentDataReader(const SegmentInfo& segment);
 
 protected:
 	DirectorySharedPtr m_dir;

diff --git a/src/index/index_writer.cpp b/src/index/index_writer.cpp
@@ -25,7 +25,7 @@ IndexWriter::IndexWriter(IndexSharedPtr index, bool alreadyHasLock) : IndexReade
     if (!alreadyHasLock) {
         m_index->acquireWriterLock();
     }
-    m_mergePolicy.reset(new SegmentMergePolicy());
+    m_mergePolicy = std::make_unique<SegmentMergePolicy>();
     m_info.incRevision();
 }
 

diff --git a/src/index/multi_index.cpp b/src/index/multi_index.cpp
@@ -47,7 +47,7 @@ bool MultiIndex::checkIndex(const QString &name) {
     if (name == ROOT_INDEX_NAME) {
         return Index::exists(m_dir);
     }
-    auto subDir = QSharedPointer<Directory>(m_dir->openDirectory(name));
+    auto subDir = m_dir->openDirectory(name);
     return Index::exists(subDir);
 }
 
@@ -71,7 +71,7 @@ QSharedPointer<Index> MultiIndex::getIndex(const QString &name, bool create) {
         m_indexes[name] = index;
         return index;
     }
-    auto subDir = QSharedPointer<Directory>(m_dir->openDirectory(name));
+    auto subDir = m_dir->openDirectory(name);
     index = QSharedPointer<Index>::create(subDir, create);
     m_indexes[name] = index;
     return index;

diff --git a/src/index/segment_data_reader.cpp b/src/index/segment_data_reader.cpp
@@ -20,9 +20,9 @@ void SegmentDataReader::setBlockSize(size_t blockSize)
 	m_blockSize = blockSize;
 }
 
-BlockDataIterator *SegmentDataReader::readBlock(size_t n, uint32_t key)
+std::unique_ptr<BlockDataIterator> SegmentDataReader::readBlock(size_t n, uint32_t key)
 {
 	m_input->seek(m_blockSize * n);
 	size_t length = m_input->readInt16();
-	return new BlockDataIterator(m_input.get(), length, key);
+	return std::make_unique<BlockDataIterator>(m_input.get(), length, key);
 }
diff --git a/src/index/segment_data_reader.h b/src/index/segment_data_reader.h
@@ -58,7 +58,7 @@ class SegmentDataReader
 	size_t blockSize() { return m_blockSize; }
 	void setBlockSize(size_t blockSize);
 
-	BlockDataIterator *readBlock(size_t n, uint32_t key);
+	std::unique_ptr<BlockDataIterator> readBlock(size_t n, uint32_t key);
 
 private:
 	std::unique_ptr<InputStream> m_input;

diff --git a/src/index/segment_enum.h b/src/index/segment_enum.h
@@ -14,7 +14,7 @@ class SegmentEnum
 {
 public:
 	SegmentEnum(SegmentIndexSharedPtr index, SegmentDataReader *dataReader)
-		: m_index(index), m_dataReader(dataReader)
+		: m_index(index), m_dataReader(std::move(dataReader))
 	{}
 
     void setFilter(const QSet<uint32_t> &excludeDocIds) { m_excludeDocIds = excludeDocIds; }
@@ -27,7 +27,7 @@ class SegmentEnum
                     return false;
                 }
                 uint32_t firstKey = m_index->key(m_block);
-                m_currentBlock.reset(m_dataReader->readBlock(m_block, firstKey));
+                m_currentBlock = m_dataReader->readBlock(m_block, firstKey);
                 m_currentBlock->next();
                 m_block++;
             }
@@ -53,7 +53,7 @@ class SegmentEnum
 	SegmentIndexSharedPtr m_index;
 	std::unique_ptr<SegmentDataReader> m_dataReader;
 	std::unique_ptr<BlockDataIterator> m_currentBlock;
-    QSet<uint32_t> m_excludeDocIds;
+  QSet<uint32_t> m_excludeDocIds;
 };
 
 }

diff --git a/src/index/segment_enum_test.cpp b/src/index/segment_enum_test.cpp
@@ -38,9 +38,8 @@ TEST(SegmentEnumTest, Iterate)
 	InputStream *indexInput = dir.openFile("segment_0.fii");
 	InputStream *dataInput = dir.openFile("segment_0.fid");
 	SegmentIndexSharedPtr index = SegmentIndexReader(indexInput, blockCount).read();
-	SegmentDataReader *dataReader = new SegmentDataReader(dataInput, 8);
 
-	SegmentEnum reader(index, dataReader);
+	SegmentEnum reader(index, std::make_unique<SegmentDataReader>(dataInput, 8));
 	ASSERT_TRUE(reader.next());
 	ASSERT_EQ(200, reader.key());
 	ASSERT_EQ(300, reader.value());

diff --git a/src/index/segment_merger_test.cpp b/src/index/segment_merger_test.cpp
@@ -61,14 +61,12 @@ TEST(SegmentMergerTest, Iterate)
 		InputStream *indexInput1 = dir.openFile("segment_0.fii");
 		InputStream *dataInput1 = dir.openFile("segment_0.fid");
 		SegmentIndexSharedPtr index1 = SegmentIndexReader(indexInput1, blockCount0).read();
-		SegmentDataReader *dataReader1 = new SegmentDataReader(dataInput1, 8);
-		SegmentEnum *reader1 = new SegmentEnum(index1, dataReader1);
+		SegmentEnum *reader1 = new SegmentEnum(index1, std::make_unique<SegmentDataReader>(dataInput1, 8));
 
 		InputStream *indexInput2 = dir.openFile("segment_1.fii");
 		InputStream *dataInput2 = dir.openFile("segment_1.fid");
 		SegmentIndexSharedPtr index2 = SegmentIndexReader(indexInput2, blockCount1).read();
-		SegmentDataReader *dataReader2 = new SegmentDataReader(dataInput2, 8);
-		SegmentEnum *reader2 = new SegmentEnum(index2, dataReader2);
+		SegmentEnum *reader2 = new SegmentEnum(index2, std::make_unique<SegmentDataReader>(dataInput2, 8));
 
 		SegmentMerger merger(writer);
 		merger.addSource(reader1);
@@ -79,8 +77,7 @@ TEST(SegmentMergerTest, Iterate)
 	InputStream *indexInput = dir.openFile("segment_2.fii");
 	InputStream *dataInput = dir.openFile("segment_2.fid");
 	SegmentIndexSharedPtr index = SegmentIndexReader(indexInput, blockCount).read();
-	SegmentDataReader *dataReader = new SegmentDataReader(dataInput, 8);
-	SegmentEnum reader(index, dataReader);
+	SegmentEnum reader(index, std::make_unique<SegmentDataReader>(dataInput, 8));
 
 	ASSERT_TRUE(reader.next());
 	ASSERT_EQ(199, reader.key());

diff --git a/src/index/segment_searcher.cpp b/src/index/segment_searcher.cpp
@@ -7,8 +7,8 @@
 
 using namespace Acoustid;
 
-SegmentSearcher::SegmentSearcher(SegmentIndexSharedPtr index, SegmentDataReader *dataReader, uint32_t lastKey)
-	: m_index(index), m_dataReader(dataReader), m_lastKey(lastKey)
+SegmentSearcher::SegmentSearcher(SegmentIndexSharedPtr index, std::unique_ptr<SegmentDataReader> &&dataReader, uint32_t lastKey)
+	: m_index(index), m_dataReader(std::move(dataReader)), m_lastKey(lastKey)
 {
 }
 

diff --git a/src/index/segment_searcher.h b/src/index/segment_searcher.h
@@ -14,7 +14,7 @@ class SegmentDataReader;
 class SegmentSearcher
 {
 public:
-	SegmentSearcher(SegmentIndexSharedPtr index, SegmentDataReader *dataReader, uint32_t lastKey = UINT32_MAX);
+	SegmentSearcher(SegmentIndexSharedPtr index, std::unique_ptr<SegmentDataReader> &&dataReader, uint32_t lastKey = UINT32_MAX);
 	virtual ~SegmentSearcher();
 
 	void search(const std::vector<uint32_t> &hashes, std::unordered_map<uint32_t, int> &hits);

diff --git a/src/store/directory.h b/src/store/directory.h
@@ -33,7 +33,7 @@ class Directory {
     virtual QStringList listDirectories() = 0;
     virtual bool fileExists(const QString &name);
 
-    virtual Directory *openDirectory(const QString &name) = 0;
+    virtual QSharedPointer<Directory> openDirectory(const QString &name) = 0;
 
     virtual bool exists() = 0;
     virtual void ensureExists() = 0;

diff --git a/src/store/fs_directory.cpp b/src/store/fs_directory.cpp
@@ -105,10 +105,10 @@ void FSDirectory::fsync(const QString &name) {
     }
 }
 
-Directory *FSDirectory::openDirectory(const QString &name) {
+QSharedPointer<Directory> FSDirectory::openDirectory(const QString &name) {
     QMutexLocker locker(&m_mutex);
     QString path = filePath(name);
-    return new FSDirectory(path, m_mmap);
+    return QSharedPointer<FSDirectory>::create(path, m_mmap);
 }
 
 FSDirectory *FSDirectory::openTemporary(bool autoDelete) {

diff --git a/src/store/fs_directory.h b/src/store/fs_directory.h
@@ -39,7 +39,7 @@ class FSDirectory : public Directory {
     virtual bool exists() override;
     virtual void ensureExists() override;
 
-    virtual Directory *openDirectory(const QString &name);
+    virtual QSharedPointer<Directory> openDirectory(const QString &name) override;
     virtual void deleteDirectory(const QString &name) override;
 
     void setAutoDelete(bool autoDelete) { m_autoDelete = autoDelete; }

diff --git a/src/store/ram_directory.cpp b/src/store/ram_directory.cpp
@@ -57,13 +57,13 @@ OutputStream *RAMDirectory::createFile(const QString &name) {
 
 const QByteArray &RAMDirectory::fileData(const QString &name) { return *m_data->files.value(name); }
 
-Directory *RAMDirectory::openDirectory(const QString &name) {
+QSharedPointer<Directory> RAMDirectory::openDirectory(const QString &name) {
     auto data = m_data->directories.value(name);
     if (!data) {
         data = QSharedPointer<RAMDirectoryData>::create();
         m_data->directories.insert(name, data);
     }
-    return new RAMDirectory(data);
+    return QSharedPointer<RAMDirectory>::create(data);
 }
 
 bool RAMDirectory::exists() { return true; }

diff --git a/src/store/ram_directory.h b/src/store/ram_directory.h
@@ -23,6 +23,7 @@ struct RAMDirectoryData {
 class RAMDirectory : public Directory {
  public:
     RAMDirectory();
+    explicit RAMDirectory(const QSharedPointer<RAMDirectoryData> &data);
     virtual ~RAMDirectory();
 
     virtual void close();
@@ -44,12 +45,11 @@ class RAMDirectory : public Directory {
     virtual bool exists() override;
     virtual void ensureExists() override;
 
-    virtual Directory *openDirectory(const QString &name) override;
+    virtual QSharedPointer<Directory> openDirectory(const QString &name) override;
 
     virtual void deleteDirectory(const QString &name) override;
 
  private:
-    RAMDirectory(const QSharedPointer<RAMDirectoryData> &data);
 
     QString m_dbPrefix;
     QSharedPointer<RAMDirectoryData> m_data;