substream_name_filter.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <adtfstreaming3/streamtype_intf.h>
 
#include <regex>
 
namespace adtf
{
namespace filter
{
namespace private_implementations
{
class cSubstreamNameFilter
{
public:
    enum class tFilterMode : uint8_t
    {
        Plain = 0,
        PrefixTrim = 1,
        Prefix = 2,
        Wildcard = 3,
        Regex = 4
    };
 
public:
    struct tFilterBase
    {
    protected:
        tFilterBase(std::string_view strFilterString): strFilter(strFilterString)
        {
        }

        std::string strFilter;
 
    public:
        virtual bool Matches(std::string_view strInput) const noexcept = 0;
 
    public:
        inline std::string_view GetFilterString() const noexcept
        {
            return strFilter;
        }

        virtual bool GetTrim() const noexcept
        {
            return false;
        }

        virtual bool PrefixMatches(std::string_view strPrefix) const noexcept
        {
            return strPrefix.substr(0, strFilter.length()) == GetFilterString().substr(0, strPrefix.length());
        }
    };

    struct tPlain final : public tFilterBase
    {
    public:
        tPlain(std::string_view strFilterString): tFilterBase(strFilterString)
        {
        }

        inline bool Matches(std::string_view strInput) const noexcept override
        {
            return strFilter == strInput;
        }

        inline bool operator==(const tPlain& oOther) const noexcept
        {
            return strFilter == oOther.strFilter;
        }
    };

    struct tPrefix final : public tFilterBase
    {
    protected:
        bool bTrim;
 
    public:
        tPrefix(std::string_view strFilterString, bool bTrim): tFilterBase(strFilterString), bTrim(bTrim)
        {
        }

        inline bool GetTrim() const noexcept override
        {
            return bTrim;
        }

        inline bool Matches(std::string_view strInput) const noexcept override
        {
            return strInput.substr(0, strFilter.length()) == strFilter;
        }

        inline bool operator==(const tPrefix& oOther) const noexcept
        {
            return strFilter == oOther.strFilter && bTrim == oOther.bTrim;
        }
    };

    struct tRegexFilterBase : public tFilterBase
    {
    private:
        std::regex oRegex;
 
    protected:
        tRegexFilterBase(std::string_view strFilterString, std::string_view strRegex):
            tFilterBase(strFilterString), oRegex(strRegex.begin(), strRegex.end())
        {
        }
 
    public:
        inline bool Matches(std::string_view strInput) const noexcept final override
        {
            return std::regex_match(strInput.begin(), strInput.end(), oRegex);
        }

        inline bool PrefixMatches(std::string_view /* strPrefix */) const noexcept final override
        {
            return true;
        }
    };

    struct tRegex final : public tRegexFilterBase
    {
    public:
        tRegex(std::string_view strFilterString): tRegexFilterBase(strFilterString, strFilterString)
        {
        }

        inline bool operator==(const tRegex& oOther) const noexcept
        {
            return strFilter == oOther.strFilter;
        }
    };

    struct tWildcard final : public tRegexFilterBase
    {
    public:
        tWildcard(std::string_view strFilterString):
            tRegexFilterBase(strFilterString, cSubstreamNameFilter::WildcardToRegex(std::string(strFilterString)))
        {
        }

        inline bool operator==(const tWildcard& oOther) const noexcept
        {
            return strFilter == oOther.strFilter;
        }
    };

    using tFilter = std::variant<tPlain, tPrefix, tWildcard, tRegex>;
    using tStreamAttributes = std::map<std::string, std::variant<bool, double, std::string>>;

    struct tStreamFilter
    {
        tFilter xFilter;
        tStreamAttributes oAttributes;

        inline std::string_view GetFilterString() const noexcept
        {
            return std::visit([](auto&& oFilter) noexcept -> std::string_view { return oFilter.GetFilterString(); },
                              xFilter);
        }

        inline bool GetTrim() const noexcept
        {
            return std::visit([](auto&& oFilter) noexcept -> bool { return oFilter.GetTrim(); }, xFilter);
        }

