Remove EvaluateSingleInputSlot. Now every node have to call EvaluateInputSlot and it will return a normal or a list value based on the output slot evaluation.

kovacsv · kovacsv · commit 3febebcecc08 · 2019-01-26T21:39:36.000+01:00
diff --git a/Sources/BuiltInNodes/BI_ArithmeticUINodes.cpp b/Sources/BuiltInNodes/BI_ArithmeticUINodes.cpp
@@ -38,8 +38,8 @@ void BinaryOperationNode::Initialize ()
 
 NE::ValueConstPtr BinaryOperationNode::Calculate (NE::EvaluationEnv& env) const
 {
-	NE::ValueConstPtr aValue = EvaluateSingleInputSlot (NE::SlotId ("a"), env);
-	NE::ValueConstPtr bValue = EvaluateSingleInputSlot (NE::SlotId ("b"), env);
+	NE::ValueConstPtr aValue = EvaluateInputSlot (NE::SlotId ("a"), env);
+	NE::ValueConstPtr bValue = EvaluateInputSlot (NE::SlotId ("b"), env);
 	if (!NE::IsComplexType<NE::NumberValue> (aValue) || !NE::IsComplexType<NE::NumberValue> (bValue)) {
 		return nullptr;
 	}
diff --git a/Sources/BuiltInNodes/BI_InputUINodes.cpp b/Sources/BuiltInNodes/BI_InputUINodes.cpp
@@ -527,9 +527,9 @@ void IntegerRangeNode::Initialize ()
 
 NE::ValueConstPtr IntegerRangeNode::Calculate (NE::EvaluationEnv& env) const
 {
-	NE::ValueConstPtr start = EvaluateSingleInputSlot (NE::SlotId ("start"), env);
-	NE::ValueConstPtr step = EvaluateSingleInputSlot (NE::SlotId ("step"), env);
-	NE::ValueConstPtr count = EvaluateSingleInputSlot (NE::SlotId ("count"), env);
+	NE::ValueConstPtr start = EvaluateInputSlot (NE::SlotId ("start"), env);
+	NE::ValueConstPtr step = EvaluateInputSlot (NE::SlotId ("step"), env);
+	NE::ValueConstPtr count = EvaluateInputSlot (NE::SlotId ("count"), env);
 	if (!NE::IsSingleType<NE::NumberValue> (start) || !NE::IsSingleType<NE::NumberValue> (step) || !NE::IsSingleType<NE::NumberValue> (count)) {
 		return nullptr;
 	}
@@ -609,9 +609,9 @@ void DoubleRangeNode::Initialize ()
 
 NE::ValueConstPtr DoubleRangeNode::Calculate (NE::EvaluationEnv& env) const
 {
-	NE::ValueConstPtr start = EvaluateSingleInputSlot (NE::SlotId ("start"), env);
-	NE::ValueConstPtr step = EvaluateSingleInputSlot (NE::SlotId ("step"), env);
-	NE::ValueConstPtr count = EvaluateSingleInputSlot (NE::SlotId ("count"), env);
+	NE::ValueConstPtr start = EvaluateInputSlot (NE::SlotId ("start"), env);
+	NE::ValueConstPtr step = EvaluateInputSlot (NE::SlotId ("step"), env);
+	NE::ValueConstPtr count = EvaluateInputSlot (NE::SlotId ("count"), env);
 	if (!NE::IsSingleType<NE::NumberValue> (start) || !NE::IsSingleType<NE::NumberValue> (step) || !NE::IsSingleType<NE::NumberValue> (count)) {
 		return nullptr;
 	}
diff --git a/Sources/BuiltInNodes/BI_ViewerUINodes.cpp b/Sources/BuiltInNodes/BI_ViewerUINodes.cpp
@@ -38,7 +38,7 @@ void MultiLineViewerNode::Initialize ()
 
 NE::ValueConstPtr MultiLineViewerNode::Calculate (NE::EvaluationEnv& env) const
 {
-	return EvaluateSingleInputSlot (NE::SlotId ("in"), env);
+	return EvaluateInputSlot (NE::SlotId ("in"), env);
 }
 
 void MultiLineViewerNode::RegisterParameters (NUIE::NodeParameterList& parameterList) const
diff --git a/Sources/NodeEngine/NE_Node.cpp b/Sources/NodeEngine/NE_Node.cpp
@@ -275,31 +275,7 @@ bool Node::RegisterOutputSlot (const OutputSlotPtr& newOutputSlot)
 	return true;
 }
 
-ValueConstPtr Node::EvaluateSingleInputSlot (const SlotId& slotId, EvaluationEnv& env) const
-{
-	if (DBGERROR (!HasInputSlot (slotId))) {
-		return nullptr;
-	}
-
-	InputSlotConstPtr inputSlot = GetInputSlot (slotId);
-	if (DBGERROR (inputSlot == nullptr)) {
-		return nullptr;
-	}
-
-	OutputSlotConnectionMode outputSlotConnectionMode = inputSlot->GetOutputSlotConnectionMode ();
-	if (DBGERROR (outputSlotConnectionMode == OutputSlotConnectionMode::Multiple)) {
-		return nullptr;
-	}
-
-	ListValueConstPtr result = EvaluateInputSlot (inputSlot, env);
-	if (DBGERROR (result->GetSize () != 1)) {
-		return nullptr;
-	}
-
-	return result->GetValue (0);
-}
-
-ListValueConstPtr Node::EvaluateInputSlot (const SlotId& slotId, EvaluationEnv& env) const
+ValueConstPtr Node::EvaluateInputSlot (const SlotId& slotId, EvaluationEnv& env) const
 {
 	if (DBGERROR (!HasInputSlot (slotId))) {
 		return nullptr;
@@ -323,22 +299,35 @@ void Node::ProcessValue (const ValueConstPtr&, EvaluationEnv&) const
 
 }
 
-ListValueConstPtr Node::EvaluateInputSlot (const InputSlotConstPtr& inputSlot, EvaluationEnv& env) const
+ValueConstPtr Node::EvaluateInputSlot (const InputSlotConstPtr& inputSlot, EvaluationEnv& env) const
 {
 	if (DBGERROR (nodeEvaluator == nullptr)) {
 		return nullptr;
 	}
 
-	ListValuePtr result (new ListValue ());
 	if (!nodeEvaluator->HasConnectedOutputSlots (inputSlot)) {
-		result->Push (inputSlot->GetDefaultValue ());
-		return result;
+		return inputSlot->GetDefaultValue ();
 	}
 
+	std::vector<OutputSlotConstPtr> connectedOutputSlots;
 	nodeEvaluator->EnumerateConnectedOutputSlots (inputSlot, [&] (const OutputSlotConstPtr& outputSlot) {
-		result->Push (outputSlot->Evaluate (env));
+		connectedOutputSlots.push_back (outputSlot);
 	});
-	return result;
+
+	OutputSlotConnectionMode outputSlotConnectionMode = inputSlot->GetOutputSlotConnectionMode ();
+	if (outputSlotConnectionMode == OutputSlotConnectionMode::Single) {
+		DBGASSERT (connectedOutputSlots.size () == 1);
+		return connectedOutputSlots[0]->Evaluate (env);
+	} else if (inputSlot->GetOutputSlotConnectionMode () == OutputSlotConnectionMode::Multiple) {
+		ListValuePtr result (new ListValue ());
+		for (const OutputSlotConstPtr& outputSlot : connectedOutputSlots) {
+			result->Push (outputSlot->Evaluate (env));
+		}
+		return result;
+	}
+
+	DBGBREAK ();
+	return nullptr;
 }
 
 NodePtr Node::Clone (const NodeConstPtr& node)
diff --git a/Sources/NodeEngine/NE_Node.hpp b/Sources/NodeEngine/NE_Node.hpp
@@ -129,9 +129,7 @@ class Node : public DynamicSerializable
 protected:
 	virtual bool			RegisterInputSlot (const InputSlotPtr& newInputSlot);
 	virtual bool			RegisterOutputSlot (const OutputSlotPtr& newOutputSlot);
-
-	ValueConstPtr			EvaluateSingleInputSlot (const SlotId& slotId, EvaluationEnv& env) const;
-	ListValueConstPtr		EvaluateInputSlot (const SlotId& slotId, EvaluationEnv& env) const;
+	ValueConstPtr			EvaluateInputSlot (const SlotId& slotId, EvaluationEnv& env) const;
 
 private:
 	virtual void			Initialize () = 0;
@@ -140,7 +138,7 @@ class Node : public DynamicSerializable
 	virtual bool			IsForceCalculated () const;
 	virtual void			ProcessValue (const ValueConstPtr& value, EvaluationEnv& env) const;
 
-	ListValueConstPtr		EvaluateInputSlot (const InputSlotConstPtr& inputSlot, EvaluationEnv& env) const;
+	ValueConstPtr			EvaluateInputSlot (const InputSlotConstPtr& inputSlot, EvaluationEnv& env) const;
 
 	NodeId					nodeId;
 	NodeEvaluatorConstPtr	nodeEvaluator;
diff --git a/Sources/NodeEngineTest/EnableDisableFeatureTest.cpp b/Sources/NodeEngineTest/EnableDisableFeatureTest.cpp
@@ -82,8 +82,8 @@ class TestNode : public SerializableTestUINode
 
 	virtual ValueConstPtr Calculate (EvaluationEnv& env) const override
 	{
-		ValueConstPtr a = EvaluateSingleInputSlot (SlotId ("in1"), env);
-		ValueConstPtr b = EvaluateSingleInputSlot (SlotId ("in2"), env);
+		ValueConstPtr a = EvaluateInputSlot (SlotId ("in1"), env);
+		ValueConstPtr b = EvaluateInputSlot (SlotId ("in2"), env);
 		int result = IntValue::Get (a) + IntValue::Get (b);
 		return ValuePtr (new IntValue (result));
 	}
diff --git a/Sources/NodeEngineTest/ListValueNodeTest.cpp b/Sources/NodeEngineTest/ListValueNodeTest.cpp
@@ -72,7 +72,7 @@ class ListSummer : public SerializableTestNode
 	
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		NE::ValueConstPtr val = EvaluateSingleInputSlot (SlotId ("in"), env);
+		NE::ValueConstPtr val = EvaluateInputSlot (SlotId ("in"), env);
 		int result = 0;
 		if (IsComplexType<NumberValue> (val)) {
 			NE::FlatEnumerate (val, [&] (const NE::ValueConstPtr& value) {
@@ -94,7 +94,7 @@ TEST (ListValueNodeTest_Node)
 
 	{
 		ValueConstPtr result = listMakerNode->Evaluate (NE::EmptyEvaluationEnv);
-		ASSERT (Value::IsType<ListValue> (result));
+		ASSERT (result == nullptr);
 	}
 	
 	{
diff --git a/Sources/NodeEngineTest/MultiInputSlotTest.cpp b/Sources/NodeEngineTest/MultiInputSlotTest.cpp
@@ -77,7 +77,7 @@ class FlattenerNode : public SerializableTestNode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ListValueConstPtr val = EvaluateInputSlot (SlotId ("in"), env);
+		ValueConstPtr val = EvaluateInputSlot (SlotId ("in"), env);
 		ListValuePtr result (new ListValue ());
 		FlatEnumerate (val, [&] (const ValueConstPtr& flatVal) {
 			result->Push (flatVal->Clone ());
diff --git a/Sources/NodeEngineTest/NodeConnectionTest.cpp b/Sources/NodeEngineTest/NodeConnectionTest.cpp
@@ -143,8 +143,8 @@ class AdditionNode : public SerializableTestNode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ValueConstPtr firstResult = EvaluateSingleInputSlot (SlotId ("first"), env);
-		ValueConstPtr secondResult = EvaluateSingleInputSlot (SlotId ("second"), env);
+		ValueConstPtr firstResult = EvaluateInputSlot (SlotId ("first"), env);
+		ValueConstPtr secondResult = EvaluateInputSlot (SlotId ("second"), env);
 		return ValuePtr (new IntValue (IntValue::Get (firstResult) + IntValue::Get (secondResult)));
 	}
 };
@@ -166,9 +166,9 @@ class MultiAdditionNode : public SerializableTestNode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ListValueConstPtr result = EvaluateInputSlot (SlotId ("in"), env);
+		ValueConstPtr result = EvaluateInputSlot (SlotId ("in"), env);
 		int sum = 0;
-		result->Enumerate ([&] (const ValueConstPtr& val) {
+		FlatEnumerate (result, [&] (const ValueConstPtr& val) {
 			sum += IntValue::Get (val);
 		});
 		return ValuePtr (new IntValue (sum));
@@ -193,8 +193,8 @@ class DisabledAdditionNode : public SerializableTestNode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ValueConstPtr firstResult = EvaluateSingleInputSlot (SlotId ("first"), env);
-		ValueConstPtr secondResult = EvaluateSingleInputSlot (SlotId ("second"), env);
+		ValueConstPtr firstResult = EvaluateInputSlot (SlotId ("first"), env);
+		ValueConstPtr secondResult = EvaluateInputSlot (SlotId ("second"), env);
 		return ValuePtr (new IntValue (IntValue::Get (firstResult) + IntValue::Get (secondResult)));
 	}
 };
@@ -217,7 +217,7 @@ class AdderInputOutputNode : public SerializableTestNode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ValueConstPtr inputVal = EvaluateSingleInputSlot (SlotId ("in"), env);
+		ValueConstPtr inputVal = EvaluateInputSlot (SlotId ("in"), env);
 		return ValuePtr (new IntValue (IntValue::Get (inputVal) + toAdd));
 	}
 
diff --git a/Sources/NodeEngineTest/NodeManagerManualUpdateTest.cpp b/Sources/NodeEngineTest/NodeManagerManualUpdateTest.cpp
@@ -62,7 +62,7 @@ class IncreaseNode : public SerializableTestNode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ValueConstPtr in = EvaluateSingleInputSlot (SlotId ("in"), env);
+		ValueConstPtr in = EvaluateInputSlot (SlotId ("in"), env);
 		return ValuePtr (new IntValue (IntValue::Get (in) + 1));
 	}
 };
@@ -85,7 +85,7 @@ class IncreaseForceCalculatedNode : public SerializableTestNode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ValueConstPtr in = EvaluateSingleInputSlot (SlotId ("in"), env);
+		ValueConstPtr in = EvaluateInputSlot (SlotId ("in"), env);
 		if (in == nullptr) {
 			return nullptr;
 		}
diff --git a/Sources/NodeEngineTest/NodeManagerMergeTest.cpp b/Sources/NodeEngineTest/NodeManagerMergeTest.cpp
@@ -49,8 +49,8 @@ class TestNode : public Node
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ValueConstPtr a = EvaluateSingleInputSlot (SlotId ("a"), env);
-		ValueConstPtr b = EvaluateSingleInputSlot (SlotId ("b"), env);
+		ValueConstPtr a = EvaluateInputSlot (SlotId ("a"), env);
+		ValueConstPtr b = EvaluateInputSlot (SlotId ("b"), env);
 		int result = IntValue::Get (a) + IntValue::Get (b);
 		return ValuePtr (new IntValue (result));
 	}
diff --git a/Sources/NodeEngineTest/NodeManagerSerializationTest.cpp b/Sources/NodeEngineTest/NodeManagerSerializationTest.cpp
@@ -43,8 +43,8 @@ class TestNode : public Node
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ValueConstPtr firstResult = EvaluateSingleInputSlot (SlotId ("a"), env);
-		ValueConstPtr secondResult = EvaluateSingleInputSlot (SlotId ("b"), env);
+		ValueConstPtr firstResult = EvaluateInputSlot (SlotId ("a"), env);
+		ValueConstPtr secondResult = EvaluateInputSlot (SlotId ("b"), env);
 		return ValueConstPtr (new IntValue (val + IntValue::Get (firstResult) + IntValue::Get (secondResult)));
 	}
 
diff --git a/Sources/NodeEngineTest/NodeRecalculationTest.cpp b/Sources/NodeEngineTest/NodeRecalculationTest.cpp
@@ -29,7 +29,7 @@ class TestNode : public SerializableTestNode
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
 		calculationCounter++;
-		ValueConstPtr in = EvaluateSingleInputSlot (SlotId ("in"), env);
+		ValueConstPtr in = EvaluateInputSlot (SlotId ("in"), env);
 		return ValuePtr (new IntValue (IntValue::Get (in) + 1));
 	}
 
diff --git a/Sources/NodeEngineTest/NodeValueCacheTest.cpp b/Sources/NodeEngineTest/NodeValueCacheTest.cpp
@@ -51,7 +51,7 @@ class InputOutputNode : public SerializableTestNode
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
 		calculationCount++;
-		ValueConstPtr in = EvaluateSingleInputSlot (SlotId ("in"), env);
+		ValueConstPtr in = EvaluateInputSlot (SlotId ("in"), env);
 		return ValuePtr (new IntValue (IntValue::Get (in) + 1));
 	}
 
