PatternUtility.hpp

Go to the documentation of this file.

 
 
#pragma once
 
// --- WRApp Includes ---
#include "wrapp/utils/inc/common.hpp"
 
// --- Core Includes ---
#include "includes/kratos_export_api.h"
#include "includes/model_part.h"
 
// --- STL Includes ---
#include <regex>
#include <vector>
#include <map>
#include <filesystem>
#include <optional>
 
 
namespace Kratos {
 
 
 
 
class RegexUtility
{
public:
 
    static std::pair<std::string,std::regex> Integer();
 
    static std::pair<std::string,std::regex> UnsignedInteger();
 
    static std::pair<std::string,std::regex> FloatingPoint();
 
 
private:
 
    RegexUtility() = delete;
 
    RegexUtility(RegexUtility&& rOther) = delete;
 
    RegexUtility(const RegexUtility& rOther) = delete;
 
}; // class RegexUtility
 
 
class KRATOS_API(WR_APPLICATION) PlaceholderPattern
{
public:
 
    using PlaceholderMap = std::map<std::string,std::string>;
 
    using PlaceholderGroupMap = std::map<std::string,std::optional<std::vector<std::size_t>>>;
 
    using MatchType = std::map<std::string,std::vector<std::string>>;
 
    using PathType = std::filesystem::path;
 
    KRATOS_CLASS_POINTER_DEFINITION(PlaceholderPattern);
 
 
    PlaceholderPattern() = default;
 
    PlaceholderPattern(Ref<const std::string> rPattern,
                       Ref<const PlaceholderMap> rPlaceholderMap);
 
    PlaceholderPattern(PlaceholderPattern&& rOther) = default;
 
    PlaceholderPattern(const PlaceholderPattern& rOther) = default;
 
    virtual ~PlaceholderPattern() = default;
 
 
    PlaceholderPattern& operator=(PlaceholderPattern&& rOther) = default;
 
    PlaceholderPattern& operator=(const PlaceholderPattern& rOther) = default;
 
 
    bool IsAMatch(Ref<const std::string> rString) const;
 
    MatchType Match(Ref<const std::string> rString) const;
 
    std::string Apply(Ref<const PlaceholderMap> rPlaceholderValueMap) const;
 
    template <class TOutputIterator>
    void Glob(TOutputIterator it) const;
 
 
    bool IsConst() const;
 
    Ref<const std::regex> GetRegex() const;
 
    Ref<const std::string> GetRegexString() const;
 
    PlaceholderMap GetPlaceholderMap() const;
 
    Ref<const std::string> GetPatternString() const;
 
 
private:
 
    std::string mPattern;
 
    // Placeholders and their assigned group indices in the pattern
    PlaceholderGroupMap mPlaceholderGroupMap;
 
    std::string mRegexString;
 
    std::regex mRegex;
 
 
    static std::string FormatRegexLiteral(const std::string& rLiteral);
 
}; // class PlaceholderPattern
 
 
class KRATOS_API(WR_APPLICATION) ModelPartPattern : public PlaceholderPattern
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(ModelPartPattern);
 
 
    ModelPartPattern() = default;
 
    ModelPartPattern(const std::string& rPattern);
 
    ModelPartPattern(ModelPartPattern&& rOther) = default;
 
    ModelPartPattern(const ModelPartPattern& rOther) = default;
 
 
    using PlaceholderPattern::operator=;
 
 
    using PlaceholderPattern::Apply;
 
    std::string Apply(const ModelPart& rModelPart) const;
 
 
protected:
 
    ModelPartPattern(const std::string& rPattern, const PlaceholderMap& rPlaceholderMap);
 
    virtual void PopulatePlaceholderMap(PlaceholderMap& rMap, const ModelPart& rModelPart) const;
 
    static PlaceholderMap GetPlaceholderMap();
 
}; // class ModelPartPattern
 
 
class KRATOS_API(WR_APPLICATION) CheckpointPattern : public ModelPartPattern
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(CheckpointPattern);
 
 
    CheckpointPattern() = default;
 
    CheckpointPattern(const std::string& rPattern);
 
    CheckpointPattern(CheckpointPattern&& rOther) = default;
 
    CheckpointPattern(const CheckpointPattern& rOther) = default;
 
 
    using ModelPartPattern::operator=;
 
protected:
 
    static PlaceholderMap GetPlaceholderMap();
 
    virtual void PopulatePlaceholderMap(PlaceholderMap& rMap, const ModelPart& rModelPart) const override;
 
}; // class CheckpointPattern
 
 
 
 
} // namespace Kratos
 
#include "wrapp/utils/impl/PatternUtility_impl.hpp"