transform.h

Go to the documentation of this file.

#ifndef TRANSFORM_H
#define TRANSFORM_H
 
 
#include "allocator.h"
#include "baseList.h"
#include "cloneable.h"
#include "maths.h"
 
namespace original {
 
    template<typename TYPE>
    class transform : public cloneable {
    protected:
        virtual void apply(TYPE& t);
 
    public:
        ~transform() override = default;
 
        transform* clone() const override;
 
        virtual void operator()(TYPE& t);
    };
 
    template<typename TYPE>
    class addOptTransform final : public transform<TYPE> {
        TYPE t_; 
 
        void apply(TYPE &t) override;
 
    public:
        addOptTransform* clone() const override;
 
        explicit addOptTransform(const TYPE& t);
    };
 
    template<typename TYPE>
    class assignOptTransform final : public transform<TYPE> {
        TYPE val_; 
 
        void apply(TYPE &t) override;
 
    public:
        assignOptTransform* clone() const override;
 
        explicit assignOptTransform(const TYPE& val);
    };
 
    template<typename TYPE>
    class multiOptTransform final : public transform<TYPE> {
        TYPE t_; 
 
        void apply(TYPE &t) override;
 
    public:
        multiOptTransform* clone() const override;
 
        explicit multiOptTransform(const TYPE& t);
    };
 
    template<typename TYPE>
    class absTransform final : public transform<TYPE> {
        void apply(TYPE &t) override;
 
    public:
        absTransform* clone() const override;
 
        explicit absTransform() = default;
    };
 
    template<typename TYPE, typename ALLOC = allocator<TYPE>>
    class copyTransform final : public transform<TYPE> {
        baseList<TYPE, ALLOC>* container_; 
 
        void apply(TYPE &t) override;
 
    public:
        copyTransform* clone() const override;
 
        explicit copyTransform(baseList<TYPE, ALLOC>& container);
    };
 
} // namespace original
 
    template<typename TYPE>
    void original::transform<TYPE>::apply(TYPE&) {}
 
    template <typename TYPE>
    auto original::transform<TYPE>::clone() const -> transform*
    {
        return new transform(*this);
    }
 
    template<typename TYPE>
    auto original::transform<TYPE>::operator()(TYPE& t) -> void
    {
        this->apply(t);
    }
 
    template<typename TYPE>
    original::assignOptTransform<TYPE>::assignOptTransform(const TYPE& val)
        : val_(val) {}
 
    template <typename TYPE>
    auto original::assignOptTransform<TYPE>::clone() const -> assignOptTransform*
    {
        return new assignOptTransform(*this);
    }
 
    template<typename TYPE>
    auto original::assignOptTransform<TYPE>::apply(TYPE& t) -> void
    {
        t = this->val_;
    }
 
    template<typename TYPE>
    original::addOptTransform<TYPE>::addOptTransform(const TYPE &t) : t_(t) {}
 
    template <typename TYPE>
    auto original::addOptTransform<TYPE>::clone() const -> addOptTransform*
    {
        return new addOptTransform(*this);
    }
 
    template<typename TYPE>
    auto original::addOptTransform<TYPE>::apply(TYPE& t) -> void
    {
        t = t + this->t_;
    }
 
    template<typename TYPE>
    original::multiOptTransform<TYPE>::multiOptTransform(const TYPE &t) : t_(t) {}
 
    template <typename TYPE>
    auto original::multiOptTransform<TYPE>::clone() const -> multiOptTransform*
    {
        return new multiOptTransform(*this);
    }
 
    template<typename TYPE>
    auto original::multiOptTransform<TYPE>::apply(TYPE& t) -> void
    {
        t = t * this->t_;
    }
 
    template <typename TYPE>
    auto original::absTransform<TYPE>::clone() const -> absTransform*
    {
        return new absTransform(*this);
    }
 
    template<typename TYPE>
    auto original::absTransform<TYPE>::apply(TYPE& t) -> void
    {
        t = original::abs(t);
    }
 
    template<typename TYPE, typename ALLOC>
    original::copyTransform<TYPE, ALLOC>::copyTransform(baseList<TYPE, ALLOC>& container)
        : container_(&container) {}
 
    template<typename TYPE, typename ALLOC>
    auto original::copyTransform<TYPE, ALLOC>::clone() const -> copyTransform*
    {
        return new copyTransform(*this);
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::copyTransform<TYPE, ALLOC>::apply(TYPE& t) -> void
    {
        this->container_->add(t);
    }
 
#endif //TRANSFORM_H