addPrimitiveType.h

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