accessor.hpp

#ifndef ABLATELIBRARY_PARTICLEACCESSOR_HPP
#define ABLATELIBRARY_PARTICLEACCESSOR_HPP
 
#include <petsc.h>
#include <functional>
#include <map>
#include <vector>
#include "particles/field.hpp"
#include "pointData.hpp"
#include "utilities/petscUtilities.hpp"
 
namespace ablate::particles::accessors {
template <class DataType>
class Accessor {
   private:
    std::map<std::string, Data<DataType>> dataCache;
 
    const bool cachePointData;
 
    std::vector<std::function<void()>> destructors{};
 
   protected:
    virtual Data<DataType> CreateData(const std::string& fieldName) = 0;
 
   public:
    explicit Accessor(bool cachePointData) : cachePointData(cachePointData) {}
 
    virtual ~Accessor() {
        for (auto& function : destructors) {
            function();
        }
    };
 
    Data<DataType> operator[](const std::string& fieldName) { return GetData(fieldName); }
 
    inline Data<DataType> GetData(const std::string& fieldName) {
        if (cachePointData) {
            if (!dataCache.count(fieldName)) {
                dataCache[fieldName] = CreateData(fieldName);
            }
            return dataCache.at(fieldName);
        } else {
            return CreateData(fieldName);
        }
    }
 
    inline void RegisterCleanupFunction(const std::function<void()>& function) { destructors.push_back(function); }
 
    Accessor(const Accessor&) = delete;
};
}  // namespace ablate::particles::accessors
#endif  // ABLATELIBRARY_PARTICLEACCESSOR_HPP