diff --git a/Sources/NodeEngineTest/NodeValueCombinationTest.cpp b/Sources/NodeEngineTest/NodeValueCombinationTest.cpp
@@ -33,8 +33,8 @@ class TestNode : public SerializableTestNode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		NE::ValueConstPtr a = EvaluateSingleInputSlot (NE::SlotId ("a"), env);
-		NE::ValueConstPtr b = EvaluateSingleInputSlot (NE::SlotId ("b"), env);
+		NE::ValueConstPtr a = EvaluateInputSlot (NE::SlotId ("a"), env);
+		NE::ValueConstPtr b = EvaluateInputSlot (NE::SlotId ("b"), env);
 		if (!NE::IsComplexType<NE::IntValue> (a) || !NE::IsComplexType<NE::IntValue> (b)) {
 			return nullptr;
 		}
diff --git a/Sources/NodeEngineTest/NumberTypeNodeTest.cpp b/Sources/NodeEngineTest/NumberTypeNodeTest.cpp
@@ -78,8 +78,8 @@ class NumberAdderNode : public SerializableTestNode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ValueConstPtr a = EvaluateSingleInputSlot (SlotId ("first"), env);
-		ValueConstPtr b = EvaluateSingleInputSlot (SlotId ("second"), env);
+		ValueConstPtr a = EvaluateInputSlot (SlotId ("first"), env);
+		ValueConstPtr b = EvaluateInputSlot (SlotId ("second"), env);
 		double result = NumberValue::ToDouble (a) + NumberValue::ToDouble (b);
 		return ValuePtr (new DoubleValue (result));
 	}
