Dynamic.h

Go to the documentation of this file.

#pragma once
 
 
#include "math/Means.h"
#include "objects/geometry/Tensor.h"
#include "objects/geometry/TracelessTensor.h"
#include "objects/wrappers/Variant.h"
 
NAMESPACE_SPH_BEGIN
 
enum class DynamicId {
    SIZE = 1,
    FLOAT,
    VECTOR,
    TENSOR,
    SYMMETRIC_TENSOR,
    TRACELESS_TENSOR,
    MIN_MAX_MEAN,
    STRING,
};
 
class Dynamic {
private:
    using DynamicVariant = Variant<NothingType,
        Size,
        Float,
        Vector,
        Tensor,
        SymmetricTensor,
        TracelessTensor,
        MinMaxMean,
        std::string>;
 
    DynamicVariant storage;
 
public:
    Dynamic();
 
    ~Dynamic();
 
    template <typename T, typename = std::enable_if_t<!std::is_same<std::decay_t<T>, Dynamic>::value>>
    Dynamic(T&& value)
        : storage(std::forward<T>(value)) {}
 
    Dynamic(const Dynamic& other)
        : storage(other.storage) {}
 
    Dynamic(Dynamic&& other)
        : storage(std::move(other.storage)) {}
 
    template <typename T, typename = std::enable_if_t<DynamicVariant::canHold<T>()>>
    Dynamic& operator=(T&& rhs) {
        storage = std::forward<T>(rhs);
        return *this;
    }
 
    Dynamic& operator=(const Dynamic& other) {
        storage = other.storage;
        return *this;
    }
 
    Dynamic& operator=(Dynamic&& other) {
        storage = std::move(other.storage);
        return *this;
    }
 
    template <typename T, typename = std::enable_if_t<DynamicVariant::canHold<T>()>>
    INLINE T& get() {
        return storage.get<T>();
    }
 
    template <typename T, typename = std::enable_if_t<DynamicVariant::canHold<T>()>>
    const T& get() const {
        return storage.get<T>();
    }
 
    template <typename T, typename = std::enable_if_t<DynamicVariant::canHold<T>()>>
    operator T&() {
        return this->get<T>();
    }
 
    template <typename T, typename = std::enable_if_t<DynamicVariant::canHold<T>()>>
    operator const T&() const {
        return this->get<T>();
    }
 
    Float getScalar() const {
        return forValue(storage, ScalarFunctor());
    }
 
    DynamicId getType() const {
        return DynamicId(storage.getTypeIdx());
    }
 
    bool empty() const {
        return storage.getTypeIdx() == 0;
    }
 
    explicit operator bool() const {
        return !this->empty();
    }
 
    bool operator!() const {
        return this->empty();
    }
 
    template <typename T, typename = std::enable_if_t<DynamicVariant::canHold<T>()>>
    bool operator==(const T& value) const {
        return this->get<T>() == value;
    }
 
    friend std::ostream& operator<<(std::ostream& stream, const Dynamic& value) {
        forValue(value.storage, [&stream](const auto& v) { stream << std::setw(20) << v; });
        return stream;
    }
 
private:
    struct ScalarFunctor {
        template <typename T>
        Float operator()(const T& value) {
            return norm(value);
        }
        Float operator()(const Size value) {
            return Float(value);
        }
        Float operator()(const Vector& value) {
            return getLength(value);
        }
        Float operator()(const MinMaxMean& value) {
            return value.mean();
        }
        Float operator()(const std::string&) {
            NOT_IMPLEMENTED;
        }
        Float operator()(const NothingType&) {
            return NAN;
        }
    };
};
 
 
NAMESPACE_SPH_END