abstractdatamodel.h

Go to the documentation of this file.

#ifndef CTL_ABSTRACTDATAMODEL_H
#define CTL_ABSTRACTDATAMODEL_H

#include "io/serializationinterface.h"
#include "copyableuniqueptr.h"

namespace CTL {

class AbstractDataModel : public SerializationInterface
{
    CTL_TYPE_ID(0)

    // abstract interface
    public:virtual float valueAt(float position) const = 0;
    public:virtual AbstractDataModel* clone() const = 0;

public:
    virtual QVariant parameter() const;
    virtual void setParameter(const QVariant& parameter);

    void fromVariant(const QVariant& variant) override;
    QVariant toVariant() const override;

    bool isIntegrable() const;

    void setName(const QString& name);
    const QString& name() const;

    ~AbstractDataModel() override = default;

private:
    QString _name;

protected:
    AbstractDataModel() = default;
    AbstractDataModel(const AbstractDataModel&) = default;
    AbstractDataModel(AbstractDataModel&&) = default;
    AbstractDataModel& operator=(const AbstractDataModel&) = default;
    AbstractDataModel& operator=(AbstractDataModel&&) = default;
};

// Data model operators
std::shared_ptr<AbstractDataModel> operator+(std::shared_ptr<AbstractDataModel> lhs,
                                             std::shared_ptr<AbstractDataModel> rhs);
std::shared_ptr<AbstractDataModel> operator-(std::shared_ptr<AbstractDataModel> lhs,
                                             std::shared_ptr<AbstractDataModel> rhs);
std::shared_ptr<AbstractDataModel> operator*(std::shared_ptr<AbstractDataModel> lhs,
                                             std::shared_ptr<AbstractDataModel> rhs);
std::shared_ptr<AbstractDataModel> operator/(std::shared_ptr<AbstractDataModel> lhs,
                                             std::shared_ptr<AbstractDataModel> rhs);
std::shared_ptr<AbstractDataModel> operator|(std::shared_ptr<AbstractDataModel> lhs,
                                             std::shared_ptr<AbstractDataModel> rhs);
std::shared_ptr<AbstractDataModel>& operator+=(std::shared_ptr<AbstractDataModel>& lhs,
                                               const std::shared_ptr<AbstractDataModel>& rhs);
std::shared_ptr<AbstractDataModel>& operator-=(std::shared_ptr<AbstractDataModel>& lhs,
                                               const std::shared_ptr<AbstractDataModel>& rhs);
std::shared_ptr<AbstractDataModel>& operator*=(std::shared_ptr<AbstractDataModel>& lhs,
                                               const std::shared_ptr<AbstractDataModel>& rhs);
std::shared_ptr<AbstractDataModel>& operator/=(std::shared_ptr<AbstractDataModel>& lhs,
                                               const std::shared_ptr<AbstractDataModel>& rhs);
std::shared_ptr<AbstractDataModel>& operator|=(std::shared_ptr<AbstractDataModel>& lhs,
                                               const std::shared_ptr<AbstractDataModel>& rhs);

class AbstractIntegrableDataModel : public AbstractDataModel
{
    // abstract interface
    public:virtual float binIntegral(float position, float binWidth) const = 0;
    public:virtual AbstractIntegrableDataModel* clone() const override = 0;

public:
    ~AbstractIntegrableDataModel() override = default;

    float meanValue(float position, float binWidth) const;

protected:
    AbstractIntegrableDataModel() = default;
    AbstractIntegrableDataModel(const AbstractIntegrableDataModel&) = default;
    AbstractIntegrableDataModel(AbstractIntegrableDataModel&&) = default;
    AbstractIntegrableDataModel& operator=(const AbstractIntegrableDataModel&) = default;
    AbstractIntegrableDataModel& operator=(AbstractIntegrableDataModel&&) = default;
};

// Operators for integrable data models
std::shared_ptr<AbstractIntegrableDataModel>
operator+(std::shared_ptr<AbstractIntegrableDataModel> lhs,
          std::shared_ptr<AbstractIntegrableDataModel> rhs);
std::shared_ptr<AbstractIntegrableDataModel>
operator-(std::shared_ptr<AbstractIntegrableDataModel> lhs,
          std::shared_ptr<AbstractIntegrableDataModel> rhs);
std::shared_ptr<AbstractIntegrableDataModel>&
operator+=(std::shared_ptr<AbstractIntegrableDataModel>& lhs,
           const std::shared_ptr<AbstractIntegrableDataModel>& rhs);
std::shared_ptr<AbstractIntegrableDataModel>&
operator-=(std::shared_ptr<AbstractIntegrableDataModel>& lhs,
           const std::shared_ptr<AbstractIntegrableDataModel>& rhs);

// resolve ambiguity for integrable data model operators
template <typename DataModel1, typename DataModel2>
auto operator+(std::shared_ptr<DataModel1> lhs, std::shared_ptr<DataModel2> rhs) ->
    typename std::enable_if<
           std::is_convertible<DataModel1*, AbstractIntegrableDataModel*>::value
        && std::is_convertible<DataModel2*, AbstractIntegrableDataModel*>::value,
        std::shared_ptr<AbstractIntegrableDataModel>>::type
{
    return std::shared_ptr<AbstractIntegrableDataModel>(std::move(lhs))
         + std::shared_ptr<AbstractIntegrableDataModel>(std::move(rhs));
}
template <typename DataModel1, typename DataModel2>
auto operator-(std::shared_ptr<DataModel1> lhs, std::shared_ptr<DataModel2> rhs) ->
    typename std::enable_if<
           std::is_convertible<DataModel1*, AbstractIntegrableDataModel*>::value
        && std::is_convertible<DataModel2*, AbstractIntegrableDataModel*>::value,
        std::shared_ptr<AbstractIntegrableDataModel>>::type
{
    return std::shared_ptr<AbstractIntegrableDataModel>(std::move(lhs))
         - std::shared_ptr<AbstractIntegrableDataModel>(std::move(rhs));
}

// Declare DataModelPtr (copyable unique_ptr)
template <class ModelType, class =
          typename std::enable_if<std::is_convertible<ModelType*, AbstractDataModel*>::value>::type>
using DataModelPtr = CopyableUniquePtr<ModelType>;

using AbstractDataModelPtr = DataModelPtr<AbstractDataModel>;

// factory function `makeDataModel`
template <typename ModelType, typename... ConstructorArguments>
auto makeDataModel(ConstructorArguments&&... arguments) ->
    typename std::enable_if<std::is_convertible<ModelType*, AbstractDataModel*>::value,
                            std::unique_ptr<ModelType>>::type
{
    return std::unique_ptr<ModelType>(
        new ModelType(std::forward<ConstructorArguments>(arguments)...));
}

} // namespace CTL




#endif // CTL_ABSTRACTDATAMODEL_H