diff --git a/Sources/NodeEngineTest/TypeHandlingTest.cpp b/Sources/NodeEngineTest/TypeHandlingTest.cpp
@@ -204,7 +204,7 @@ class OutputNodeA : public SerializableTestNode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		return EvaluateSingleInputSlot (SlotId ("inA"), env);
+		return EvaluateInputSlot (SlotId ("inA"), env);
 	}
 };
 
@@ -234,7 +234,7 @@ class OutputNodeB : public SerializableTestNode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		return EvaluateSingleInputSlot (SlotId ("inB"), env);
+		return EvaluateInputSlot (SlotId ("inB"), env);
 	}
 };
 
diff --git a/Sources/NodeEngineTest/UINodeTest.cpp b/Sources/NodeEngineTest/UINodeTest.cpp
@@ -34,8 +34,8 @@ class TestNode : public SerializableTestUINode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ValueConstPtr a = EvaluateSingleInputSlot (SlotId ("in1"), env);
-		ValueConstPtr b = EvaluateSingleInputSlot (SlotId ("in2"), env);
+		ValueConstPtr a = EvaluateInputSlot (SlotId ("in1"), env);
+		ValueConstPtr b = EvaluateInputSlot (SlotId ("in2"), env);
 		int result = IntValue::Get (a) + IntValue::Get (b);
 		return ValuePtr (new IntValue (result));
 	}
