Utilities.h

#pragma once

#include "XDGFilePaths.h"
#include <iterator>
#include <algorithm>

#define XSTR(arg) STR(arg)  
#define STR(arg) #arg       

#define FILE_LOC " -- ", __FILE__, ':', __LINE__    

namespace rose {

    template<typename U, typename C>
    bool oneFlagOf(U flag, C container) {
        static_assert(std::is_unsigned_v<U>, "Argument flag must be unsigned type." );
        static_assert(std::is_unsigned_v<typename C::value_type>, "Container must hold an unsigned type.");
        return std::any_of(container.begin(), container.end(), [&flag](typename C::value_type value){
            return flag == value;
        });
    }

    template<class ContainerType>
    class ReverseContainerView {
    protected:
        ContainerType &mContainer;      

    public:
        ReverseContainerView() = delete;

        explicit ReverseContainerView(ContainerType &container) : mContainer(container) {}

        auto begin() {
            return std::rbegin(mContainer);
        }

        auto end() {
            return std::rend(mContainer);
        }
    };

    template<class ContainerType>
    class ContainerView {
    protected:
        ContainerType &mContainer;      

    public:
        ContainerView() = delete;

        explicit ContainerView(ContainerType &container) : mContainer(container) {}

        auto begin() {
            return std::begin(mContainer);
        }

        auto end() {
            return std::end(mContainer);
        }
    };

    template<typename Arg, typename... Args>
    std::string StringCompositor(Arg &&arg, Args &&... args) {
        std::stringstream out;
        out << std::forward<Arg>(arg);
        ((out << std::forward<Args>(args)), ...);
        return out.str();
    }

    class Environment {
    protected:
        Environment();

        std::filesystem::path mHomeDirectory;       
        std::filesystem::path mDataHome;            
        std::filesystem::path mConfigHome;          
        std::filesystem::path mCacheHome;           
        std::filesystem::path mAppResources;        

        std::filesystem::path mLibResources;
        XDGFilePaths mFilePaths{};                  

        std::string mAppName;                       

    public:
        ~Environment() = default;

        Environment(const Environment &) = delete;

        Environment(Environment &&) = delete;

        Environment& operator=(const Environment &) = delete;

        Environment& operator=(Environment &&) = delete;

        static Environment &getEnvironment() {
            static Environment instance{};
            return instance;
        }

        [[nodiscard]] const std::string& appName() const { return mAppName; }

        [[nodiscard]] const std::filesystem::path& configHome() const { return mConfigHome; }

        [[nodiscard]] const std::filesystem::path& cacheHome() const { return mCacheHome; }

        [[nodiscard]] const std::filesystem::path& dataHome() const { return mDataHome; }

        [[nodiscard]] const std::filesystem::path& appResources() const { return mAppResources; }

        template<typename Source>
        std::filesystem::path appResourcesAppend(Source source) {
            auto path = mAppResources;
            return path.append(source);
        }

        std::filesystem::path getenv_path(XDGFilePaths::XDG_Name name, const std::string &appName, bool create);
    };
}