file_name_data_collector.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Suneth Warnakulasuriya (https://github.com/sunethwarna)
//
 
#if !defined(KRATOS_FILE_NAME_DATA_COLLECTOR)
#define KRATOS_FILE_NAME_DATA_COLLECTOR
 
// System includes
#include <string>
#include <unordered_map>
#include <vector>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/model_part.h"
 
namespace Kratos
{
 
class KRATOS_API(KRATOS_CORE) FileNameDataCollector
{
    // private forward declarations
    class PatternFlag;
 
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(FileNameDataCollector);
 
 
    class FileNameData
    {
    public:
 
        KRATOS_CLASS_POINTER_DEFINITION(FileNameData);
 
 
        // Default constructor
        FileNameData()
        {}
 
        FileNameData(
            const std::string& rFileName,
            const int Rank,
            const int Step,
            const double Time)
            : mFileName(rFileName),
              mRank(Rank),
              mStep(Step),
              mTime(Time)
        {}
 
 
        void SetFileName(const std::string& rFileName) { mFileName = rFileName; }
 
        std::string GetFileName() const { return mFileName; }
 
        void SetRank(const int Rank) { mRank = Rank; }
 
        int GetRank() const { return mRank; }
 
        void SetStep(const int Step) { mStep = Step; }
 
        int GetStep() const { return mStep; }
 
        void SetTime(const double Time) { mTime = Time; }
 
        double GetTime() const { return mTime; }
 
 
        void Clear()
        {
            mFileName = "";
            mRank = -1;
            mStep = -1;
            mTime = -1.0;
        }
 
 
        bool operator==(const FileNameData& rRHS)
        {
            return (mFileName == rRHS.mFileName && mRank == rRHS.mRank &&
                    mStep == rRHS.mStep && mTime == rRHS.mTime);
        }
 
 
    private:
 
        std::string mFileName = "";
        int mRank = -1;
        int mStep = -1;
        double mTime = -1.0;
 
        friend class PatternFlag;
 
    };
 
 
    FileNameDataCollector(
        const ModelPart& rModelPart,
        const std::string& rFileNamePattern,
        const std::unordered_map<std::string, std::string>& rFlagFormatMap);
 
 
    std::string GetFileName() const;
 
    std::string GetPath() const;
 
    std::vector<std::string> GetSortedFileNamesList(
        const std::vector<std::string>& rFlagsSortingOrder) const;
 
    bool RetrieveFileNameData(
        FileNameData& rFileNameData,
        const std::string& rFileNameWithoutPath) const;
 
    std::vector<FileNameData> GetFileNameDataList() const;
 
 
    static void SortListOfFileNameData(
        std::vector<FileNameData>& rFileNameDataList,
        const std::vector<std::string>& rFlagsSortingOrder);
 
    static std::pair<bool, std::string> ExtractFileNamePattern(
        const std::string& rFileName,
        const std::vector<std::string>& rFlagsList);
 
 
private:
 
    class KRATOS_API(KRATOS_CORE) PatternFlag
    {
    public:
 
        // Constructor
        PatternFlag(
            const std::string& rPatternFlag,
            const std::string& rPatternValueFormat = "");
 
 
        bool UpdateFileNameData(
            FileNameData& rFileNameData,
            std::size_t& rCurrentPosition,
            const std::string& rData) const
        {
            return (this->*mUpdateData)(rFileNameData, rCurrentPosition, rData);
        }
 
        std::string GetValueString(
            const ModelPart& rModelPart) const
        {
            return (this->*mGetValueString)(rModelPart);
        }
 
 
        bool IsFlag() const
        {
            return (mPatternFlag.front() == '<' && mPatternFlag.back() == '>');
        }
 
        std::string GetPatternFlagString() const
        {
            return mPatternFlag;
        }
 
 
        static bool RetrieveIntegerValue(
            int& rValue,
            std::size_t& rCurrentPosition,
            const std::string& rData);
 
        static bool RetrieveFloatingPointValue(
            double& rValue,
            std::size_t& rCurrentPosition,
            const std::string& rData);
 
 
    private:
 
        const std::string mPatternFlag;
        const std::string mPatternValueFormat;
        bool (PatternFlag::*mUpdateData)(FileNameData& rFileNameData, std::size_t& rCurrentPosition, const std::string& rData) const;
        std::string (PatternFlag::*mGetValueString)(const ModelPart& rModelPart) const;
 
 
        bool UpdateRank(FileNameData& rFileNameData, std::size_t& rCurrentPosition, const std::string& rData) const;
        bool UpdateStep(FileNameData& rFileNameData, std::size_t& rCurrentPosition, const std::string& rData) const;
        bool UpdateTime(FileNameData& rFileNameData, std::size_t& rCurrentPosition, const std::string& rData) const;
        bool UpdateCustomString(FileNameData& rFileNameData, std::size_t& rCurrentPosition, const std::string& rData) const;
 
        std::string GetRankString(const ModelPart& rModelPart) const;
        std::string GetStepString(const ModelPart& rModelPart) const;
        std::string GetTimeString(const ModelPart& rModelPart) const;
        std::string GetCustomString(const ModelPart& rModelPart) const;
 
        template <class TDataType>
        std::string GetFormattedValueString(
            const TDataType& rData) const
        {
            if (mPatternValueFormat == "") {
                return std::to_string(rData);
            } else {
                int length = std::snprintf(nullptr, 0, mPatternValueFormat.c_str(), rData);
                assert(length >= 0);
 
                char* buf = new char[length + 1];
                std::snprintf(buf, length + 1, mPatternValueFormat.c_str(), rData);
 
                std::string data_str(buf);
                delete[] buf;
 
                return data_str;
            }
        }
 
    };
 
 
    const ModelPart& mrModelPart;
    std::string mFilePath;
    std::vector<PatternFlag> mFileNamePatternFlags;
 
 
    static std::vector<std::string> GetPatternFlagStrings(
        const std::string& rPattern);
 
    static void FindAndReplace(
        std::string& rInputString,
        const std::string& rSearchString,
        const std::string& rReplaceString);
 
};
 
 
} // namespace Kratos
 
#endif // KRATOS_FILE_NAME_DATA_COLLECTOR