find external states also in writing-interfaces

Essential for SerialContainer that spawns multiple solutions
with the same end state.

Author: v4hn

core/src/container.cpp

@@ -206,15 +206,26 @@ void ContainerBasePrivate::copyState(Interface::iterator external, const Interfa
 void ContainerBasePrivate::liftSolution(const SolutionBasePtr& solution, const InterfaceState* internal_from,
                                         const InterfaceState* internal_to, InterfaceState* new_from,
                                         InterfaceState* new_to) {
-	const bool create_from{ requiredInterface().testFlag(WRITES_PREV_END) };
-	const bool create_to{ requiredInterface().testFlag(WRITES_NEXT_START) };
+	// NOLINTNEXTLINE(readability-identifier-naming)
+	auto findExternal = [this](InterfaceState* replacement, const InterfaceState* internal) -> const InterfaceState* {
+		auto it = internalToExternalMap().find(internal);
+		if (it != internalToExternalMap().end()) {
+			return &*it->second;
+		}
+
+		// if replacement has been created before it was returned above already
+		if (replacement)
+			return replacement;
+
+		return nullptr;
+	};
 
 	// external states, nullptr if they don't exist yet
-	const InterfaceState* external_from{ create_from ? new_from : internalToExternalMap().at(internal_from) };
-	const InterfaceState* external_to{ create_to ? new_to : internalToExternalMap().at(internal_to) };
+	const InterfaceState* external_from{ findExternal(new_from, internal_from) };
+	const InterfaceState* external_to{ findExternal(new_to, internal_to) };
 
 	// computeCost
-	// we can pass intern_{from/to} here because in this case the lifted states that might be created later
+	// we can pass internal_{from/to} here because in this case the lifted states that might be created later
 	// are equivalent up to the connected Solutions (which are not relevant for CostTerms)
 	computeCost(external_from ? *external_from : *internal_from, external_to ? *external_to : *internal_to, *solution);
 
@@ -223,21 +234,31 @@ void ContainerBasePrivate::liftSolution(const SolutionBasePtr& solution, const I
 		return;
 	}
 
-	auto create_state = [this](const InterfaceState& internal, InterfaceState* new_external) {
+	// create unstored states in stage-internal storage
+
+	// NOLINTNEXTLINE(readability-identifier-naming)
+	auto createState = [this](const InterfaceState& internal, InterfaceState* new_external) {
 		InterfaceState* external{ storeState(new_external ? std::move(*new_external) : InterfaceState{ internal }) };
 		internalToExternalMap().insert(std::make_pair(&internal, external));
 		return external;
 	};
 
-	if (create_from)
-		external_from = create_state(*internal_from, new_from);
-	if (create_to)
-		external_to = create_state(*internal_to, new_to);
+	const bool create_from{ new_from != nullptr || external_from == nullptr };
+	const bool create_to{ new_to != nullptr || external_to == nullptr };
+
+	if (create_from) {
+		assert(requiredInterface().testFlag(WRITES_PREV_END));
+		external_from = createState(*internal_from, new_from);
+	}
+	if (create_to) {
+		assert(requiredInterface().testFlag(WRITES_NEXT_START));
+		external_to = createState(*internal_to, new_to);
+	}
 
 	assert(external_from);
 	assert(external_to);
 
-	// connect solution to states
+	// connect solution to stored states
 	solution->setStartState(*external_from);
 	solution->setEndState(*external_to);