lambdaInstruction.h

 
#ifndef LAMBDA_INSTRUCTION_H
#define LAMBDA_INSTRUCTION_H
 
#include <functional>
#include <typeinfo>
 
#include "data/untypedSharedPtr.h"
#include "instructions/instruction.h"
 
namespace Instructions {
 
    template <typename First, typename... Rest>
    class LambdaInstruction : public Instructions::Instruction
    {
 
#ifdef CODE_GENERATION
      public:
        LambdaInstruction(std::function<double(First, Rest...)> function,
                          const std::string& printTemplate = "")
            : Instructions::Instruction(printTemplate), func{function}
        {
            setUpOperand();
        };
 
#endif // CODE_GENERATION
      protected:
        const std::function<double(const First, const Rest...)> func;
 
      public:
        LambdaInstruction() = delete;
#ifndef CODE_GENERATION
        LambdaInstruction(std::function<double(First, Rest...)> function)
            : Instructions::Instruction(), func{function}
        {
            setUpOperand();
        };
#endif // CODE_GENERATION
        virtual bool checkOperandTypes(
            const std::vector<Data::UntypedSharedPtr>& arguments) const override
        {
            if (arguments.size() != this->operandTypes.size()) {
                return false;
            }
 
            // List of expected types
            const std::vector<std::reference_wrapper<const std::type_info>>
                expectedTypes{
                    // First
                    (!std::is_array<First>::value)
                        ? typeid(First)
                        : typeid(std::remove_all_extents_t<First>[]),
                    (!std::is_array<Rest>::value)
                        ? typeid(Rest)
                        : typeid(std::remove_all_extents_t<Rest>[])...};
 
            for (auto idx = 0; idx < arguments.size(); idx++) {
                // Argument Type
                const std::type_info& argType = arguments.at(idx).getType();
                if (argType != expectedTypes.at(idx).get()) {
                    return false;
                }
            }
 
            return true;
        };
 
        virtual double execute(
            const std::vector<Data::UntypedSharedPtr>& args) const override
        {
 
#ifndef NDEBUG
            if (Instruction::execute(args) != 1.0) {
                return 0.0;
            }
#endif
            double result =
                doExecution(args, std::index_sequence_for<Rest...>{});
 
            return result;
        };
 
      private:
        template <size_t... I>
        double doExecution(const std::vector<Data::UntypedSharedPtr>& args,
                           std::index_sequence<I...>) const
        {
            return this->func(
                getDataFromUntypedSharedPtr<First>(args, 0),
                getDataFromUntypedSharedPtr<Rest>(args, I + 1)...);
        }
 
        template <typename T,
                  typename MINUS_EXTENT = typename std::remove_extent<T>::type,
                  typename RETURN_TYPE = typename std::conditional<
                      !std::is_array<MINUS_EXTENT>::value,
                      typename std::remove_all_extents<T>::type*,
                      MINUS_EXTENT*>::type>
        constexpr auto getDataFromUntypedSharedPtr(
            const std::vector<Data::UntypedSharedPtr>& args, size_t idx) const
        {
            if constexpr (!std::is_array<T>::value) {
                return *(args.at(idx).getSharedPointer<const T>());
            }
            else {
                auto returnedPtr =
                    args.at(idx)
                        .getSharedPointer<
                            const std::remove_all_extents_t<T>[]>();
                return (RETURN_TYPE)returnedPtr.get();
            };
        };
 
        void setUpOperand()
        {
            this->operandTypes.push_back(typeid(First));
            // Fold expression to push all other types
            (this->operandTypes.push_back(typeid(Rest)), ...);
        }
    };
}; // namespace Instructions
 
#endif