Rename functions in `MessageHandlerElement`

include/rtc/h264rtppacketizer.hpp

@@ -55,7 +55,7 @@ public:
 	H264RtpPacketizer(std::shared_ptr<RtpPacketizationConfig> rtpConfig,
 					  uint16_t maximumFragmentSize = NalUnits::defaultMaximumFragmentSize);
 
-	ChainedOutgoingProduct modifyOutgoingBinary(ChainedMessagesProduct messages, std::optional<message_ptr> control) override;
+	ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) override;
 private:
 	const Separator separator;
 };

include/rtc/messagehandlerelement.hpp

@@ -54,7 +54,7 @@ struct RTC_CPP_EXPORT ChainedIncomingProduct {
 
 /// Incoming control messages with response
 struct RTC_CPP_EXPORT ChainedIncomingControlProduct {
-	ChainedIncomingControlProduct(message_ptr incoming, std::optional<ChainedMessagesProduct> outgoing = nullopt);
+	ChainedIncomingControlProduct(message_ptr incoming, std::optional<ChainedOutgoingResponseProduct> outgoing = nullopt);
 	const std::optional<message_ptr> incoming;
 	const std::optional<ChainedOutgoingResponseProduct> outgoing;
 };
@@ -76,31 +76,31 @@ public:
 	std::optional<ChainedOutgoingResponseProduct> processOutgoingResponse(ChainedOutgoingResponseProduct messages);
 
 	// Process incoming and ougoing messages
-	std::optional<message_ptr> processIncomingControl(message_ptr message, std::function<bool (ChainedOutgoingResponseProduct)> send);
-	std::optional<ChainedMessagesProduct> processIncomingBinary(ChainedMessagesProduct messages, std::function<bool (ChainedOutgoingResponseProduct)> send);
-	std::optional<message_ptr> processOutgoingControl(message_ptr message);
-	std::optional<ChainedOutgoingProduct> processOutgoingBinary(ChainedOutgoingProduct product);
+	std::optional<message_ptr> formIncomingControlMessage(message_ptr message, std::function<bool (ChainedOutgoingResponseProduct)> send);
+	std::optional<ChainedMessagesProduct> formIncomingBinaryMessage(ChainedMessagesProduct messages, std::function<bool (ChainedOutgoingResponseProduct)> send);
+	std::optional<message_ptr> formOutgoingControlMessage(message_ptr message);
+	std::optional<ChainedOutgoingProduct> formOutgoingBinaryMessage(ChainedOutgoingProduct product);
 
-	/// Modifies current control message
+	/// Process current control message
 	/// @param messages current message
 	/// @returns Modified message and response
-	virtual ChainedIncomingControlProduct modifyIncomingControl(message_ptr messages);
+	virtual ChainedIncomingControlProduct processIncomingControlMessage(message_ptr messages);
 
-	/// Modifies current control message
+	/// Process current control message
 	/// @param messages current message
 	/// @returns Modified message
-	virtual message_ptr modifyOutgoingControl(message_ptr messages);
+	virtual message_ptr processOutgoingControlMessage(message_ptr messages);
 
-	/// Modifies current binary message
+	/// Process current binary message
 	/// @param messages current message
 	/// @returns Modified message and response
-	virtual ChainedIncomingProduct modifyIncomingBinary(ChainedMessagesProduct messages);
+	virtual ChainedIncomingProduct processIncomingBinaryMessage(ChainedMessagesProduct messages);
 
-	/// Modifies current binary message
+	/// Process current binary message
 	/// @param messages current message
 	/// @param control current control message
 	/// @returns Modified binary message and control message
-	virtual ChainedOutgoingProduct modifyOutgoingBinary(ChainedMessagesProduct messages, std::optional<message_ptr> control);
+	virtual ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control);
 
 	/// Set given element as upstream to this
 	/// @param upstream Upstream element

include/rtc/opusrtppacketizer.hpp

@@ -48,7 +48,7 @@ public:
 	/// @param messages opus samples
 	/// @param control RTCP
 	/// @returns RTP packets and unchanged `control`
-	ChainedOutgoingProduct modifyOutgoingBinary(ChainedMessagesProduct messages, std::optional<message_ptr> control) override;
+	ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) override;
 };
 
 } // namespace rtc

include/rtc/rtcpsrreporter.hpp

@@ -50,7 +50,7 @@ public:
 
 	RtcpSRReporter(std::shared_ptr<RtpPacketizationConfig> rtpConfig);
 
-	ChainedOutgoingProduct modifyOutgoingBinary(ChainedMessagesProduct messages, std::optional<message_ptr> control) override;
+	ChainedOutgoingProduct processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) override;
 
 	/// Set `needsToReport` flag. Sender report will be sent before next RTP packet with same
 	/// timestamp.

src/h264rtppacketizer.cpp

@@ -139,7 +139,7 @@ H264RtpPacketizer::H264RtpPacketizer(H264RtpPacketizer::Separator separator, std
 									 uint16_t maximumFragmentSize)
 : RtpPacketizer(rtpConfig), MessageHandlerRootElement(), maximumFragmentSize(maximumFragmentSize), separator(separator) {}
 
-ChainedOutgoingProduct H264RtpPacketizer::modifyOutgoingBinary(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
+ChainedOutgoingProduct H264RtpPacketizer::processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
 	ChainedMessagesProduct packets = std::make_shared<std::vector<binary_ptr>>();
 	for (auto message: *messages) {
 		auto nalus = splitMessage(message);

src/messagehandlerelement.cpp

@@ -22,8 +22,7 @@
 namespace rtc {
 
 ChainedMessagesProduct make_chained_messages_product() {
-	std::vector<binary_ptr> msgs = {};
-	return std::make_shared<std::vector<binary_ptr>>(msgs);
+	return std::make_shared<std::vector<binary_ptr>>();
 }
 
 ChainedMessagesProduct make_chained_messages_product(message_ptr msg) {
@@ -40,7 +39,7 @@ ChainedOutgoingResponseProduct::ChainedOutgoingResponseProduct(std::optional<Cha
 ChainedIncomingProduct::ChainedIncomingProduct(std::optional<ChainedMessagesProduct> incoming, std::optional<ChainedMessagesProduct> outgoing)
 : incoming(incoming), outgoing(outgoing) { }
 
-ChainedIncomingControlProduct::ChainedIncomingControlProduct(message_ptr incoming, std::optional<ChainedMessagesProduct> outgoing)
+ChainedIncomingControlProduct::ChainedIncomingControlProduct(message_ptr incoming, std::optional<ChainedOutgoingResponseProduct> outgoing)
 : incoming(incoming), outgoing(outgoing) { }
 
 MessageHandlerElement::MessageHandlerElement() { }
@@ -66,7 +65,7 @@ void MessageHandlerElement::recursiveRemoveChain() {
 std::optional<ChainedOutgoingResponseProduct> MessageHandlerElement::processOutgoingResponse(ChainedOutgoingResponseProduct messages) {
 	if (messages.messages.has_value()) {
 		if (upstream.has_value()) {
-			auto msgs = upstream.value()->processOutgoingBinary(ChainedOutgoingProduct(messages.messages.value(), messages.control));
+			auto msgs = upstream.value()->formOutgoingBinaryMessage(ChainedOutgoingProduct(messages.messages.value(), messages.control));
 			if (msgs.has_value()) {
 				auto messages = msgs.value();
 				return ChainedOutgoingResponseProduct(std::make_optional(messages.messages), messages.control);
@@ -79,7 +78,7 @@ std::optional<ChainedOutgoingResponseProduct> MessageHandlerElement::processOutg
 		}
 	} else if (messages.control.has_value()) {
 		if (upstream.has_value()) {
-			auto control = upstream.value()->processOutgoingControl(messages.control.value());
+			auto control = upstream.value()->formOutgoingControlMessage(messages.control.value());
 			if (control.has_value()) {
 				return ChainedOutgoingResponseProduct(nullopt, control.value());
 			} else {
@@ -108,14 +107,14 @@ void MessageHandlerElement::prepareAndSendResponse(std::optional<ChainedOutgoing
 	}
 }
 
-std::optional<message_ptr> MessageHandlerElement::processIncomingControl(message_ptr message, std::function<bool (ChainedOutgoingResponseProduct)> send) {
+std::optional<message_ptr> MessageHandlerElement::formIncomingControlMessage(message_ptr message, std::function<bool (ChainedOutgoingResponseProduct)> send) {
 	assert(message);
-	auto product = modifyIncomingControl(message);
+	auto product = processIncomingControlMessage(message);
 	prepareAndSendResponse(product.outgoing, send);
 	if (product.incoming.has_value()) {
 		if (downstream.has_value()) {
 			if (product.incoming.value()) {
-				return downstream.value()->processIncomingControl(product.incoming.value(), send);
+				return downstream.value()->formIncomingControlMessage(product.incoming.value(), send);
 			} else {
 				LOG_DEBUG << "Failed to generate incoming message";
 				return nullopt;
@@ -128,14 +127,14 @@ std::optional<message_ptr> MessageHandlerElement::processIncomingControl(message
 	}
 }
 
-std::optional<ChainedMessagesProduct> MessageHandlerElement::processIncomingBinary(ChainedMessagesProduct messages, std::function<bool (ChainedOutgoingResponseProduct)> send) {
+std::optional<ChainedMessagesProduct> MessageHandlerElement::formIncomingBinaryMessage(ChainedMessagesProduct messages, std::function<bool (ChainedOutgoingResponseProduct)> send) {
 	assert(messages && !messages->empty());
-	auto product = modifyIncomingBinary(messages);
+	auto product = processIncomingBinaryMessage(messages);
 	prepareAndSendResponse(product.outgoing, send);
 	if (product.incoming.has_value()) {
 		if (downstream.has_value()) {
 			if (product.incoming.value()) {
-				return downstream.value()->processIncomingBinary(product.incoming.value(), send);
+				return downstream.value()->formIncomingBinaryMessage(product.incoming.value(), send);
 			} else {
 				LOG_ERROR << "Failed to generate incoming message";
 				return nullopt;
@@ -148,24 +147,24 @@ std::optional<ChainedMessagesProduct> MessageHandlerElement::processIncomingBina
 	}
 }
 
-std::optional<message_ptr> MessageHandlerElement::processOutgoingControl(message_ptr message) {
+std::optional<message_ptr> MessageHandlerElement::formOutgoingControlMessage(message_ptr message) {
 	assert(message);
-	auto newMessage = modifyOutgoingControl(message);
+	auto newMessage = processOutgoingControlMessage(message);
 	assert(newMessage);
 	if(!newMessage) {
 		LOG_ERROR << "Failed to generate outgoing message";
 		return nullopt;
 	}
 	if (upstream.has_value()) {
-		return upstream.value()->processOutgoingControl(newMessage);
+		return upstream.value()->formOutgoingControlMessage(newMessage);
 	} else {
 		return newMessage;
 	}
 }
 
-std::optional<ChainedOutgoingProduct> MessageHandlerElement::processOutgoingBinary(ChainedOutgoingProduct product) {
+std::optional<ChainedOutgoingProduct> MessageHandlerElement::formOutgoingBinaryMessage(ChainedOutgoingProduct product) {
 	assert(product.messages && !product.messages->empty());
-	auto newProduct = modifyOutgoingBinary(product.messages, product.control);
+	auto newProduct = processOutgoingBinaryMessage(product.messages, product.control);
 	assert(!product.control.has_value() || newProduct.control.has_value());
 	assert(!newProduct.control.has_value() || newProduct.control.value());
 	assert(newProduct.messages && !newProduct.messages->empty());
@@ -182,25 +181,25 @@ std::optional<ChainedOutgoingProduct> MessageHandlerElement::processOutgoingBina
 		return nullopt;
 	}
 	if (upstream.has_value()) {
-		return upstream.value()->processOutgoingBinary(newProduct);
+		return upstream.value()->formOutgoingBinaryMessage(newProduct);
 	} else {
 		return newProduct;
 	}
 }
 
-ChainedIncomingControlProduct MessageHandlerElement::modifyIncomingControl(message_ptr messages) {
+ChainedIncomingControlProduct MessageHandlerElement::processIncomingControlMessage(message_ptr messages) {
 	return {messages};
 }
 
-message_ptr MessageHandlerElement::modifyOutgoingControl(message_ptr messages) {
+message_ptr MessageHandlerElement::processOutgoingControlMessage(message_ptr messages) {
 	return messages;
 }
 
-ChainedIncomingProduct MessageHandlerElement::modifyIncomingBinary(ChainedMessagesProduct messages) {
+ChainedIncomingProduct MessageHandlerElement::processIncomingBinaryMessage(ChainedMessagesProduct messages) {
 	return {messages};
 }
 
-ChainedOutgoingProduct MessageHandlerElement::modifyOutgoingBinary(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
+ChainedOutgoingProduct MessageHandlerElement::processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
 	return {messages, control};
 }
 

src/opusrtppacketizer.cpp

@@ -30,7 +30,7 @@ binary_ptr OpusRtpPacketizer::packetize(binary_ptr payload, bool setMark) {
 	return RtpPacketizer::packetize(payload, false);
 }
 
-ChainedOutgoingProduct OpusRtpPacketizer::modifyOutgoingBinary(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
+ChainedOutgoingProduct OpusRtpPacketizer::processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
 	ChainedMessagesProduct packets = make_chained_messages_product();
 	packets->reserve(messages->size());
 	for (auto message: *messages) {

src/rtcpchainablehandler.cpp

@@ -56,7 +56,7 @@ bool RtcpChainableHandler::sendProduct(ChainedOutgoingResponseProduct product) {
 std::optional<message_ptr> RtcpChainableHandler::handleIncomingBinary(message_ptr msg) {
 	assert(msg->type == Message::Binary);
 	auto messages = root->split(msg);
-	auto incoming = leaf->processIncomingBinary(messages, [this](ChainedOutgoingResponseProduct outgoing) {
+	auto incoming = leaf->formIncomingBinaryMessage(messages, [this](ChainedOutgoingResponseProduct outgoing) {
 		return sendProduct(outgoing);
 	});
 	if (incoming.has_value()) {
@@ -68,7 +68,7 @@ std::optional<message_ptr> RtcpChainableHandler::handleIncomingBinary(message_pt
 
 std::optional<message_ptr> RtcpChainableHandler::handleIncomingControl(message_ptr msg) {
 	assert(msg->type == Message::Control);
-	auto incoming = leaf->processIncomingControl(msg, [this](ChainedOutgoingResponseProduct outgoing) {
+	auto incoming = leaf->formIncomingControlMessage(msg, [this](ChainedOutgoingResponseProduct outgoing) {
 		return sendProduct(outgoing);
 	});
 	assert(!incoming.has_value() || incoming.value()->type == Message::Control);
@@ -78,7 +78,7 @@ std::optional<message_ptr> RtcpChainableHandler::handleIncomingControl(message_p
 std::optional<message_ptr> RtcpChainableHandler::handleOutgoingBinary(message_ptr msg) {
 	assert(msg->type == Message::Binary);
 	auto messages = make_chained_messages_product(msg);
-	auto optOutgoing = root->processOutgoingBinary(ChainedOutgoingProduct(messages));
+	auto optOutgoing = root->formOutgoingBinaryMessage(ChainedOutgoingProduct(messages));
 	if (!optOutgoing.has_value()) {
 		LOG_ERROR << "Generating outgoing message failed";
 		return nullopt;
@@ -108,7 +108,7 @@ std::optional<message_ptr> RtcpChainableHandler::handleOutgoingBinary(message_pt
 
 std::optional<message_ptr> RtcpChainableHandler::handleOutgoingControl(message_ptr msg) {
 	assert(msg->type == Message::Control);
-	auto optOutgoing = root->processOutgoingControl(msg);
+	auto optOutgoing = root->formOutgoingControlMessage(msg);
 	assert(!optOutgoing.has_value() || optOutgoing.value()->type == Message::Control);
 	if (!optOutgoing.has_value()) {
 		LOG_ERROR << "Generating outgoing control message failed";

src/rtcpsrreporter.cpp

@@ -21,7 +21,7 @@
 
 namespace rtc {
 
-ChainedOutgoingProduct RtcpSRReporter::modifyOutgoingBinary(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
+ChainedOutgoingProduct RtcpSRReporter::processOutgoingBinaryMessage(ChainedMessagesProduct messages, std::optional<message_ptr> control) {
 	if (needsToReport) {
 		auto timestamp = rtpConfig->timestamp;
 		auto sr = getSenderReport(timestamp);