PKDatasetFinder.cpp

Go to the documentation of this file.

// Simox
#include <SimoxUtility/algorithm/vector.hpp>
 
// BaseClass
#include "PKDatasetFinder.h"
 
// ArmarX
namespace armarx::priorknowledge::core
{
    void
    PKDatasetFinder::registerPropertyDefinitions(armarx::PropertyDefinitionsPtr& defs,
                                                 const std::string& prefix)
    {
        if (not defs->hasDefinition(prefix + "packageName"))
        {
            defs->optional(this->packageName,
                           prefix + "packageName",
                           "The name of the prior knowledge data package.");
        }
    }
 
    void
    PKDatasetFinder::init()
    {
        this->recalculateBasePath();
    }
 
    bool
    PKDatasetFinder::checkAll(const std::string& dataset) const
    {
        const std::filesystem::path absPathToDataset = this->getFullPath(dataset);
        if (std::filesystem::is_regular_file(absPathToDataset))
        {
            ARMARX_WARNING << "The entered path is leading to a file!";
            return false;
        }
 
        for (const auto& d : std::filesystem::directory_iterator(absPathToDataset))
        {
            if (!d.is_directory())
            {
                ARMARX_WARNING << "Found invalid path. Ignoring: " << d.path();
                continue;
            }
            std::string k = d.path().filename();
            if (simox::alg::contains(ID_BLACKLIST, k))
            {
                continue;
            }
 
            if (not this->check(dataset, k))
            {
                return false;
            }
        }
        return true;
    }
 
    bool
    PKDatasetFinder::checkAll() const
    {
        const std::filesystem::path absPath = Base::Base::getFullPath();
        if (std::filesystem::is_regular_file(absPath))
        {
            ARMARX_WARNING << "The entered path is leading to a file!";
            return false;
        }
 
        for (const auto& d : std::filesystem::directory_iterator(absPath))
        {
            if (!d.is_directory())
            {
                ARMARX_WARNING << "Found invalid path: " << d.path();
                continue;
            }
            std::string k = d.path().filename();
            if (simox::alg::contains(DATASET_FOLDERS_BLACKLIST, k))
            {
                continue;
            }
 
            if (not this->checkAll(k))
            {
                return false;
            }
        }
        return true;
    }
 
    bool
    PKDatasetFinder::check(const std::string& dataset, const std::string& id) const
    {
        if (simox::alg::contains(DATASET_FOLDERS_BLACKLIST, dataset))
        {
            return false;
        }
 
        if (simox::alg::contains(ID_BLACKLIST, id))
        {
            return false;
        }
 
        const std::filesystem::path idPath = std::filesystem::path(dataset) / id;
        const std::filesystem::path absPathToId = this->getFullPath(idPath);
 
        return this->accept(absPathToId);
    }
 
    bool
    PKDatasetFinder::check(const std::string& id) const
    {
        const std::filesystem::path absPath = Base::Base::getFullPath();
        if (std::filesystem::is_regular_file(absPath))
        {
            ARMARX_WARNING << "The entered path is leading to a file!";
            return false;
        }
 
        for (const auto& d : std::filesystem::directory_iterator(absPath))
        {
            if (!d.is_directory())
            {
                ARMARX_WARNING << "Found invalid path: " << d.path();
                continue;
            }
            std::string k = d.path().filename();
            if (simox::alg::contains(DATASET_FOLDERS_BLACKLIST, k))
            {
                continue;
            }
 
            if (this->check(k, id))
            {
                return true;
            }
        }
        return false;
    }
 
    std::optional<PKDatasetFinderInfo>
    PKDatasetFinder::find(const std::string& dataset, const std::string& id) const
    {
        const std::filesystem::path idPath = std::filesystem::path(dataset) / id;
        const std::filesystem::path absPathToId = this->getFullPath(idPath);
 
        if (this->check(dataset, id))
        {
            return PKDatasetFinderInfo{getPackageName(),
                                       getAbsolutePackagePath(),
                                       getRelativePath() / dataset,
                                       id,
                                       dataset,
                                       id};
        }
        return std::nullopt;
    }
 
    std::optional<PKDatasetFinderInfo>
    PKDatasetFinder::find(const std::string& id) const
    {
        const std::filesystem::path absPath = Base::Base::getFullPath();
        if (std::filesystem::is_regular_file(absPath))
        {
            ARMARX_WARNING << "The entered path is leading to a file!";
            return std::nullopt;
        }
 
        std::vector<PKDatasetFinderInfo> ret;
        for (const auto& d : std::filesystem::directory_iterator(absPath))
        {
            if (!d.is_directory())
            {
                ARMARX_WARNING << "Found invalid path: " << d.path();
                continue;
            }
            std::string k = d.path().filename();
            if (simox::alg::contains(DATASET_FOLDERS_BLACKLIST, k))
            {
                continue;
            }
 
            if (auto op = this->find(k, id); op.has_value())
            {
                return op;
            }
        }
        return std::nullopt;
    }
 
    std::vector<PKDatasetFinderInfo>
    PKDatasetFinder::findAll() const
    {
        const std::filesystem::path absPath = Base::Base::getFullPath();
        if (std::filesystem::is_regular_file(absPath))
        {
            ARMARX_WARNING << "The entered path is leading to a file!";
            return {};
        }
 
        std::vector<PKDatasetFinderInfo> ret;
        for (const auto& d : std::filesystem::directory_iterator(absPath))
        {
            if (!d.is_directory())
            {
                ARMARX_WARNING << "Found invalid path: " << d.path();
                continue;
            }
            std::string k = d.path().filename();
            if (simox::alg::contains(DATASET_FOLDERS_BLACKLIST, k))
            {
                continue;
            }
 
            auto idsForDataset = this->findAll(k);
            simox::alg::append(ret, idsForDataset);
        }
        return ret;
    }
 
    std::vector<PKDatasetFinderInfo>
    PKDatasetFinder::findAll(const std::string& dataset) const
    {
        const std::filesystem::path absPathToDataset = this->getFullPath(dataset);
        if (std::filesystem::is_regular_file(absPathToDataset))
        {
            ARMARX_WARNING << "The entered path is leading to a file!";
            return {};
        }
 
        std::vector<PKDatasetFinderInfo> ret;
        for (const auto& d : std::filesystem::directory_iterator(absPathToDataset))
        {
            if (!d.is_directory())
            {
                ARMARX_WARNING << "Found invalid path: " << d.path();
                continue;
            }
            std::string k = d.path().filename();
            if (simox::alg::contains(ID_BLACKLIST, k))
            {
                continue;
            }
 
            if (auto op = this->find(dataset, k); op.has_value())
            {
                ret.emplace_back(op.value());
            }
        }
        return ret;
    }
 
} // namespace armarx::priorknowledge::core