Skip to content
Snippets Groups Projects
Commit 7e5bff26 authored by Stéphane Del Pino's avatar Stéphane Del Pino
Browse files

Refactor AffectationRegisterForR* and UnaryOperatorRegisterForR* 

Use single template infrastructures according to dimensions
- AffectationRegisterForR
- UnaryOperatorRegisterForRn
parent 802ef9a9
No related branches found
No related tags found
1 merge request!70Feature/language reduce static
Show whitespace changes
Inline Side-by-side
Showing
with 216 additions and 419 deletions
src/language/utils/AffectationRegisterForR1.cpp deleted 100644 → 0
+ 0
− 102
View file @ 802ef9a9
#include <language/utils/AffectationRegisterForR1.hpp>
#include <language/utils/AffectationProcessorBuilder.hpp>
#include <language/utils/BasicAffectationRegistrerFor.hpp>
#include <language/utils/OperatorRepository.hpp>
void
AffectationRegisterForR1::_register_eq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R1 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(1);
repository.addAffectation<
language::eq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<1>, bool>>());
repository.addAffectation<
language::eq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<1>, uint64_t>>());
repository.addAffectation<
language::eq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<1>, int64_t>>());
repository.addAffectation<
language::eq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<1>, double>>());
repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<1>>>());
repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<1>>>());
repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<1>>>());
repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R1),
ASTNodeDataType::build<ASTNodeDataType::double_t>(),
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<1>>>());
}
void
AffectationRegisterForR1::_register_pluseq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R1 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(1);
repository.addAffectation<language::pluseq_op>(R1, R1,
std::make_shared<AffectationProcessorBuilder<
language::pluseq_op, TinyVector<1>, TinyVector<1>>>());
}
void
AffectationRegisterForR1::_register_minuseq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R1 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(1);
repository.addAffectation<language::minuseq_op>(R1, R1,
std::make_shared<AffectationProcessorBuilder<
language::minuseq_op, TinyVector<1>, TinyVector<1>>>());
}
void
AffectationRegisterForR1::_register_multiplyeq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R1 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(1);
repository.addAffectation<language::multiplyeq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<1>, bool>>());
repository.addAffectation<language::multiplyeq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<1>, uint64_t>>());
repository.addAffectation<language::multiplyeq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<1>, int64_t>>());
repository.addAffectation<language::multiplyeq_op>(R1, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<1>, double>>());
}
AffectationRegisterForR1::AffectationRegisterForR1()
{
BasicAffectationRegisterFor<TinyVector<1>>{};
this->_register_eq_op();
this->_register_pluseq_op();
this->_register_minuseq_op();
this->_register_multiplyeq_op();
}
src/language/utils/AffectationRegisterForR1.hpp deleted 100644 → 0
+ 0
− 16
View file @ 802ef9a9
#ifndef AFFECTATION_REGISTER_FOR_R1_HPP
#define AFFECTATION_REGISTER_FOR_R1_HPP
class AffectationRegisterForR1
{
private:
void _register_eq_op();
void _register_pluseq_op();
void _register_minuseq_op();
void _register_multiplyeq_op();
public:
AffectationRegisterForR1();
};
#endif // AFFECTATION_REGISTER_FOR_R1_HPP
src/language/utils/AffectationRegisterForR2.cpp deleted 100644 → 0
+ 0
− 84
View file @ 802ef9a9
#include <language/utils/AffectationRegisterForR2.hpp>
#include <language/utils/AffectationProcessorBuilder.hpp>
#include <language/utils/BasicAffectationRegistrerFor.hpp>
#include <language/utils/OperatorRepository.hpp>
void
AffectationRegisterForR2::_register_eq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R2 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(2);
repository.addAffectation<
language::eq_op>(R2, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationFromZeroProcessorBuilder<language::eq_op, TinyVector<2>>>());
repository.addAffectation<language::eq_op>(R2,
ASTNodeDataType::build<ASTNodeDataType::list_t>(
std::vector<std::shared_ptr<const ASTNodeDataType>>{}),
std::make_shared<AffectationToTinyVectorFromListProcessorBuilder<
language::eq_op, TinyVector<2>>>());
repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R2),
ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<2>>>());
}
void
AffectationRegisterForR2::_register_pluseq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R2 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(2);
repository.addAffectation<language::pluseq_op>(R2, R2,
std::make_shared<AffectationProcessorBuilder<
language::pluseq_op, TinyVector<2>, TinyVector<2>>>());
}
void
AffectationRegisterForR2::_register_minuseq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R2 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(2);
repository.addAffectation<language::minuseq_op>(R2, R2,
std::make_shared<AffectationProcessorBuilder<
language::minuseq_op, TinyVector<2>, TinyVector<2>>>());
}
void
AffectationRegisterForR2::_register_multiplyeq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R2 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(2);
repository.addAffectation<language::multiplyeq_op>(R2, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<2>, bool>>());
repository.addAffectation<language::multiplyeq_op>(R2, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<2>, uint64_t>>());
repository.addAffectation<language::multiplyeq_op>(R2, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<2>, int64_t>>());
repository.addAffectation<language::multiplyeq_op>(R2, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<2>, double>>());
}
AffectationRegisterForR2::AffectationRegisterForR2()
{
BasicAffectationRegisterFor<TinyVector<2>>{};
this->_register_eq_op();
this->_register_pluseq_op();
this->_register_minuseq_op();
this->_register_multiplyeq_op();
}
src/language/utils/AffectationRegisterForR2.hpp deleted 100644 → 0
+ 0
− 16
View file @ 802ef9a9
#ifndef AFFECTATION_REGISTER_FOR_R2_HPP
#define AFFECTATION_REGISTER_FOR_R2_HPP
class AffectationRegisterForR2
{
private:
void _register_eq_op();
void _register_pluseq_op();
void _register_minuseq_op();
void _register_multiplyeq_op();
public:
AffectationRegisterForR2();
};
#endif // AFFECTATION_REGISTER_FOR_R2_HPP
src/language/utils/AffectationRegisterForR3.cpp deleted 100644 → 0
+ 0
− 84
View file @ 802ef9a9
#include <language/utils/AffectationRegisterForR3.hpp>
#include <language/utils/AffectationProcessorBuilder.hpp>
#include <language/utils/BasicAffectationRegistrerFor.hpp>
#include <language/utils/OperatorRepository.hpp>
void
AffectationRegisterForR3::_register_eq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R3 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(3);
repository.addAffectation<
language::eq_op>(R3, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationFromZeroProcessorBuilder<language::eq_op, TinyVector<3>>>());
repository.addAffectation<language::eq_op>(R3,
ASTNodeDataType::build<ASTNodeDataType::list_t>(
std::vector<std::shared_ptr<const ASTNodeDataType>>{}),
std::make_shared<AffectationToTinyVectorFromListProcessorBuilder<
language::eq_op, TinyVector<3>>>());
repository.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(R3),
ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<3>>>());
}
void
AffectationRegisterForR3::_register_pluseq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R3 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(3);
repository.addAffectation<language::pluseq_op>(R3, R3,
std::make_shared<AffectationProcessorBuilder<
language::pluseq_op, TinyVector<3>, TinyVector<3>>>());
}
void
AffectationRegisterForR3::_register_minuseq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R3 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(3);
repository.addAffectation<language::minuseq_op>(R3, R3,
std::make_shared<AffectationProcessorBuilder<
language::minuseq_op, TinyVector<3>, TinyVector<3>>>());
}
void
AffectationRegisterForR3::_register_multiplyeq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R3 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(3);
repository.addAffectation<language::multiplyeq_op>(R3, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<3>, bool>>());
repository.addAffectation<language::multiplyeq_op>(R3, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<3>, uint64_t>>());
repository.addAffectation<language::multiplyeq_op>(R3, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<3>, int64_t>>());
repository.addAffectation<language::multiplyeq_op>(R3, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<3>, double>>());
}
AffectationRegisterForR3::AffectationRegisterForR3()
{
BasicAffectationRegisterFor<TinyVector<3>>{};
this->_register_eq_op();
this->_register_pluseq_op();
this->_register_minuseq_op();
this->_register_multiplyeq_op();
}
src/language/utils/AffectationRegisterForRn.cpp 0 → 100644
+ 143
− 0
View file @ 7e5bff26
#include <language/utils/AffectationRegisterForRn.hpp>
#include <language/utils/AffectationProcessorBuilder.hpp>
#include <language/utils/BasicAffectationRegistrerFor.hpp>
#include <language/utils/OperatorRepository.hpp>
template <size_t Dimension>
void
AffectationRegisterForRn<Dimension>::_register_eq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto Rn = ASTNodeDataType::build<ASTNodeDataType::vector_t>(Dimension);
repository.addAffectation<
language::eq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationFromZeroProcessorBuilder<language::eq_op, TinyVector<Dimension>>>());
repository.addAffectation<language::eq_op>(Rn,
ASTNodeDataType::build<ASTNodeDataType::list_t>(
std::vector<std::shared_ptr<const ASTNodeDataType>>{}),
std::make_shared<AffectationToTinyVectorFromListProcessorBuilder<
language::eq_op, TinyVector<Dimension>>>());
repository
.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rn),
ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<Dimension>>>());
}
template <>
void
AffectationRegisterForRn<1>::_register_eq_op()
{
constexpr size_t Dimension = 1;
OperatorRepository& repository = OperatorRepository::instance();
auto Rn = ASTNodeDataType::build<ASTNodeDataType::vector_t>(Dimension);
repository.addAffectation<
language::eq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<Dimension>, bool>>());
repository.addAffectation<
language::eq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<Dimension>, uint64_t>>());
repository.addAffectation<
language::eq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<Dimension>, int64_t>>());
repository.addAffectation<
language::eq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
std::make_shared<AffectationProcessorBuilder<language::eq_op, TinyVector<Dimension>, double>>());
repository
.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rn),
ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<Dimension>>>());
repository
.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rn),
ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<Dimension>>>());
repository
.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rn),
ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<Dimension>>>());
repository
.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rn),
ASTNodeDataType::build<ASTNodeDataType::double_t>(),
std::make_shared<AffectationToTupleProcessorBuilder<TinyVector<Dimension>>>());
}
template <size_t Dimension>
void
AffectationRegisterForRn<Dimension>::_register_pluseq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto Rn = ASTNodeDataType::build<ASTNodeDataType::vector_t>(Dimension);
repository
.addAffectation<language::pluseq_op>(Rn, Rn,
std::make_shared<AffectationProcessorBuilder<
language::pluseq_op, TinyVector<Dimension>, TinyVector<Dimension>>>());
}
template <size_t Dimension>
void
AffectationRegisterForRn<Dimension>::_register_minuseq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto Rn = ASTNodeDataType::build<ASTNodeDataType::vector_t>(Dimension);
repository
.addAffectation<language::minuseq_op>(Rn, Rn,
std::make_shared<AffectationProcessorBuilder<
language::minuseq_op, TinyVector<Dimension>, TinyVector<Dimension>>>());
}
template <size_t Dimension>
void
AffectationRegisterForRn<Dimension>::_register_multiplyeq_op()
{
OperatorRepository& repository = OperatorRepository::instance();
auto Rn = ASTNodeDataType::build<ASTNodeDataType::vector_t>(Dimension);
repository.addAffectation<language::multiplyeq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::bool_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<Dimension>, bool>>());
repository.addAffectation<language::multiplyeq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<Dimension>, uint64_t>>());
repository.addAffectation<language::multiplyeq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<Dimension>, int64_t>>());
repository.addAffectation<language::multiplyeq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::double_t>(),
std::make_shared<AffectationProcessorBuilder<
language::multiplyeq_op, TinyVector<Dimension>, double>>());
}
template <size_t Dimension>
AffectationRegisterForRn<Dimension>::AffectationRegisterForRn()
{
BasicAffectationRegisterFor<TinyVector<Dimension>>{};
this->_register_eq_op();
this->_register_pluseq_op();
this->_register_minuseq_op();
this->_register_multiplyeq_op();
}
template class AffectationRegisterForRn<1>;
template class AffectationRegisterForRn<2>;
template class AffectationRegisterForRn<3>;
src/language/utils/AffectationRegisterForR3.hpp → src/language/utils/AffectationRegisterForRn.hpp
+ 19
− 0
View file @ 7e5bff26
#ifndef AFFECTATION_REGISTER_FOR_R3_HPP
#define AFFECTATION_REGISTER_FOR_R3_HPP
#ifndef AFFECTATION_REGISTER_FOR_RN_HPP
#define AFFECTATION_REGISTER_FOR_RN_HPP
class AffectationRegisterForR3
#include <cstdlib>
template <size_t Dimension>
class AffectationRegisterForRn
{
private:
void _register_eq_op();
......@@ -10,7 +13,7 @@ class AffectationRegisterForR3
void _register_multiplyeq_op();
public:
AffectationRegisterForR3();
AffectationRegisterForRn();
};
#endif // AFFECTATION_REGISTER_FOR_R3_HPP
#endif // AFFECTATION_REGISTER_FOR_RN_HPP
src/language/utils/CMakeLists.txt
+ 2
− 6
View file @ 7e5bff26
......@@ -4,9 +4,7 @@ add_library(PugsLanguageUtils
AffectationRegisterForB.cpp
AffectationRegisterForN.cpp
AffectationRegisterForR.cpp
AffectationRegisterForR1.cpp
AffectationRegisterForR2.cpp
AffectationRegisterForR3.cpp
AffectationRegisterForRn.cpp
AffectationRegisterForString.cpp
AffectationRegisterForZ.cpp
ASTDotPrinter.cpp
......@@ -28,9 +26,7 @@ add_library(PugsLanguageUtils
UnaryOperatorRegisterForB.cpp
UnaryOperatorRegisterForN.cpp
UnaryOperatorRegisterForR.cpp
UnaryOperatorRegisterForR1.cpp
UnaryOperatorRegisterForR2.cpp
UnaryOperatorRegisterForR3.cpp
UnaryOperatorRegisterForRn.cpp
UnaryOperatorRegisterForZ.cpp
)
......
src/language/utils/OperatorRepository.cpp
+ 8
− 12
View file @ 7e5bff26
......@@ -4,9 +4,7 @@
#include <language/utils/AffectationRegisterForB.hpp>
#include <language/utils/AffectationRegisterForN.hpp>
#include <language/utils/AffectationRegisterForR.hpp>
#include <language/utils/AffectationRegisterForR1.hpp>
#include <language/utils/AffectationRegisterForR2.hpp>
#include <language/utils/AffectationRegisterForR3.hpp>
#include <language/utils/AffectationRegisterForRn.hpp>
#include <language/utils/AffectationRegisterForString.hpp>
#include <language/utils/AffectationRegisterForZ.hpp>
......@@ -24,9 +22,7 @@
#include <language/utils/UnaryOperatorRegisterForB.hpp>
#include <language/utils/UnaryOperatorRegisterForN.hpp>
#include <language/utils/UnaryOperatorRegisterForR.hpp>
#include <language/utils/UnaryOperatorRegisterForR1.hpp>
#include <language/utils/UnaryOperatorRegisterForR2.hpp>
#include <language/utils/UnaryOperatorRegisterForR3.hpp>
#include <language/utils/UnaryOperatorRegisterForRn.hpp>
#include <language/utils/UnaryOperatorRegisterForZ.hpp>
#include <utils/PugsAssert.hpp>
......@@ -66,9 +62,9 @@ OperatorRepository::_initialize()
AffectationRegisterForN{};
AffectationRegisterForZ{};
AffectationRegisterForR{};
AffectationRegisterForR1{};
AffectationRegisterForR2{};
AffectationRegisterForR3{};
AffectationRegisterForRn<1>{};
AffectationRegisterForRn<2>{};
AffectationRegisterForRn<3>{};
AffectationRegisterForString{};
BinaryOperatorRegisterForB{};
......@@ -88,7 +84,7 @@ OperatorRepository::_initialize()
UnaryOperatorRegisterForN{};
UnaryOperatorRegisterForZ{};
UnaryOperatorRegisterForR{};
UnaryOperatorRegisterForR1{};
UnaryOperatorRegisterForR2{};
UnaryOperatorRegisterForR3{};
UnaryOperatorRegisterForRn<1>{};
UnaryOperatorRegisterForRn<2>{};
UnaryOperatorRegisterForRn<3>{};
}
src/language/utils/UnaryOperatorRegisterForR1.cpp deleted 100644 → 0
+ 0
− 20
View file @ 802ef9a9
#include <language/utils/UnaryOperatorRegisterForR1.hpp>
#include <language/utils/OperatorRepository.hpp>
#include <language/utils/UnaryOperatorProcessorBuilder.hpp>
void
UnaryOperatorRegisterForR1::_register_unary_minus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R1 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(1);
repository.addUnaryOperator<language::unary_minus>(R1, std::make_shared<UnaryOperatorProcessorBuilder<
language::unary_minus, TinyVector<1>, TinyVector<1>>>());
}
UnaryOperatorRegisterForR1::UnaryOperatorRegisterForR1()
{
this->_register_unary_minus();
}
src/language/utils/UnaryOperatorRegisterForR1.hpp deleted 100644 → 0
+ 0
− 13
View file @ 802ef9a9
#ifndef UNARY_OPERATOR_REGISTER_FOR_R1_HPP
#define UNARY_OPERATOR_REGISTER_FOR_R1_HPP
class UnaryOperatorRegisterForR1
{
private:
void _register_unary_minus();
public:
UnaryOperatorRegisterForR1();
};
#endif // UNARY_OPERATOR_REGISTER_FOR_R1_HPP
src/language/utils/UnaryOperatorRegisterForR2.cpp deleted 100644 → 0
+ 0
− 20
View file @ 802ef9a9
#include <language/utils/UnaryOperatorRegisterForR2.hpp>
#include <language/utils/OperatorRepository.hpp>
#include <language/utils/UnaryOperatorProcessorBuilder.hpp>
void
UnaryOperatorRegisterForR2::_register_unary_minus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R2 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(2);
repository.addUnaryOperator<language::unary_minus>(R2, std::make_shared<UnaryOperatorProcessorBuilder<
language::unary_minus, TinyVector<2>, TinyVector<2>>>());
}
UnaryOperatorRegisterForR2::UnaryOperatorRegisterForR2()
{
this->_register_unary_minus();
}
src/language/utils/UnaryOperatorRegisterForR2.hpp deleted 100644 → 0
+ 0
− 13
View file @ 802ef9a9
#ifndef UNARY_OPERATOR_REGISTER_FOR_R2_HPP
#define UNARY_OPERATOR_REGISTER_FOR_R2_HPP
class UnaryOperatorRegisterForR2
{
private:
void _register_unary_minus();
public:
UnaryOperatorRegisterForR2();
};
#endif // UNARY_OPERATOR_REGISTER_FOR_R2_HPP
src/language/utils/UnaryOperatorRegisterForR3.cpp deleted 100644 → 0
+ 0
− 20
View file @ 802ef9a9
#include <language/utils/UnaryOperatorRegisterForR3.hpp>
#include <language/utils/OperatorRepository.hpp>
#include <language/utils/UnaryOperatorProcessorBuilder.hpp>
void
UnaryOperatorRegisterForR3::_register_unary_minus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R3 = ASTNodeDataType::build<ASTNodeDataType::vector_t>(3);
repository.addUnaryOperator<language::unary_minus>(R3, std::make_shared<UnaryOperatorProcessorBuilder<
language::unary_minus, TinyVector<3>, TinyVector<3>>>());
}
UnaryOperatorRegisterForR3::UnaryOperatorRegisterForR3()
{
this->_register_unary_minus();
}
src/language/utils/UnaryOperatorRegisterForR3.hpp deleted 100644 → 0
+ 0
− 13
View file @ 802ef9a9
#ifndef UNARY_OPERATOR_REGISTER_FOR_R3_HPP
#define UNARY_OPERATOR_REGISTER_FOR_R3_HPP
class UnaryOperatorRegisterForR3
{
private:
void _register_unary_minus();
public:
UnaryOperatorRegisterForR3();
};
#endif // UNARY_OPERATOR_REGISTER_FOR_R3_HPP
src/language/utils/UnaryOperatorRegisterForRn.cpp 0 → 100644
+ 28
− 0
View file @ 7e5bff26
#include <language/utils/UnaryOperatorRegisterForRn.hpp>
#include <language/utils/OperatorRepository.hpp>
#include <language/utils/UnaryOperatorProcessorBuilder.hpp>
template <size_t Dimension>
void
UnaryOperatorRegisterForRn<Dimension>::_register_unary_minus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto Rn = ASTNodeDataType::build<ASTNodeDataType::vector_t>(Dimension);
repository
.addUnaryOperator<language::unary_minus>(Rn,
std::make_shared<UnaryOperatorProcessorBuilder<
language::unary_minus, TinyVector<Dimension>, TinyVector<Dimension>>>());
}
template <size_t Dimension>
UnaryOperatorRegisterForRn<Dimension>::UnaryOperatorRegisterForRn()
{
this->_register_unary_minus();
}
template class UnaryOperatorRegisterForRn<1>;
template class UnaryOperatorRegisterForRn<2>;
template class UnaryOperatorRegisterForRn<3>;
src/language/utils/UnaryOperatorRegisterForRn.hpp 0 → 100644
+ 16
− 0
View file @ 7e5bff26
#ifndef UNARY_OPERATOR_REGISTER_FOR_RN_HPP
#define UNARY_OPERATOR_REGISTER_FOR_RN_HPP
#include <cstdlib>
template <size_t Dimension>
class UnaryOperatorRegisterForRn
{
private:
void _register_unary_minus();
public:
UnaryOperatorRegisterForRn();
};
#endif // UNARY_OPERATOR_REGISTER_FOR_RN_HPP
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment