Journal.hpp

Go to the documentation of this file.

 
#pragma once
 
// --- WRApplication Includes ---
#include "wrapp/io/inc/FileContentIterator.hpp"
 
// --- Core Includes ---
#include "includes/kratos_parameters.h"
#include "containers/model.h"
#include "includes/smart_pointers.h"
 
// --- STL Includes ---
#include <filesystem>
#include <functional>
 
#ifdef KRATOS_SMP_CXX11
#include <thread>
#endif
 
 
namespace Kratos {
 
 
 
 
class JournalBase
{
public:
    using iterator = FileStringIterator;
 
    using const_iterator = iterator;
 
    using value_type = iterator::value_type;
 
    using size_type = std::size_t;
 
    using Extractor = std::function<value_type(const Model&)>;
 
    KRATOS_CLASS_POINTER_DEFINITION(JournalBase);
 
public:
    JournalBase();
 
    JournalBase(const std::filesystem::path& rJournalPath);
 
    JournalBase(const std::filesystem::path& rJournalPath,
                const Extractor& rExtractor);
 
    JournalBase(JournalBase&& rOther) = delete;
 
    explicit JournalBase(const JournalBase& rOther);
 
    JournalBase& operator=(JournalBase&& rOther) = delete;
 
    JournalBase& operator=(const JournalBase& rOther);
 
    const std::filesystem::path& GetFilePath() const noexcept;
 
    void SetExtractor(Extractor&& rExtractor);
 
    void SetExtractor(const Extractor& rExtractor);
 
    void Push(const Model& rModel);
 
    void Push(const value_type& rEntry);
 
    void Erase(const_iterator itEntry);
 
    void Erase(const_iterator Begin, const_iterator End);
 
    void EraseIf(const std::function<bool(const value_type&)>& rPredicate);
 
    void Clear();
 
    bool IsOpen() const noexcept;
 
    [[nodiscard]] const_iterator begin() const;
 
    [[nodiscard]] const_iterator end() const;
 
    size_type size() const;
 
protected:
    class ThreadID
    {
    private:
        #ifdef KRATOS_SMP_OPENMP
            using ID = int;
            ID mID;
        #elif defined(KRATOS_SMP_CXX11)
            using ID = std::thread::thread_id;
            ID mID;
        #endif
 
    public:
        ThreadID();
 
        friend bool operator==(ThreadID Left, ThreadID Right)
        {return Left.mID == Right.mID;}
 
        friend bool operator!=(ThreadID Left, ThreadID Right)
        {return Left.mID != Right.mID;}
 
        friend std::ostream& operator<<(std::ostream& rStream, ThreadID threadID)
        {return rStream << threadID.mID;}
    }; // class ThreadID
 
private:
    void Erase(const std::set<const_iterator>& rLines);
 
    static bool IsValidEntry(const value_type& rEntry);
 
    [[nodiscard]] std::shared_ptr<iterator::FileAccess> Open(std::ios::openmode OpenMode = std::ios::in) const;
 
    std::filesystem::path mJournalPath;
 
    std::pair<Extractor,ThreadID> mExtractor;
 
    mutable std::weak_ptr<iterator::FileAccess> mpFileAccess;
}; // class JournalBase
 
 
class Journal
{
public:
    class iterator
    {
    public:
        friend class Journal;
 
        using iterator_category = std::forward_iterator_tag;
 
        using value_type = Parameters;
 
        using difference_type = std::ptrdiff_t;
 
        using pointer = void;
 
        using reference = void;
 
    public:
        iterator() = delete;
 
        iterator(iterator&& rOther) = default;
 
        iterator(const iterator& rOther) = default;
 
        iterator& operator=(iterator&& rOther) = default;
 
        iterator& operator=(const iterator& rOther) = default;
 
        iterator& operator++();
 
        iterator operator++(int);
 
        value_type operator*() const;
 
        JournalBase::iterator GetBase() const
        {return mWrapped;}
 
        friend bool operator==(const iterator& rLeft, const iterator& rRight);
 
        friend bool operator!=(const iterator& rLeft, const iterator& rRight);
 
    private:
        iterator(JournalBase::iterator&& rWrapped);
 
        JournalBase::iterator mWrapped;
    }; // class iterator
 
    using const_iterator = iterator;
 
    using value_type = iterator::value_type;
 
    using size_type = std::size_t;
 
    using Extractor = std::function<Parameters(const Model&)>;
 
    KRATOS_CLASS_POINTER_DEFINITION(Journal);
 
public:
    Journal();
 
    Journal(const std::filesystem::path& rJournalPath);
 
    Journal(const std::filesystem::path& rJournalPath,
            const Extractor& rExtractor);
 
    Journal(Journal&& rOther) = delete;
 
    explicit Journal(const Journal& rOther) = default;
 
    Journal& operator=(Journal&& rOther) = delete;
 
    Journal& operator=(const Journal& rOther) = default;
 
    const std::filesystem::path& GetFilePath() const noexcept;
 
    void SetExtractor(Extractor&& rExtractor);
 
    void SetExtractor(const Extractor& rExtractor);
 
    void Push(const Model& rModel);
 
    void Erase(const_iterator itEntry);
 
    void Erase(const_iterator Begin, const_iterator End);
 
    void EraseIf(const std::function<bool(const value_type&)>& rPredicate);
 
    void Clear();
 
    bool IsOpen() const noexcept;
 
    [[nodiscard]] const_iterator begin() const;
 
    [[nodiscard]] const_iterator end() const;
 
    size_type size() const;
 
private:
    JournalBase mBase;
}; // class Journal
 
 
 
 
} // namespace Kratos