FinderInfoBase.h

Go to the documentation of this file.

#pragma once
 
// STD/STL
#include <filesystem>
#include <optional>
#include <string>
 
// Base Class
#include <ArmarXCore/core/logging/Logging.h>
 
// ArmarX
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/system/ArmarXDataPath.h>
 
namespace armarx::priorknowledge::core
{
    struct PackageFileLocation
    {
        /// Name of the ArmarX package.
        std::string package;
 
        /// Relative to the package's data directory.
        std::filesystem::path relativePath;
 
        /// The absolute path (in the host's file system).
        std::filesystem::path absolutePath;
    };
 
    /**
     * @brief The FinderInfoBase class
     * Indicates an into to 'something' of type IDType
     */
    template <class IDType>
    class FinderInfoBase
    {
    public:
        FinderInfoBase(const std::string& packageName,
                       const std::filesystem::path& absPackageDataPath, // the path to the data dir
                       const std::filesystem::path&
                           relPathToId, // the path to 'something' from data/packageName
                       const IDType& id) :
            packageName(packageName),
            absPackageDataPath(absPackageDataPath),
            relPathToId(relPathToId),
            id(id)
        {
        }
 
        virtual ~FinderInfoBase()
        {
        }
 
        PackageFileLocation
        toPackageFileLocation()
        {
            return {getPackageName(), getRelativePath(), getFullPath()};
        }
 
        std::string
        getPackageName() const
        {
            return packageName;
        }
 
        std::filesystem::path
        getRelativePath() const
        {
            return relPathToId;
        }
 
        std::filesystem::path
        getAbsolutePackageDataPath() const
        {
            checkAbsolutePathIsValid();
            return absPackageDataPath;
        }
 
        virtual std::filesystem::path
        getFullPath() const
        {
            checkAbsolutePathIsValid();
            return absPackageDataPath / packageName / relPathToId;
        }
 
        IDType
        getID() const
        {
            return id;
        }
 
    protected:
        void
        checkAbsolutePathIsValid() const
        {
            if (!std::filesystem::exists(absPackageDataPath))
            {
                ARMARX_ERROR << "Could not resolve absolute path for package '" << packageName
                             << "'.";
            }
        }
 
 
    protected:
        bool logError = true;
 
    private:
        std::string packageName;
        std::filesystem::path absPackageDataPath;
        std::filesystem::path relPathToId;
        IDType id;
    };
 
    /**
     * @brief The DatasetFinderInfoBase class
     * Indicates an into to 'something' of type IDType inside a dataset of type DatasetType
     */
    template <class IDType, class DatasetType>
    class DatasetFinderInfoBase : public FinderInfoBase<IDType>
    {
 
    public:
        using Base = FinderInfoBase<IDType>;
 
        DatasetFinderInfoBase(
            const std::string& packageName,
            const std::filesystem::path& absPackageDataDir,
            const std::filesystem::path&
                relDatasetPath, // the path to the dataset from data/packageName
            const std::filesystem::path& relPath, // the path to 'something' from the dataset
            const DatasetType& dataset,
            const IDType& id) :
            Base(packageName, absPackageDataDir, (relDatasetPath / relPath), id),
            dataset(dataset),
            relDatasetPath(relDatasetPath)
        {
        }
 
        virtual ~DatasetFinderInfoBase()
        {
        }
 
        DatasetType
        getDataset() const
        {
            return dataset;
        }
 
    private:
        DatasetType dataset;
        std::filesystem::path relDatasetPath;
    };
 
} // namespace armarx::priorknowledge::core