multByConstant.h

 
#ifndef INST_MULT_BY_CONST_H
#define INST_MULT_BY_CONST_H
 
#include <memory>
#include <type_traits>
#include <typeinfo>
 
#include "data/constantHandler.h"
#include "data/untypedSharedPtr.h"
#include "instructions/instruction.h"
 
namespace Instructions {
 
    class IAbstractMultByConstant
    {
      public:
        virtual ~IAbstractMultByConstant() = default;
    };
 
    template <class T>
    class MultByConstant : public Instruction, public IAbstractMultByConstant
    {
        static_assert(std::is_fundamental<T>::value,
                      "Template class MultByConstParam<> can only be used for "
                      "primitive types.");
#ifdef CODE_GENERATION
      public:
        MultByConstant(const std::string& printTemplate = "$0 = $1 * $2;");
#endif // CODE_GENERATION
 
      public:
#ifndef CODE_GENERATION
        MultByConstant();
#endif // CODE_GENERATION
 
        double execute(
            const std::vector<Data::UntypedSharedPtr>& args) const override;
 
      private:
        void setUpOperand();
    };
 
#ifdef CODE_GENERATION
    template <class T>
    MultByConstant<T>::MultByConstant(const std::string& printTemplate)
        : Instruction(printTemplate)
    {
        setUpOperand();
    }
 
#endif // CODE_GENERATION
 
#ifndef CODE_GENERATION
    template <class T> MultByConstant<T>::MultByConstant() : Instruction()
    {
        setUpOperand();
    }
#endif // CODE_GENERATION
    template <class T>
    inline double MultByConstant<T>::execute(
        const std::vector<Data::UntypedSharedPtr>& args) const
    {
#ifndef NDEBUG
        if (Instruction::execute(args) != 1.0)
            return 0;
#endif
        const Data::Constant constantValue = (const Data::Constant&)*(
            args.at(1).getSharedPointer<const Data::Constant>());
        return *(args.at(0).getSharedPointer<const T>()) *
               (double)constantValue;
    }
 
    template <class T> void MultByConstant<T>::setUpOperand()
    {
        this->operandTypes.push_back(typeid(T));
        this->operandTypes.push_back(typeid(Data::Constant));
    }
} // namespace Instructions
#endif // INST_MULT_BY_CONST_H