        inline bool Matches(std::string_view strInput) const noexcept
        {
            return std::visit([&](auto&& oFilter) noexcept -> bool { return oFilter.Matches(strInput); }, xFilter);
        }

        inline bool PrefixMatches(std::string_view strPrefix) const noexcept
        {
            return std::visit([&](auto&& oFilter) noexcept -> bool { return oFilter.PrefixMatches(strPrefix); },
                              xFilter);
        }

        inline bool HasAttribute(const std::string& strAttributeName) const noexcept
        {
            return oAttributes.find(strAttributeName) != oAttributes.end();
        }

        template<typename T>
        inline T GetAttributeValue(const std::string& strAttributeName) const
        {
            if (auto it = oAttributes.find(strAttributeName); it != oAttributes.end())
            {
                if (std::holds_alternative<T>(it->second))
                {
                    return std::get<T>(it->second);
                }
                else
                {
                    THROW_ERROR_DESC(ERR_INVALID_TYPE, "There is no attribute with the requested type.");
                }
            }
            else
            {
                THROW_ERROR_DESC(ERR_NOT_FOUND, "Attribute '%s' not found.", strAttributeName.c_str());
            }
        }
    };
 
private:
    class ISubstreamNameFilterParser
    {
    public:
        struct tContext
        {
            std::optional<tFilterMode> eFilterMode{};
        };
 
    public:
        virtual std::vector<tStreamFilter> ReadFromFile(std::string_view strFileName,
                                                        const tContext& oContext) const = 0;
        virtual void WriteToFile(std::string_view strFileName,
                                 const std::vector<tStreamFilter>& oFilters,
                                 const tContext& oContext) const = 0;
    };
 
    class cTextParser;
    class cJsonParser;
 
public:
    static std::string WildcardToRegex(std::string_view strString);

    static std::string EscapeRegularExpression(std::string_view strString);

    cSubstreamNameFilter() noexcept;
    cSubstreamNameFilter(const cSubstreamNameFilter&);
    cSubstreamNameFilter(cSubstreamNameFilter&&) noexcept;
    cSubstreamNameFilter(std::string_view strFileName, std::optional<tFilterMode> oTextModeOverride);
    cSubstreamNameFilter(std::vector<tStreamFilter> oStreamFilters) noexcept;
    ~cSubstreamNameFilter();

    void Reset(std::vector<tStreamFilter> oStreamFilters = {}) noexcept;

    void AddFilter(const tFilter& oFilter, const tStreamAttributes& oAttributes = {});

    void AddFilterFile(std::string_view strFileName, std::optional<tFilterMode> oTextModeOverride);

    void SaveFiltersToFile(std::string_view strFileName, std::optional<tFilterMode> oTextModeOverride);

    tResult RemoveFilter(const tFilter& oFilter) noexcept;

    std::vector<tStreamFilter> GetStreamFilters() const& noexcept;

    std::vector<tStreamFilter>&& GetStreamFilters() && noexcept;

    bool Matches(std::string_view strName) const noexcept;

    bool PrefixMatches(std::string_view strName) const;

    void Select(std::string_view strPrefix,
                const adtf::streaming::ant::IStreamType& oType,
                const std::function<void(std::string_view,
                                         uint32_t,
                                         const tStreamFilter&,
                                         const adtf::ucom::ant::iobject_ptr<const adtf::streaming::ant::IStreamType>&)>&
                    fnSelectedCallback,
                bool bInverseMatch = false) const;

    void Select(const adtf::streaming::ant::IStreamType& oType,
                const std::function<void(std::string_view,
                                         uint32_t,
                                         const tStreamFilter&,
                                         const adtf::ucom::ant::iobject_ptr<const adtf::streaming::ant::IStreamType>&)>&
                    fnSelectedCallback,
                bool bInverseMatch = false) const;
 
private:
    static const ISubstreamNameFilterParser& GetFileParserFor(std::string_view strExtension);
 
private:
    std::vector<tStreamFilter> m_oStreamFilters;
};
 
} // namespace private_implementations
} // namespace filter
} // namespace adtf