serializable.hpp

#ifndef ABLATELIBRARY_SERIALIZABLE_HPP
#define ABLATELIBRARY_SERIALIZABLE_HPP
 
#include <petsc.h>
#include <algorithm>
#include <memory>
#include <string>
 
namespace ablate::io {
class Serializable {
   public:
    enum class SerializerType { none, collective, serial };
 
    virtual ~Serializable() = default;
    [[nodiscard]] virtual SerializerType Serialize() const { return SerializerType::collective; }
 
    [[nodiscard]] virtual const std::string& GetId() const = 0;
 
    virtual PetscErrorCode Save(PetscViewer viewer, PetscInt sequenceNumber, PetscReal time) = 0;
 
    virtual PetscErrorCode Restore(PetscViewer viewer, PetscInt sequenceNumber, PetscReal time) = 0;
 
   protected:
    static PetscErrorCode SaveKeyValue(PetscViewer viewer, const char* name, PetscScalar value);
 
    static PetscErrorCode RestoreKeyValue(PetscViewer viewer, const char* name, PetscScalar& value);
 
    template <class T>
    static inline PetscErrorCode SaveKeyValue(PetscViewer viewer, const char* name, T value) {
        PetscFunctionBeginUser;
        auto tempValue = (PetscScalar)value;
        PetscCall(SaveKeyValue(viewer, name, tempValue));
        PetscFunctionReturn(0);
    }
 
    template <class T>
    static inline PetscErrorCode RestoreKeyValue(PetscViewer viewer, const char* name, T& value) {
        PetscFunctionBeginUser;
        PetscScalar tempValue = {};
        PetscCall(RestoreKeyValue(viewer, name, tempValue));
        value = (T)tempValue;
        PetscFunctionReturn(0);
    }
 
    template <class T>
    static inline SerializerType DetermineSerializerType(const T& types) {
        auto collectiveCount = std::count_if(types.begin(), types.end(), [](auto& testProcess) {
            auto serializable = std::dynamic_pointer_cast<ablate::io::Serializable>(testProcess);
            return serializable != nullptr && serializable->Serialize() == SerializerType::collective;
        });
        auto serialCount = std::count_if(types.begin(), types.end(), [](auto& testProcess) {
            auto serializable = std::dynamic_pointer_cast<ablate::io::Serializable>(testProcess);
            return serializable != nullptr && serializable->Serialize() == SerializerType::serial;
        });
 
        if (collectiveCount && serialCount) {
            throw std::invalid_argument("All objects in DetermineSerializerType must be collective or serial");
        } else if (collectiveCount) {
            return SerializerType::collective;
        } else if (serialCount) {
            return SerializerType::serial;
        } else {
            return SerializerType::none;
        }
    }
};
}  // namespace ablate::io
 
#endif  // ABLATELIBRARY_SERIALIZABLE_HPP