diff --git a/include/aidge/nodeTester/ConditionalInterpreter.hpp b/include/aidge/nodeTester/ConditionalInterpreter.hpp
index e5f971a81b6964c137ae489b46b921953975946d..9840f637fe7452ddd21c5289455162e1993c505e 100644
--- a/include/aidge/nodeTester/ConditionalInterpreter.hpp
+++ b/include/aidge/nodeTester/ConditionalInterpreter.hpp
@@ -228,6 +228,17 @@ class ConditionalInterpreter
* @see ConditionalRegisterFunction
*/
ConditionalRegisterFunction mLambdaRegiter;
+
+
+ std::vector<ConditionalData*> mResolution ;
+
+ void clearRes(){
+
+ for (std::size_t i = 0; i < mResolution.size(); ++i) {
+ delete mResolution[i];
+ }
+ mResolution.clear();
+ }
public:
/**
@@ -236,6 +247,8 @@ class ConditionalInterpreter
*/
ConditionalInterpreter(const std::string ConditionalExpressions);
+
+ ~ConditionalInterpreter(){clearRes();}
/**
* @brief Test a node depending of the ConditionalExpressions
@@ -275,49 +288,49 @@ class ConditionalInterpreter
* @ingroup ASTnodeInterpreterF
* @brief Function that does something.
*/
- std::vector<ConditionalData*> fLambda(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node,std::vector<ConditionalData*> datas);
+ void fLambda(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node);
/**
* @ingroup ASTnodeInterpreterF
* @brief Converted the lexeme to a int and to ConditionalData*
*/
- std::vector<ConditionalData*> fStrToInteger(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node);
+ void fStrToInteger(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node);
/**
* @ingroup ASTnodeInterpreterF
* @brief Converted the lexeme to a float and to ConditionalData*
*/
- std::vector<ConditionalData*> fStrToFloat(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node);
+ void fStrToFloat(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node);
/**
* @ingroup ASTnodeInterpreterF
* @brief Converted the lexeme to a str and to ConditionalData*
*/
- std::vector<ConditionalData*> fStrToStr(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node);
+ void fStrToStr(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node);
/**
* @ingroup ASTnodeInterpreterF
* @brief makes the == operation between two previously converted ConditionalData*
*/
- std::vector<ConditionalData*> fEq(std::vector<ConditionalData*> datas);
+ void fEq(void);
/**
* @ingroup ASTnodeInterpreterF
* @brief makes the != operation between two previously converted ConditionalData*
*/
- std::vector<ConditionalData*> fNeq(std::vector<ConditionalData*> datas);
+ void fNeq(void);
/**
* @ingroup ASTnodeInterpreterF
* @brief makes the && operation between two previously converted ConditionalData* in bool
*/
- std::vector<ConditionalData*> fAnd(std::vector<ConditionalData*> datas);
+ void fAnd(void);
/**
* @ingroup ASTnodeInterpreterF
* @brief makes the || operation between two previously converted ConditionalData* in bool
*/
- std::vector<ConditionalData*> fOr(std::vector<ConditionalData*> datas);
+ void fOr(void);
/**
* @ingroup ASTnodeInterpreterF
* @brief makes the ! operation
*/
- std::vector<ConditionalData*> fNot(std::vector<ConditionalData*> datas);
+ void fNot(void);
};
diff --git a/src/nodeTester/ConditionalInterpreter.cpp b/src/nodeTester/ConditionalInterpreter.cpp
index 48947035eb0648effe39ff5c9ac394ead8cc7650..8cb20ac2f2348821b245dfc9f61be1072d76b9c9 100644
--- a/src/nodeTester/ConditionalInterpreter.cpp
+++ b/src/nodeTester/ConditionalInterpreter.cpp
@@ -35,16 +35,18 @@ using namespace Aidge;
bool ConditionalInterpreter::test( const NodePtr nodeOp)
{
+
+ clearRes();
try{
std::vector<ConditionalData*> r = visit({mTree},nodeOp);
- if (r.size() != 1){
+ if (mResolution.size() != 1){
throw std::runtime_error("Multy output interpretation output");
}else{
- if (!r[0]->isTypeEqualTo<bool>()){
+ if (!mResolution[0]->isTypeEqualTo<bool>()){
throw std::runtime_error("TEST OUT MUST BE A BOOL ");
}else{
- return r[0]->getValue<bool>();
+ return mResolution[0]->getValue<bool>();
}
}
@@ -53,7 +55,6 @@ using namespace Aidge;
errorMessage << "Error in test " << "\n\t" << e.what() << "\n";
throw std::runtime_error(errorMessage.str());
}
-
}
void ConditionalInterpreter::insertLambda(const std::string key,std::function<bool(Aidge::NodePtr)> f){
@@ -72,32 +73,33 @@ using namespace Aidge;
///////////////////////////////////
case ConditionalTokenTypes::NOT:
{
- std::vector<ConditionalData*> tmp = fNot(visit(node->getChilds(),nodeOp));
- dataVector.insert(dataVector.end(), tmp.begin(), tmp.end());
+ visit(node->getChilds(),nodeOp);
+ fNot();
}
break;
case ConditionalTokenTypes::AND:
{
- std::vector<ConditionalData*> tmp = fAnd(visit(node->getChilds(),nodeOp));
- dataVector.insert(dataVector.end(), tmp.begin(), tmp.end());
+ visit(node->getChilds(),nodeOp);
+ fAnd();
}
break;
case ConditionalTokenTypes::OR:
{
- std::vector<ConditionalData*> tmp = fOr(visit(node->getChilds(),nodeOp));
- dataVector.insert(dataVector.end(), tmp.begin(), tmp.end());
+ visit(node->getChilds(),nodeOp);
+ fOr();
}
break;
case ConditionalTokenTypes::EQ:
{
- std::vector<ConditionalData*> tmp = fEq(visit(node->getChilds(),nodeOp));
- dataVector.insert(dataVector.end(), tmp.begin(), tmp.end());
+ visit(node->getChilds(),nodeOp);
+ fEq();
+ //dataVector.insert(dataVector.end(), tmp.begin(), tmp.end());
}
break;
case ConditionalTokenTypes::NEQ:
{
- std::vector<ConditionalData*> tmp = fNeq(visit(node->getChilds(),nodeOp));
- dataVector.insert(dataVector.end(), tmp.begin(), tmp.end());
+ visit(node->getChilds(),nodeOp);
+ fNeq();
}
break;
@@ -110,38 +112,36 @@ using namespace Aidge;
break;
case ConditionalTokenTypes::INTEGER:
{
- std::vector<ConditionalData*> tmp = fStrToInteger(node);
- dataVector.insert(dataVector.end(), tmp.begin(), tmp.end());
+ fStrToInteger(node);
}
break;
case ConditionalTokenTypes::FLOAT:
{
- std::vector<ConditionalData*> tmp = fStrToFloat(node);
- dataVector.insert(dataVector.end(), tmp.begin(), tmp.end());
+ fStrToFloat(node);
+
}
break;
case ConditionalTokenTypes::STRING:
{
- std::vector<ConditionalData*> tmp = fStrToStr(node);
- dataVector.insert(dataVector.end(), tmp.begin(), tmp.end());
+ fStrToStr(node);
}
break;
case ConditionalTokenTypes::NODE: //TODO
{
- ConditionalData* data = new ConditionalData;
- data->setValue<NodePtr>(nodeOp);
- std::vector<ConditionalData*> tmp = {data};
- dataVector.insert(dataVector.end(), tmp.begin(), tmp.end());
+ ConditionalData* data = new ConditionalData;
+ data->setValue<NodePtr>(nodeOp);
+ mResolution.push_back(data);
}
break;
case ConditionalTokenTypes::LAMBDA:
{
- std::vector<ConditionalData*> tmp = fLambda(node,visit(node->getChilds(),nodeOp));
- dataVector.insert(dataVector.end(), tmp.begin(), tmp.end());
+ visit(node->getChilds(),nodeOp);
+ fLambda(node);
+
}
break;
@@ -154,9 +154,9 @@ using namespace Aidge;
}else{
data->setValue<bool>(false);
}
-
- std::vector<ConditionalData*> tmp = {data};
- dataVector.insert(dataVector.end(), tmp.begin(), tmp.end());
+
+ mResolution.push_back(data);
+
}
break;
@@ -183,68 +183,57 @@ using namespace Aidge;
/////////////////////
- std::vector<ConditionalData*> ConditionalInterpreter::fStrToInteger(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node)
+ void ConditionalInterpreter::fStrToInteger(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node)
{
- std::vector<ConditionalData*> dataVector;
ConditionalData* data = new ConditionalData;
data->setValue<int>(std::stoi(node->getValue()));
- dataVector.push_back(data);
- return dataVector;
+ mResolution.push_back(data);
}
- std::vector<ConditionalData*> ConditionalInterpreter::fStrToFloat(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node)
+ void ConditionalInterpreter::fStrToFloat(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node)
{
- std::vector<ConditionalData*> dataVector;
+
ConditionalData* data = new ConditionalData;
data->setValue<float>(std::stof(node->getValue()));
- dataVector.push_back(data);
- return dataVector;
+ mResolution.push_back(data);
}
- std::vector<ConditionalData*> ConditionalInterpreter::fStrToStr(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node)
+ void ConditionalInterpreter::fStrToStr(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node)
{
- std::vector<ConditionalData*> dataVector;
ConditionalData* data = new ConditionalData;
data->setValue<std::string>(node->getValue());
- dataVector.push_back(data);
- return dataVector;
+ mResolution.push_back(data);
}
- std::vector<ConditionalData*> ConditionalInterpreter::fLambda(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node,std::vector<ConditionalData*> datas)
+ void ConditionalInterpreter::fLambda(const std::shared_ptr<AstNode<ConditionalTokenTypes>>& node)
{
//if the lambda have input
- std::vector<ConditionalData*> dataVector;
ConditionalData* data;
try {
- data = mLambdaRegiter.run(node->getValue(),datas);
+ data = mLambdaRegiter.run(node->getValue(),mResolution);
} catch (const std::exception& e) {
std::ostringstream errorMessage;
errorMessage << "Error in conditional interpretation when run the "<< node->getValue() <<" Lambda\n\t" << e.what() << "\n";
throw std::runtime_error(errorMessage.str());
}
- dataVector.push_back(data);
-
- //clear
- for (std::size_t i = 0; i < datas.size(); ++i) {
- delete datas[i];
- }
- datas.clear();
- return dataVector;
+
+ clearRes();
+ mResolution.push_back(data);
}
- std::vector<ConditionalData*> ConditionalInterpreter::fEq(std::vector<ConditionalData*> datas)
+ void ConditionalInterpreter::fEq(void)
{
- if (datas.size() != 2){
- throw std::runtime_error("EQ need 2 arg and get :" + datas.size());
+ if (mResolution.size() != 2){
+ throw std::runtime_error("EQ need 2 arg and get :" + mResolution.size());
}
- auto a = datas[0];
- auto b = datas[1];
+ auto a = mResolution[0];
+ auto b = mResolution[1];
if (a->getType() != b->getType()){
throw std::runtime_error("EQ Unsuported between type :" + a->getType() +" "+ b->getType());
}
- std::vector<ConditionalData*> dataVector;
+
ConditionalData* data = new ConditionalData;
@@ -259,29 +248,23 @@ using namespace Aidge;
}else{
throw std::runtime_error("EQ Unknown type encountered :" + a->getType() );
}
- dataVector.push_back(data);
- //clear
- for (std::size_t i = 0; i < datas.size(); ++i) {
- delete datas[i];
- }
- datas.clear();
- return dataVector;
+
+ clearRes();
+ mResolution.push_back(data);
}
- std::vector<ConditionalData*> ConditionalInterpreter::fNeq(std::vector<ConditionalData*> datas)
+ void ConditionalInterpreter::fNeq(void)
{
- if (datas.size() != 2){
- throw std::runtime_error("NEQ need 2 arg and get :" + datas.size());
+ if (mResolution.size() != 2){
+ throw std::runtime_error("NEQ need 2 arg and get :" + mResolution.size());
}
- auto a = datas[0];
- auto b = datas[1];
+ auto a = mResolution[0];
+ auto b = mResolution[1];
if (a->getType() != b->getType()){
throw std::runtime_error("NEQ Unsuported between type :" + a->getType() +" "+ b->getType());
}
- std::vector<ConditionalData*> dataVector;
-
ConditionalData* data = new ConditionalData;
if (a->isTypeEqualTo<int>()) {
@@ -294,24 +277,19 @@ using namespace Aidge;
{
throw std::runtime_error("NEQ Unknown type encountered :" + a->getType() );
}
- dataVector.push_back(data);
- //clear
- for (std::size_t i = 0; i < datas.size(); ++i) {
- delete datas[i];
- }
- datas.clear();
- return dataVector;
+
+ clearRes();
+ mResolution.push_back(data);
}
- std::vector<ConditionalData*> ConditionalInterpreter::fAnd(std::vector<ConditionalData*> datas)
+ void ConditionalInterpreter::fAnd(void)
{
- if (datas.size() != 2){
- throw std::runtime_error("AND need 2 arg and get :" + datas.size());
+ if (mResolution.size() != 2){
+ throw std::runtime_error("AND need 2 arg and get :" + mResolution.size());
}
- auto a = datas[0];
- auto b = datas[1];
+ auto a = mResolution[0];
+ auto b = mResolution[1];
- std::vector<ConditionalData*> dataVector;
if (a->getType() != typeid(bool).name() || b->getType() != typeid(bool).name()){
throw std::runtime_error("AND Unknown type encountered need bool get :" + a->getType() );
@@ -321,24 +299,18 @@ using namespace Aidge;
data->setValue<bool>( a->getValue<bool>() && b->getValue<bool>());
- dataVector.push_back(data);
- //clear
- for (std::size_t i = 0; i < datas.size(); ++i) {
- delete datas[i];
- }
- datas.clear();
- return dataVector;
+ clearRes();
+ mResolution.push_back(data);
}
- std::vector<ConditionalData*> ConditionalInterpreter::fOr(std::vector<ConditionalData*> datas)
+ void ConditionalInterpreter::fOr(void)
{
- if (datas.size() != 2){
- throw std::runtime_error("OR need 2 arg and get :" + datas.size());
+ if (mResolution.size() != 2){
+ throw std::runtime_error("OR need 2 arg and get :" + mResolution.size());
}
- auto a = datas[0];
- auto b = datas[1];
+ auto a = mResolution[0];
+ auto b = mResolution[1];
- std::vector<ConditionalData*> dataVector;
if (a->getType() != typeid(bool).name() || b->getType() != typeid(bool).name()){
throw std::runtime_error("OR Unknown type encountered need bool get :" + a->getType() );
@@ -348,23 +320,16 @@ using namespace Aidge;
data->setValue<bool>( a->getValue<bool>() || b->getValue<bool>());
- dataVector.push_back(data);
- //clear
- for (std::size_t i = 0; i < datas.size(); ++i) {
- delete datas[i];
- }
- datas.clear();
- return dataVector;
+ clearRes();
+ mResolution.push_back(data);
}
- std::vector<ConditionalData*> ConditionalInterpreter::fNot(std::vector<ConditionalData*> datas)
+ void ConditionalInterpreter::fNot()
{
- if (datas.size() != 1){
- throw std::runtime_error("not need 1 arg and get :" + datas.size());
+ if (mResolution.size() != 1){
+ throw std::runtime_error("not need 1 arg and get :" + mResolution.size());
}
- auto a = datas[0];
-
- std::vector<ConditionalData*> dataVector;
+ auto a = mResolution[0];
if (a->getType() != typeid(bool).name()){
throw std::runtime_error("NOT Unknown type encountered need bool get :" + a->getType() );
@@ -373,12 +338,7 @@ using namespace Aidge;
ConditionalData* data = new ConditionalData;
data->setValue<bool>( !a->getValue<bool>() );
+ clearRes();
+ mResolution.push_back(data);
- dataVector.push_back(data);
- //clear
- for (std::size_t i = 0; i < datas.size(); ++i) {
- delete datas[i];
- }
- datas.clear();
- return dataVector;
}
diff --git a/unit_tests/nodeTester/Test_ConditionalInterpreter.cpp b/unit_tests/nodeTester/Test_ConditionalInterpreter.cpp
index 4479adfcde81de36f415e44fefc2c6c5483ce758..8b502fb546e2f1396b629ebc78bc1bd4d67842e2 100644
--- a/unit_tests/nodeTester/Test_ConditionalInterpreter.cpp
+++ b/unit_tests/nodeTester/Test_ConditionalInterpreter.cpp
@@ -27,4 +27,40 @@ TEST_CASE("ConditionalInterpreter", "ConditionalInterpreter") {
REQUIRE_THROWS_AS( ConditionalInterpreter(test), std::runtime_error);
}
+
+
+ SECTION("test false int ") {
+
+ const std::string test = " 10 == 11 " ;
+ ConditionalInterpreter conditionalParser = ConditionalInterpreter(test);
+ std::shared_ptr<Node> nodeOp = GenericOperator("conv", 0, 0, 0, "Gop1");
+ bool result = conditionalParser.test(nodeOp);
+ REQUIRE(result == false);
+ }
+
+ SECTION("test true int ") {
+ const std::string test = " 42 == 42 " ;
+ ConditionalInterpreter conditionalParser = ConditionalInterpreter(test);
+ std::shared_ptr<Node> nodeOp = GenericOperator("conv", 0, 0, 0, "Gop1");
+ bool result = conditionalParser.test(nodeOp);
+ REQUIRE(result == true);
+ }
+
+ SECTION("test false str ") {
+ const std::string test = " 'toto' == 'Corgi' " ;
+ ConditionalInterpreter conditionalParser = ConditionalInterpreter(test);
+ std::shared_ptr<Node> nodeOp = GenericOperator("conv", 0, 0, 0, "Gop1");
+ bool result = conditionalParser.test(nodeOp);
+ REQUIRE(result == false);
+ }
+
+ SECTION("test true str ") {
+
+ const std::string test = " 'Corgi' == 'Corgi' " ;
+ ConditionalInterpreter conditionalParser = ConditionalInterpreter(test);
+ std::shared_ptr<Node> nodeOp = GenericOperator("conv", 0, 0, 0, "Gop1");
+ bool result = conditionalParser.test(nodeOp);
+ REQUIRE(result == true);
+ }
+
}
\ No newline at end of file