@@ -80,8 +80,8 @@ class TestNode2 : public SerializableTestUINode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ValueConstPtr a = EvaluateSingleInputSlot (SlotId ("in1"), env);
-		ValueConstPtr b = EvaluateSingleInputSlot (SlotId ("in2"), env);
+		ValueConstPtr a = EvaluateInputSlot (SlotId ("in1"), env);
+		ValueConstPtr b = EvaluateInputSlot (SlotId ("in2"), env);
 		int result = IntValue::Get (a) + IntValue::Get (b);
 		return ValuePtr (new IntValue (result));
 	}
@@ -134,8 +134,8 @@ class EnumerationParamTestNode : public SerializableTestUINode
 
 	virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		ValueConstPtr a = EvaluateSingleInputSlot (SlotId ("in1"), env);
-		ValueConstPtr b = EvaluateSingleInputSlot (SlotId ("in2"), env);
+		ValueConstPtr a = EvaluateInputSlot (SlotId ("in1"), env);
+		ValueConstPtr b = EvaluateInputSlot (SlotId ("in2"), env);
 		int result = IntValue::Get (a) + IntValue::Get (b);
 		return ValuePtr (new IntValue (result));
 	}
diff --git a/Sources/NodeEngineTest/VisualTestFramework.cpp b/Sources/NodeEngineTest/VisualTestFramework.cpp
@@ -37,7 +37,7 @@ class IncreaseNode : public BI::BasicUINode
 
 	NE::ValueConstPtr Calculate (NE::EvaluationEnv& env) const override
 	{
-		NE::ValueConstPtr inValue = EvaluateSingleInputSlot (NE::SlotId ("in"), env);
+		NE::ValueConstPtr inValue = EvaluateInputSlot (NE::SlotId ("in"), env);
 		if (!IsSingleType<NE::IntValue> (inValue)) {
 			return nullptr;
 		}
diff --git a/Sources/wxWidgetsTestApp/TestAppNodes.cpp b/Sources/wxWidgetsTestApp/TestAppNodes.cpp

Original file line number	Diff line number	Diff line change
`@@ -38,8 +38,8 @@ void BinaryOperationNode::Initialize ()`
`38`	`38`
`39`	`39`	`NE::ValueConstPtr BinaryOperationNode::Calculate (NE::EvaluationEnv& env) const`
`40`	`40`	`{`
`41`		`- NE::ValueConstPtr aValue = EvaluateSingleInputSlot (NE::SlotId ("a"), env);`
`42`		`- NE::ValueConstPtr bValue = EvaluateSingleInputSlot (NE::SlotId ("b"), env);`
	`41`	`+ NE::ValueConstPtr aValue = EvaluateInputSlot (NE::SlotId ("a"), env);`
	`42`	`+ NE::ValueConstPtr bValue = EvaluateInputSlot (NE::SlotId ("b"), env);`
`43`	`43`	`if (!NE::IsComplexType<NE::NumberValue> (aValue) \|\| !NE::IsComplexType<NE::NumberValue> (bValue)) {`
`44`	`44`	`return nullptr;`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -527,9 +527,9 @@ void IntegerRangeNode::Initialize ()`
`527`	`527`
`528`	`528`	`NE::ValueConstPtr IntegerRangeNode::Calculate (NE::EvaluationEnv& env) const`
`529`	`529`	`{`
`530`		`- NE::ValueConstPtr start = EvaluateSingleInputSlot (NE::SlotId ("start"), env);`
`531`		`- NE::ValueConstPtr step = EvaluateSingleInputSlot (NE::SlotId ("step"), env);`
`532`		`- NE::ValueConstPtr count = EvaluateSingleInputSlot (NE::SlotId ("count"), env);`
	`530`	`+ NE::ValueConstPtr start = EvaluateInputSlot (NE::SlotId ("start"), env);`
	`531`	`+ NE::ValueConstPtr step = EvaluateInputSlot (NE::SlotId ("step"), env);`
	`532`	`+ NE::ValueConstPtr count = EvaluateInputSlot (NE::SlotId ("count"), env);`
`533`	`533`	`if (!NE::IsSingleType<NE::NumberValue> (start) \|\| !NE::IsSingleType<NE::NumberValue> (step) \|\| !NE::IsSingleType<NE::NumberValue> (count)) {`
`534`	`534`	`return nullptr;`
`535`	`535`	`}`
`@@ -609,9 +609,9 @@ void DoubleRangeNode::Initialize ()`
`609`	`609`
`610`	`610`	`NE::ValueConstPtr DoubleRangeNode::Calculate (NE::EvaluationEnv& env) const`
`611`	`611`	`{`
`612`		`- NE::ValueConstPtr start = EvaluateSingleInputSlot (NE::SlotId ("start"), env);`
`613`		`- NE::ValueConstPtr step = EvaluateSingleInputSlot (NE::SlotId ("step"), env);`
`614`		`- NE::ValueConstPtr count = EvaluateSingleInputSlot (NE::SlotId ("count"), env);`
	`612`	`+ NE::ValueConstPtr start = EvaluateInputSlot (NE::SlotId ("start"), env);`
	`613`	`+ NE::ValueConstPtr step = EvaluateInputSlot (NE::SlotId ("step"), env);`
	`614`	`+ NE::ValueConstPtr count = EvaluateInputSlot (NE::SlotId ("count"), env);`
`615`	`615`	`if (!NE::IsSingleType<NE::NumberValue> (start) \|\| !NE::IsSingleType<NE::NumberValue> (step) \|\| !NE::IsSingleType<NE::NumberValue> (count)) {`
`616`	`616`	`return nullptr;`
`617`	`617`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ void MultiLineViewerNode::Initialize ()`
`38`	`38`
`39`	`39`	`NE::ValueConstPtr MultiLineViewerNode::Calculate (NE::EvaluationEnv& env) const`
`40`	`40`	`{`
`41`		`- return EvaluateSingleInputSlot (NE::SlotId ("in"), env);`
	`41`	`+ return EvaluateInputSlot (NE::SlotId ("in"), env);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`void MultiLineViewerNode::RegisterParameters (NUIE::NodeParameterList& parameterList) const`
Original file line number	Diff line number	Diff line change
`@@ -82,8 +82,8 @@ class TestNode : public SerializableTestUINode`
`82`	`82`
`83`	`83`	`virtual ValueConstPtr Calculate (EvaluationEnv& env) const override`
`84`	`84`	`{`
`85`		`- ValueConstPtr a = EvaluateSingleInputSlot (SlotId ("in1"), env);`
`86`		`- ValueConstPtr b = EvaluateSingleInputSlot (SlotId ("in2"), env);`
	`85`	`+ ValueConstPtr a = EvaluateInputSlot (SlotId ("in1"), env);`
	`86`	`+ ValueConstPtr b = EvaluateInputSlot (SlotId ("in2"), env);`
`87`	`87`	`int result = IntValue::Get (a) + IntValue::Get (b);`
`88`	`88`	`return ValuePtr (new IntValue (result));`
`89`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ class ListSummer : public SerializableTestNode`
`72`	`72`
`73`	`73`	`virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override`
`74`	`74`	`{`
`75`		`- NE::ValueConstPtr val = EvaluateSingleInputSlot (SlotId ("in"), env);`
	`75`	`+ NE::ValueConstPtr val = EvaluateInputSlot (SlotId ("in"), env);`
`76`	`76`	`int result = 0;`
`77`	`77`	`if (IsComplexType<NumberValue> (val)) {`
`78`	`78`	`NE::FlatEnumerate (val, [&] (const NE::ValueConstPtr& value) {`
`@@ -94,7 +94,7 @@ TEST (ListValueNodeTest_Node)`
`94`	`94`
`95`	`95`	`{`
`96`	`96`	`ValueConstPtr result = listMakerNode->Evaluate (NE::EmptyEvaluationEnv);`
`97`		`- ASSERT (Value::IsType<ListValue> (result));`
	`97`	`+ ASSERT (result == nullptr);`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`{`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ class FlattenerNode : public SerializableTestNode`
`77`	`77`
`78`	`78`	`virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override`
`79`	`79`	`{`
`80`		`- ListValueConstPtr val = EvaluateInputSlot (SlotId ("in"), env);`
	`80`	`+ ValueConstPtr val = EvaluateInputSlot (SlotId ("in"), env);`
`81`	`81`	`ListValuePtr result (new ListValue ());`
`82`	`82`	`FlatEnumerate (val, [&] (const ValueConstPtr& flatVal) {`
`83`	`83`	`result->Push (flatVal->Clone ());`
Original file line number	Diff line number	Diff line change
`@@ -143,8 +143,8 @@ class AdditionNode : public SerializableTestNode`
`143`	`143`
`144`	`144`	`virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override`
`145`	`145`	`{`
`146`		`- ValueConstPtr firstResult = EvaluateSingleInputSlot (SlotId ("first"), env);`
`147`		`- ValueConstPtr secondResult = EvaluateSingleInputSlot (SlotId ("second"), env);`
	`146`	`+ ValueConstPtr firstResult = EvaluateInputSlot (SlotId ("first"), env);`
	`147`	`+ ValueConstPtr secondResult = EvaluateInputSlot (SlotId ("second"), env);`
`148`	`148`	`return ValuePtr (new IntValue (IntValue::Get (firstResult) + IntValue::Get (secondResult)));`
`149`	`149`	`}`
`150`	`150`	`};`
`@@ -166,9 +166,9 @@ class MultiAdditionNode : public SerializableTestNode`
`166`	`166`
`167`	`167`	`virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override`
`168`	`168`	`{`
`169`		`- ListValueConstPtr result = EvaluateInputSlot (SlotId ("in"), env);`
	`169`	`+ ValueConstPtr result = EvaluateInputSlot (SlotId ("in"), env);`
`170`	`170`	`int sum = 0;`
`171`		`- result->Enumerate ([&] (const ValueConstPtr& val) {`
	`171`	`+ FlatEnumerate (result, [&] (const ValueConstPtr& val) {`
`172`	`172`	`sum += IntValue::Get (val);`
`173`	`173`	`});`
`174`	`174`	`return ValuePtr (new IntValue (sum));`
`@@ -193,8 +193,8 @@ class DisabledAdditionNode : public SerializableTestNode`
`193`	`193`
`194`	`194`	`virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override`
`195`	`195`	`{`
`196`		`- ValueConstPtr firstResult = EvaluateSingleInputSlot (SlotId ("first"), env);`
`197`		`- ValueConstPtr secondResult = EvaluateSingleInputSlot (SlotId ("second"), env);`
	`196`	`+ ValueConstPtr firstResult = EvaluateInputSlot (SlotId ("first"), env);`
	`197`	`+ ValueConstPtr secondResult = EvaluateInputSlot (SlotId ("second"), env);`
`198`	`198`	`return ValuePtr (new IntValue (IntValue::Get (firstResult) + IntValue::Get (secondResult)));`
`199`	`199`	`}`
`200`	`200`	`};`
`@@ -217,7 +217,7 @@ class AdderInputOutputNode : public SerializableTestNode`
`217`	`217`
`218`	`218`	`virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override`
`219`	`219`	`{`
`220`		`- ValueConstPtr inputVal = EvaluateSingleInputSlot (SlotId ("in"), env);`
	`220`	`+ ValueConstPtr inputVal = EvaluateInputSlot (SlotId ("in"), env);`
`221`	`221`	`return ValuePtr (new IntValue (IntValue::Get (inputVal) + toAdd));`
`222`	`222`	`}`
`223`	`223`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ class IncreaseNode : public SerializableTestNode`
`62`	`62`
`63`	`63`	`virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override`
`64`	`64`	`{`
`65`		`- ValueConstPtr in = EvaluateSingleInputSlot (SlotId ("in"), env);`
	`65`	`+ ValueConstPtr in = EvaluateInputSlot (SlotId ("in"), env);`
`66`	`66`	`return ValuePtr (new IntValue (IntValue::Get (in) + 1));`
`67`	`67`	`}`
`68`	`68`	`};`
`@@ -85,7 +85,7 @@ class IncreaseForceCalculatedNode : public SerializableTestNode`
`85`	`85`
`86`	`86`	`virtual ValueConstPtr Calculate (NE::EvaluationEnv& env) const override`
`87`	`87`	`{`
`88`		`- ValueConstPtr in = EvaluateSingleInputSlot (SlotId ("in"), env);`
	`88`	`+ ValueConstPtr in = EvaluateInputSlot (SlotId ("in"), env);`
`89`	`89`	`if (in == nullptr) {`
`90`	`90`	`return nullptr;`
`91`	`91`	`}`