gerbera · KarlStraussberger · Jan 23, 2024 · Jan 21, 2024 · Jan 21, 2024 · Jan 22, 2024
diff --git a/src/action_request.cc b/src/action_request.cc
@@ -48,7 +48,7 @@ ActionRequest::ActionRequest(std::shared_ptr<UpnpXMLBuilder> xmlBuilder, std::sh
 {
     auto ctrlPtIPAddr = std::make_shared<GrbNet>(UpnpActionRequest_get_CtrlPtIPAddr(upnpRequest));
     std::string userAgent = UpnpActionRequest_get_Os_cstr(upnpRequest);
-    quirks = std::make_unique<Quirks>(xmlBuilder, clients, ctrlPtIPAddr, userAgent);
+    quirks = std::make_unique<Quirks>(std::move(xmlBuilder), clients, ctrlPtIPAddr, userAgent);
 }
 
 std::string ActionRequest::getActionName() const

diff --git a/src/config/config_generator.cc b/src/config/config_generator.cc
@@ -161,11 +161,8 @@ std::shared_ptr<pugi::xml_node> ConfigGenerator::setVector(config_option_t optio
     auto nodeKey = ConfigDefinition::mapConfigOption(cs->nodeOption);
     for (auto&& value : cs->getXmlContent({})) {
         setValue(fmt::format("{}/{}/", cs->xpath, nodeKey), "", true);
-        std::size_t index = 0;
-        for (auto&& [key, val] : value) {
+        for (auto&& [key, val] : value)
             setValue(fmt::format("{}/{}/attribute::{}", cs->xpath, nodeKey, key), val);
-            ++index;
-        }
     }
     return generated[cs->xpath];
 }

diff --git a/src/config/config_option_enum.h b/src/config/config_option_enum.h
@@ -32,17 +32,17 @@
 template <class Enum>
 class EnumOption : public ConfigOption {
 public:
-    explicit EnumOption(Enum option, const std::string& optionString)
+    explicit EnumOption(Enum option, std::string optionString)
         : option(option)
-        , optionString(optionString)
+        , optionString(std::move(optionString))
     {
     }
 
     std::string getOption() const override { return optionString.length() == 0 ? fmt::format("{}", option) : optionString; }
 
     Enum getEnumOption() const { return option; }
 
-    static Enum getEnumOption(const std::shared_ptr<Config> config, config_option_t option)
+    static Enum getEnumOption(const std::shared_ptr<Config>& config, config_option_t option)
     {
         auto optionValue = config->getConfigOption(option);
         auto optionEnumValue = std::dynamic_pointer_cast<EnumOption<Enum>>(optionValue);

diff --git a/src/config/config_options.h b/src/config/config_options.h
@@ -138,9 +138,9 @@ class Option : public ConfigOption {
 
 class IntOption : public ConfigOption {
 public:
-    explicit IntOption(IntOptionType option, const std::string& optionString = "")
+    explicit IntOption(IntOptionType option, std::string optionString = "")
         : option(option)
-        , optionString(optionString)
+        , optionString(std::move(optionString))
     {
     }
 
@@ -155,9 +155,9 @@ class IntOption : public ConfigOption {
 
 class UIntOption : public ConfigOption {
 public:
-    explicit UIntOption(UIntOptionType option, const std::string& optionString = "")
+    explicit UIntOption(UIntOptionType option, std::string optionString = "")
         : option(option)
-        , optionString(optionString)
+        , optionString(std::move(optionString))
     {
     }
 
@@ -172,9 +172,9 @@ class UIntOption : public ConfigOption {
 
 class LongOption : public ConfigOption {
 public:
-    explicit LongOption(LongOptionType option, const std::string& optionString = "")
+    explicit LongOption(LongOptionType option, std::string optionString = "")
         : option(option)
-        , optionString(optionString)
+        , optionString(std::move(optionString))
     {
     }
 

diff --git a/src/config/config_setup.h b/src/config/config_setup.h
@@ -133,7 +133,7 @@ class ConfigSetup {
 
     bool checkValue(std::string& optValue) const
     {
-        return !(rawCheck && !rawCheck(optValue));
+        return !rawCheck || rawCheck(optValue);
     }
     const char* getHelp() const { return help; }
     std::shared_ptr<ConfigOption> getValue() const { return optionValue; }

diff --git a/src/config/setup/config_setup_int.h b/src/config/setup/config_setup_int.h
@@ -30,7 +30,7 @@
 
 template <typename T, class OptionClass>
 class ConfigIntegerSetup : public ConfigSetup {
-    static_assert(std::is_integral<T>::value, "Integral required.");
+    static_assert(std::is_integral_v<T>, "Integral required.");
 
 public:
     using IntCheckFunction = std::function<bool(T value)>;
@@ -128,8 +128,8 @@ bool CheckProfileNumberValue(std::string& value);
 bool CheckImageQualityValue(IntOptionType value);
 bool CheckPortValue(UIntOptionType value);
 
-typedef ConfigIntegerSetup<IntOptionType, IntOption> ConfigIntSetup;
-typedef ConfigIntegerSetup<UIntOptionType, UIntOption> ConfigUIntSetup;
-typedef ConfigIntegerSetup<LongOptionType, LongOption> ConfigLongSetup;
+using ConfigIntSetup = ConfigIntegerSetup<IntOptionType, IntOption>;
+using ConfigUIntSetup = ConfigIntegerSetup<UIntOptionType, UIntOption>;
+using ConfigLongSetup = ConfigIntegerSetup<LongOptionType, LongOption>;
 
 #endif // __CONFIG_SETUP_INT_H__
diff --git a/src/config/setup/config_setup_vector.cc b/src/config/setup/config_setup_vector.cc
@@ -46,6 +46,7 @@ bool ConfigVectorSetup::createOptionFromNode(const pugi::xml_node& optValue, std
     if (optValue) {
         const auto dictNodes = optValue.select_nodes(ConfigDefinition::mapConfigOption(nodeOption));
         std::vector<std::string> attrList;
+        attrList.reserve(optionList.size());
         for (auto& opt : optionList) {
             attrList.push_back(ConfigDefinition::removeAttribute(opt));
         }

diff --git a/src/content/autoscan_inotify.cc b/src/content/autoscan_inotify.cc
@@ -356,7 +356,7 @@ int AutoscanInotify::addMoveWatch(const fs::path& path, int removeWd, int parent
 
         // add move watch
         auto watch = std::make_shared<WatchMove>(removeWd);
-        wdObj->addWatch(move(watch));
+        wdObj->addWatch(std::move(watch));
     }
     return wd;
 }

diff --git a/src/content/cm_task.cc b/src/content/cm_task.cc
@@ -67,12 +67,12 @@ void CMAddFileTask::run()
 }
 
 CMRemoveObjectTask::CMRemoveObjectTask(std::shared_ptr<ContentManager> content, std::shared_ptr<AutoscanDirectory> adir,
-    std::shared_ptr<CdsObject> object, const fs::path& path, bool rescanResource, bool all)
+    std::shared_ptr<CdsObject> object, fs::path path, bool rescanResource, bool all)
     : GenericTask(ContentManagerTask)
     , content(std::move(content))
     , adir(std::move(adir))
     , object(std::move(object))
-    , path(path)
+    , path(std::move(path))
     , all(all)
     , rescanResource(rescanResource)
 {

diff --git a/src/content/cm_task.h b/src/content/cm_task.h
@@ -68,7 +68,7 @@ class CMRemoveObjectTask : public GenericTask {
 
 public:
     CMRemoveObjectTask(std::shared_ptr<ContentManager> content, std::shared_ptr<AutoscanDirectory> adir,
-        std::shared_ptr<CdsObject> object, const fs::path& path, bool rescanResource, bool all);
+        std::shared_ptr<CdsObject> object, fs::path path, bool rescanResource, bool all);
     void run() override;
 };
 

diff --git a/src/content/content_manager.cc b/src/content/content_manager.cc
@@ -162,7 +162,7 @@ void ContentManager::run()
                 continue;
             }
         }
-        for (auto dir : config->getAutoscanListOption(CFG_IMPORT_AUTOSCAN_INOTIFY_LIST)) {
+        for (const auto& dir : config->getAutoscanListOption(CFG_IMPORT_AUTOSCAN_INOTIFY_LIST)) {
             fs::path path = dir->getLocation();
             if (fs::is_directory(path)) {
                 dir->setObjectID(ensurePathExistence(path));
@@ -413,7 +413,7 @@ std::shared_ptr<CdsObject> ContentManager::createSingleItem(
     bool processExisting,
     bool firstChild,
     const std::shared_ptr<AutoscanDirectory>& adir,
-    std::shared_ptr<CMAddFileTask> task)
+    const std::shared_ptr<CMAddFileTask>& task)
 {
     auto obj = checkDatabase ? database->findObjectByPath(dirEnt.path()) : nullptr;
     bool isNew = false;
@@ -474,27 +474,25 @@ std::shared_ptr<CdsObject> ContentManager::_addFile(const fs::directory_entry& d
         getImportService(asSetting.adir)->doImport(dirEnt.path(), asSetting, currentContent, task);
 
         return getImportService(asSetting.adir)->getObject(dirEnt.path());
-    } else {
-        // checkDatabase, don't process existing
-        std::shared_ptr<CdsContainer> parent;
-        auto parentObject = database->findObjectByPath(dirEnt.path().parent_path(), DbFileType::Directory);
-        if (parentObject && parentObject->isContainer())
-            parent = std::dynamic_pointer_cast<CdsContainer>(parentObject);
-        auto obj = createSingleItem(dirEnt, parent, rootPath, asSetting.followSymlinks, true, false, false, asSetting.adir, task);
-        if (!obj) // object ignored
-            return obj;
-
-        if (asSetting.recursive && obj->isContainer()) {
-            addRecursive(asSetting.adir, dirEnt, std::dynamic_pointer_cast<CdsContainer>(obj), asSetting.followSymlinks, asSetting.hidden, task);
-        }
+    }
+    // checkDatabase, don't process existing
+    std::shared_ptr<CdsContainer> parent;
+    auto parentObject = database->findObjectByPath(dirEnt.path().parent_path(), DbFileType::Directory);
+    if (parentObject && parentObject->isContainer())
+        parent = std::dynamic_pointer_cast<CdsContainer>(parentObject);
+    auto obj = createSingleItem(dirEnt, parent, rootPath, asSetting.followSymlinks, true, false, false, asSetting.adir, task);
+    if (!obj) // object ignored
+        return obj;
 
-        if (asSetting.rescanResource && obj->hasResource(ContentHandler::RESOURCE)) {
-            std::string parentPath = dirEnt.path().parent_path();
-            updateAttachedResources(asSetting.adir, obj, parentPath, true);
-        }
+    if (asSetting.recursive && obj->isContainer())
+        addRecursive(asSetting.adir, dirEnt, std::dynamic_pointer_cast<CdsContainer>(obj), asSetting.followSymlinks, asSetting.hidden, task);
 
-        return obj;
+    if (asSetting.rescanResource && obj->hasResource(ContentHandler::RESOURCE)) {
+        std::string parentPath = dirEnt.path().parent_path();
+        updateAttachedResources(asSetting.adir, obj, parentPath, true);
     }
+
+    return obj;
 }
 
 bool ContentManager::updateAttachedResources(const std::shared_ptr<AutoscanDirectory>& adir, const std::shared_ptr<CdsObject>& obj, const fs::path& parentPath, bool all)
@@ -531,7 +529,7 @@ bool ContentManager::updateAttachedResources(const std::shared_ptr<AutoscanDirec
     return parentRemoved;
 }
 
-std::vector<int> ContentManager::_removeObject(const std::shared_ptr<AutoscanDirectory>& adir, std::shared_ptr<CdsObject> obj, const fs::path& path, bool rescanResource, bool all)
+std::vector<int> ContentManager::_removeObject(const std::shared_ptr<AutoscanDirectory>& adir, const std::shared_ptr<CdsObject>& obj, const fs::path& path, bool rescanResource, bool all)
 {
     if (!obj || obj->getID() == INVALID_OBJECT_ID)
         return {};
@@ -1453,7 +1451,7 @@ void ContentManager::invalidateTask(unsigned int taskID, task_owner_t taskOwner)
 #endif
 }
 
-std::vector<int> ContentManager::removeObject(const std::shared_ptr<AutoscanDirectory>& adir, std::shared_ptr<CdsObject> obj, const fs::path& path, bool rescanResource, bool async, bool all)
+std::vector<int> ContentManager::removeObject(const std::shared_ptr<AutoscanDirectory>& adir, const std::shared_ptr<CdsObject>& obj, const fs::path& path, bool rescanResource, bool async, bool all)
 {
     if (async) {
         auto self = shared_from_this();

diff --git a/src/content/content_manager.h b/src/content/content_manager.h
@@ -124,7 +124,7 @@ class ContentManager : public Timer::Subscriber, public std::enable_shared_from_
         bool lowPriority = false, bool cancellable = true);
 
     int ensurePathExistence(const fs::path& path) const;
-    std::vector<int> removeObject(const std::shared_ptr<AutoscanDirectory>& adir, std::shared_ptr<CdsObject> obj, const fs::path& path, bool rescanResource, bool async = true, bool all = false);
+    std::vector<int> removeObject(const std::shared_ptr<AutoscanDirectory>& adir, const std::shared_ptr<CdsObject>& obj, const fs::path& path, bool rescanResource, bool async = true, bool all = false);
 
     /// \brief Updates an object in the database using the given parameters.
     /// \param objectID ID of the object to update
@@ -270,14 +270,14 @@ class ContentManager : public Timer::Subscriber, public std::enable_shared_from_
         const std::shared_ptr<CMAddFileTask>& task = nullptr);
 
     std::shared_ptr<ImportService> getImportService(const std::shared_ptr<AutoscanDirectory>& adir);
-    std::vector<int> _removeObject(const std::shared_ptr<AutoscanDirectory>& adir, std::shared_ptr<CdsObject> obj, const fs::path& path, bool rescanResource, bool all);
+    std::vector<int> _removeObject(const std::shared_ptr<AutoscanDirectory>& adir, const std::shared_ptr<CdsObject>& obj, const fs::path& path, bool rescanResource, bool all);
     void cleanupTasks(const fs::path& path);
 
     void scanDir(const std::shared_ptr<AutoscanDirectory>& dir, bool updateUI);
     void _rescanDirectory(const std::shared_ptr<AutoscanDirectory>& adir, int containerID, const std::shared_ptr<GenericTask>& task = nullptr);
     /* for recursive addition */
     void addRecursive(std::shared_ptr<AutoscanDirectory>& adir, const fs::directory_entry& subDir, const std::shared_ptr<CdsContainer>& parentContainer, bool followSymlinks, bool hidden, const std::shared_ptr<CMAddFileTask>& task);
-    std::shared_ptr<CdsObject> createSingleItem(const fs::directory_entry& dirEnt, const std::shared_ptr<CdsContainer>& parent, const fs::path& rootPath, bool followSymlinks, bool checkDatabase, bool processExisting, bool firstChild, const std::shared_ptr<AutoscanDirectory>& adir, std::shared_ptr<CMAddFileTask> task);
+    std::shared_ptr<CdsObject> createSingleItem(const fs::directory_entry& dirEnt, const std::shared_ptr<CdsContainer>& parent, const fs::path& rootPath, bool followSymlinks, bool checkDatabase, bool processExisting, bool firstChild, const std::shared_ptr<AutoscanDirectory>& adir, const std::shared_ptr<CMAddFileTask>& task);
     bool updateAttachedResources(const std::shared_ptr<AutoscanDirectory>& adir, const std::shared_ptr<CdsObject>& obj, const fs::path& parentPath, bool all);
     static void invalidateAddTask(const std::shared_ptr<GenericTask>& t, const fs::path& path);
 

diff --git a/src/content/import_service.cc b/src/content/import_service.cc
@@ -137,7 +137,7 @@ void ImportService::run(std::shared_ptr<ContentManager> content, std::shared_ptr
     this->content = std::move(content);
     if (autoScan) {
         this->autoscanDir = std::move(autoScan);
-        this->rootPath = path;
+        this->rootPath = std::move(path);
     }
 }
 
@@ -294,7 +294,7 @@ void ImportService::readDir(const fs::path& location, AutoScanSetting settings)
     log_debug("end {}", location.string());
 }
 
-void ImportService::cacheState(const fs::path& entryPath, const fs::directory_entry& dirEntry, ImportState state, std::chrono::seconds mtime, std::shared_ptr<CdsObject> cdsObject)
+void ImportService::cacheState(const fs::path& entryPath, const fs::directory_entry& dirEntry, ImportState state, std::chrono::seconds mtime, const std::shared_ptr<CdsObject>& cdsObject)
 {
     if (contentStateCache.find(entryPath) == contentStateCache.end()) {
         contentStateCache[entryPath] = std::make_shared<ContentState>(dirEntry, state, mtime, cdsObject);
@@ -359,14 +359,13 @@ bool ImportService::isHiddenFile(const fs::path& entryPath, bool isDirectory, co
         auto noMediaFile = (isDirectory) ? entryPath / noMediaName : entryPath.parent_path() / noMediaName;
         if (contentStateCache.find(noMediaFile) != contentStateCache.end()) {
             return contentStateCache[entryPath]->getState() != ImportState::Broken; // broken means: file not found
+        }
+        auto noMediaEntry = fs::directory_entry(noMediaFile, ec);
+        if (!noMediaEntry.exists(ec) || ec) {
+            cacheState(noMediaEntry, noMediaEntry, ImportState::Broken, toSeconds(dirEntry.last_write_time(ec)));
         } else {
-            auto noMediaEntry = fs::directory_entry(noMediaFile, ec);
-            if (!noMediaEntry.exists(ec) || ec) {
-                cacheState(noMediaEntry, noMediaEntry, ImportState::Broken, toSeconds(dirEntry.last_write_time(ec)));
-            } else {
-                // if file exists it will be automatically created
-                return true;
-            }
+            // if file exists it will be automatically created
+            return true;
         }
     }
     return false;
@@ -504,7 +503,7 @@ void ImportService::createItems(AutoScanSetting& settings)
 
 std::pair<bool, std::shared_ptr<CdsObject>> ImportService::createSingleItem(const fs::directory_entry& dirEntry) // ToDo: Use StateEntry here
 {
-    auto objectPath = dirEntry.path();
+    const auto& objectPath = dirEntry.path();
 
     /* retrieve information about item and decide if it should be included */
     auto [skip, mimetype] = mime->getMimeType(objectPath, MIMETYPE_DEFAULT);
@@ -551,7 +550,7 @@ std::pair<bool, std::shared_ptr<CdsObject>> ImportService::createSingleItem(cons
     return { skip, item };
 }
 
-void ImportService::updateSingleItem(const fs::directory_entry& dirEntry, std::shared_ptr<CdsItem> item, const std::string& mimetype)
+void ImportService::updateSingleItem(const fs::directory_entry& dirEntry, const std::shared_ptr<CdsItem>& item, const std::string& mimetype)
 {
     auto mTime = toSeconds(dirEntry.last_write_time(ec));
     item->setMTime(mTime);
@@ -575,7 +574,7 @@ void ImportService::fillLayout(const std::shared_ptr<GenericTask>& task)
 /// \param object used to make code compatible with legacy scan
 void ImportService::fillSingleLayout(const std::shared_ptr<ContentState>& state, std::shared_ptr<CdsObject> object, const std::shared_ptr<CdsContainer>& parent, const std::shared_ptr<GenericTask>& task)
 {
-    std::shared_ptr<CdsObject> cdsObject = state ? state->getObject() : object;
+    std::shared_ptr<CdsObject> cdsObject = state ? state->getObject() : std::move(object);
 
     if (cdsObject && cdsObject->isItem() && layout) {
         try {
@@ -604,7 +603,7 @@ void ImportService::fillSingleLayout(const std::shared_ptr<ContentState>& state,
 #ifdef HAVE_JS
             try {
                 if (playlistParserScript && contentType == CONTENT_TYPE_PLAYLIST)
-                    playlistParserScript->processPlaylistObject(cdsObject, std::move(task), rootPath);
+                    playlistParserScript->processPlaylistObject(cdsObject, task, rootPath);
             } catch (const std::runtime_error& e) {
                 log_error("{}", e.what());
             }

diff --git a/src/content/import_service.h b/src/content/import_service.h
@@ -83,26 +83,26 @@ class ContentState {
     std::shared_ptr<CdsContainer> parentObject;
 
 public:
-    ContentState(const fs::directory_entry& dirEntry, ImportState state, std::chrono::seconds mtime = std::chrono::seconds::zero(), std::shared_ptr<CdsObject> cdsObject = nullptr)
+    ContentState(fs::directory_entry dirEntry, ImportState state, std::chrono::seconds mtime = std::chrono::seconds::zero(), std::shared_ptr<CdsObject> cdsObject = nullptr)
         : state(state)
-        , dirEntry(dirEntry)
+        , dirEntry(std::move(dirEntry))
         , mtime(mtime)
-        , cdsObject(cdsObject)
+        , cdsObject(std::move(cdsObject))
     {
     }
 
     void setObject(ImportState state, std::shared_ptr<CdsObject> cdsObject)
     {
         this->state = state;
-        this->cdsObject = cdsObject;
+        this->cdsObject = std::move(cdsObject);
     }
     void setFirstObject(std::shared_ptr<CdsObject> firstObject)
     {
-        this->firstObject = firstObject;
+        this->firstObject = std::move(firstObject);
     }
     void setParentObject(std::shared_ptr<CdsContainer> parentObject)
     {
-        this->parentObject = parentObject;
+        this->parentObject = std::move(parentObject);
     }
     std::shared_ptr<CdsObject> getObject() { return cdsObject; }
     std::shared_ptr<CdsObject> getFirstObject() { return firstObject; }
@@ -182,13 +182,13 @@ class ImportService {
     void readFile(const fs::path& location);
     void createContainers(int parentContainerId, AutoScanSetting& settings);
     void createItems(AutoScanSetting& settings);
-    void updateSingleItem(const fs::directory_entry& dirEntry, std::shared_ptr<CdsItem> item, const std::string& mimetype);
+    void updateSingleItem(const fs::directory_entry& dirEntry, const std::shared_ptr<CdsItem>& item, const std::string& mimetype);
     void fillLayout(const std::shared_ptr<GenericTask>& task);
     void updateFanArt();
     void assignFanArt(const std::shared_ptr<CdsContainer>& container, const std::shared_ptr<CdsObject>& refObj, int count);
     void removeHidden(AutoScanSetting& settings);
 
-    void cacheState(const fs::path& entryPath, const fs::directory_entry& dirEntry, ImportState state, std::chrono::seconds mtime = std::chrono::seconds::zero(), std::shared_ptr<CdsObject> cdsObject = nullptr);
+    void cacheState(const fs::path& entryPath, const fs::directory_entry& dirEntry, ImportState state, std::chrono::seconds mtime = std::chrono::seconds::zero(), const std::shared_ptr<CdsObject>& cdsObject = nullptr);
 
 public:
     ImportService(std::shared_ptr<Context> context);