From cb3ef02e9c483596f3c146bc72325457e61d0b19 Mon Sep 17 00:00:00 2001
From: Neil <nyamatongwe@gmail.com>
Date: Fri, 29 Jul 2022 10:16:34 +1000
Subject: Flatten Partitioning and RunStyles to avoid a level of indirection by
 containing SplitVector and Partitioning directly instead of using
 std::unique_ptr. This will enable more value semantics and reduces potential
 memory allocation failure scenarios.

---
 src/RunStyles.cxx | 110 +++++++++++++++++++++++++++---------------------------
 1 file changed, 55 insertions(+), 55 deletions(-)

(limited to 'src/RunStyles.cxx')

diff --git a/src/RunStyles.cxx b/src/RunStyles.cxx
index 6d43e6085..37c76f921 100644
--- a/src/RunStyles.cxx
+++ b/src/RunStyles.cxx
@@ -31,9 +31,9 @@ using namespace Scintilla::Internal;
 // Find the first run at a position
 template <typename DISTANCE, typename STYLE>
 DISTANCE RunStyles<DISTANCE, STYLE>::RunFromPosition(DISTANCE position) const noexcept {
-	DISTANCE run = starts->PartitionFromPosition(position);
+	DISTANCE run = starts.PartitionFromPosition(position);
 	// Go to first element with this position
-	while ((run > 0) && (position == starts->PositionFromPartition(run-1))) {
+	while ((run > 0) && (position == starts.PositionFromPartition(run-1))) {
 		run--;
 	}
 	return run;
@@ -43,26 +43,26 @@ DISTANCE RunStyles<DISTANCE, STYLE>::RunFromPosition(DISTANCE position) const no
 template <typename DISTANCE, typename STYLE>
 DISTANCE RunStyles<DISTANCE, STYLE>::SplitRun(DISTANCE position) {
 	DISTANCE run = RunFromPosition(position);
-	const DISTANCE posRun = starts->PositionFromPartition(run);
+	const DISTANCE posRun = starts.PositionFromPartition(run);
 	if (posRun < position) {
 		STYLE runStyle = ValueAt(position);
 		run++;
-		starts->InsertPartition(run, position);
-		styles->InsertValue(run, 1, runStyle);
+		starts.InsertPartition(run, position);
+		styles.InsertValue(run, 1, runStyle);
 	}
 	return run;
 }
 
 template <typename DISTANCE, typename STYLE>
 void RunStyles<DISTANCE, STYLE>::RemoveRun(DISTANCE run) {
-	starts->RemovePartition(run);
-	styles->DeleteRange(run, 1);
+	starts.RemovePartition(run);
+	styles.DeleteRange(run, 1);
 }
 
 template <typename DISTANCE, typename STYLE>
 void RunStyles<DISTANCE, STYLE>::RemoveRunIfEmpty(DISTANCE run) {
-	if ((run < starts->Partitions()) && (starts->Partitions() > 1)) {
-		if (starts->PositionFromPartition(run) == starts->PositionFromPartition(run+1)) {
+	if ((run < starts.Partitions()) && (starts.Partitions() > 1)) {
+		if (starts.PositionFromPartition(run) == starts.PositionFromPartition(run+1)) {
 			RemoveRun(run);
 		}
 	}
@@ -70,9 +70,9 @@ void RunStyles<DISTANCE, STYLE>::RemoveRunIfEmpty(DISTANCE run) {
 
 template <typename DISTANCE, typename STYLE>
 void RunStyles<DISTANCE, STYLE>::RemoveRunIfSameAsPrevious(DISTANCE run) {
-	if ((run > 0) && (run < starts->Partitions())) {
+	if ((run > 0) && (run < starts.Partitions())) {
 		const DISTANCE runBefore = run - 1;
-		if (styles->ValueAt(runBefore) == styles->ValueAt(run)) {
+		if (styles.ValueAt(runBefore) == styles.ValueAt(run)) {
 			RemoveRun(run);
 		}
 	}
@@ -80,9 +80,9 @@ void RunStyles<DISTANCE, STYLE>::RemoveRunIfSameAsPrevious(DISTANCE run) {
 
 template <typename DISTANCE, typename STYLE>
 RunStyles<DISTANCE, STYLE>::RunStyles() {
-	starts = std::make_unique<Partitioning<DISTANCE>>(8);
-	styles = std::make_unique<SplitVector<STYLE>>();
-	styles->InsertValue(0, 2, 0);
+	starts = Partitioning<DISTANCE>(8);
+	styles = SplitVector<STYLE>();
+	styles.InsertValue(0, 2, 0);
 }
 
 template <typename DISTANCE, typename STYLE>
@@ -91,22 +91,22 @@ RunStyles<DISTANCE, STYLE>::~RunStyles() {
 
 template <typename DISTANCE, typename STYLE>
 DISTANCE RunStyles<DISTANCE, STYLE>::Length() const noexcept {
-	return starts->PositionFromPartition(starts->Partitions());
+	return starts.PositionFromPartition(starts.Partitions());
 }
 
 template <typename DISTANCE, typename STYLE>
 STYLE RunStyles<DISTANCE, STYLE>::ValueAt(DISTANCE position) const noexcept {
-	return styles->ValueAt(starts->PartitionFromPosition(position));
+	return styles.ValueAt(starts.PartitionFromPosition(position));
 }
 
 template <typename DISTANCE, typename STYLE>
 DISTANCE RunStyles<DISTANCE, STYLE>::FindNextChange(DISTANCE position, DISTANCE end) const noexcept {
-	const DISTANCE run = starts->PartitionFromPosition(position);
-	if (run < starts->Partitions()) {
-		const DISTANCE runChange = starts->PositionFromPartition(run);
+	const DISTANCE run = starts.PartitionFromPosition(position);
+	if (run < starts.Partitions()) {
+		const DISTANCE runChange = starts.PositionFromPartition(run);
 		if (runChange > position)
 			return runChange;
-		const DISTANCE nextChange = starts->PositionFromPartition(run + 1);
+		const DISTANCE nextChange = starts.PositionFromPartition(run + 1);
 		if (nextChange > position) {
 			return nextChange;
 		} else if (position < end) {
@@ -121,12 +121,12 @@ DISTANCE RunStyles<DISTANCE, STYLE>::FindNextChange(DISTANCE position, DISTANCE
 
 template <typename DISTANCE, typename STYLE>
 DISTANCE RunStyles<DISTANCE, STYLE>::StartRun(DISTANCE position) const noexcept {
-	return starts->PositionFromPartition(starts->PartitionFromPosition(position));
+	return starts.PositionFromPartition(starts.PartitionFromPosition(position));
 }
 
 template <typename DISTANCE, typename STYLE>
 DISTANCE RunStyles<DISTANCE, STYLE>::EndRun(DISTANCE position) const noexcept {
-	return starts->PositionFromPartition(starts->PartitionFromPosition(position) + 1);
+	return starts.PositionFromPartition(starts.PartitionFromPosition(position) + 1);
 }
 
 template <typename DISTANCE, typename STYLE>
@@ -140,9 +140,9 @@ FillResult<DISTANCE> RunStyles<DISTANCE, STYLE>::FillRange(DISTANCE position, ST
 		return resultNoChange;
 	}
 	DISTANCE runEnd = RunFromPosition(end);
-	if (styles->ValueAt(runEnd) == value) {
+	if (styles.ValueAt(runEnd) == value) {
 		// End already has value so trim range.
-		end = starts->PositionFromPartition(runEnd);
+		end = starts.PositionFromPartition(runEnd);
 		if (position >= end) {
 			// Whole range is already same as value so no action
 			return resultNoChange;
@@ -152,20 +152,20 @@ FillResult<DISTANCE> RunStyles<DISTANCE, STYLE>::FillRange(DISTANCE position, ST
 		runEnd = SplitRun(end);
 	}
 	DISTANCE runStart = RunFromPosition(position);
-	if (styles->ValueAt(runStart) == value) {
+	if (styles.ValueAt(runStart) == value) {
 		// Start is in expected value so trim range.
 		runStart++;
-		position = starts->PositionFromPartition(runStart);
+		position = starts.PositionFromPartition(runStart);
 		fillLength = end - position;
 	} else {
-		if (starts->PositionFromPartition(runStart) < position) {
+		if (starts.PositionFromPartition(runStart) < position) {
 			runStart = SplitRun(position);
 			runEnd++;
 		}
 	}
 	if (runStart < runEnd) {
 		const FillResult<DISTANCE> result{ true, position, fillLength };
-		styles->SetValueAt(runStart, value);
+		styles.SetValueAt(runStart, value);
 		// Remove each old run over the range
 		for (DISTANCE run=runStart+1; run<runEnd; run++) {
 			RemoveRun(runStart+1);
@@ -189,37 +189,37 @@ void RunStyles<DISTANCE, STYLE>::SetValueAt(DISTANCE position, STYLE value) {
 template <typename DISTANCE, typename STYLE>
 void RunStyles<DISTANCE, STYLE>::InsertSpace(DISTANCE position, DISTANCE insertLength) {
 	DISTANCE runStart = RunFromPosition(position);
-	if (starts->PositionFromPartition(runStart) == position) {
+	if (starts.PositionFromPartition(runStart) == position) {
 		STYLE runStyle = ValueAt(position);
 		// Inserting at start of run so make previous longer
 		if (runStart == 0) {
 			// Inserting at start of document so ensure 0
 			if (runStyle) {
-				styles->SetValueAt(0, STYLE());
-				starts->InsertPartition(1, 0);
-				styles->InsertValue(1, 1, runStyle);
-				starts->InsertText(0, insertLength);
+				styles.SetValueAt(0, STYLE());
+				starts.InsertPartition(1, 0);
+				styles.InsertValue(1, 1, runStyle);
+				starts.InsertText(0, insertLength);
 			} else {
-				starts->InsertText(runStart, insertLength);
+				starts.InsertText(runStart, insertLength);
 			}
 		} else {
 			if (runStyle) {
-				starts->InsertText(runStart-1, insertLength);
+				starts.InsertText(runStart-1, insertLength);
 			} else {
 				// Insert at end of run so do not extend style
-				starts->InsertText(runStart, insertLength);
+				starts.InsertText(runStart, insertLength);
 			}
 		}
 	} else {
-		starts->InsertText(runStart, insertLength);
+		starts.InsertText(runStart, insertLength);
 	}
 }
 
 template <typename DISTANCE, typename STYLE>
 void RunStyles<DISTANCE, STYLE>::DeleteAll() {
-	starts = std::make_unique<Partitioning<DISTANCE>>(8);
-	styles = std::make_unique<SplitVector<STYLE>>();
-	styles->InsertValue(0, 2, 0);
+	starts = Partitioning<DISTANCE>(8);
+	styles = SplitVector<STYLE>();
+	styles.InsertValue(0, 2, 0);
 }
 
 template <typename DISTANCE, typename STYLE>
@@ -229,12 +229,12 @@ void RunStyles<DISTANCE, STYLE>::DeleteRange(DISTANCE position, DISTANCE deleteL
 	DISTANCE runEnd = RunFromPosition(end);
 	if (runStart == runEnd) {
 		// Deleting from inside one run
-		starts->InsertText(runStart, -deleteLength);
+		starts.InsertText(runStart, -deleteLength);
 		RemoveRunIfEmpty(runStart);
 	} else {
 		runStart = SplitRun(position);
 		runEnd = SplitRun(end);
-		starts->InsertText(runStart, -deleteLength);
+		starts.InsertText(runStart, -deleteLength);
 		// Remove each old run over the range
 		for (DISTANCE run=runStart; run<runEnd; run++) {
 			RemoveRun(runStart);
@@ -246,14 +246,14 @@ void RunStyles<DISTANCE, STYLE>::DeleteRange(DISTANCE position, DISTANCE deleteL
 
 template <typename DISTANCE, typename STYLE>
 DISTANCE RunStyles<DISTANCE, STYLE>::Runs() const noexcept {
-	return starts->Partitions();
+	return starts.Partitions();
 }
 
 template <typename DISTANCE, typename STYLE>
 bool RunStyles<DISTANCE, STYLE>::AllSame() const noexcept {
-	for (DISTANCE run = 1; run < starts->Partitions(); run++) {
+	for (DISTANCE run = 1; run < starts.Partitions(); run++) {
 		const DISTANCE runBefore = run - 1;
-		if (styles->ValueAt(run) != styles->ValueAt(runBefore))
+		if (styles.ValueAt(run) != styles.ValueAt(runBefore))
 			return false;
 	}
 	return true;
@@ -261,19 +261,19 @@ bool RunStyles<DISTANCE, STYLE>::AllSame() const noexcept {
 
 template <typename DISTANCE, typename STYLE>
 bool RunStyles<DISTANCE, STYLE>::AllSameAs(STYLE value) const noexcept {
-	return AllSame() && (styles->ValueAt(0) == value);
+	return AllSame() && (styles.ValueAt(0) == value);
 }
 
 template <typename DISTANCE, typename STYLE>
 DISTANCE RunStyles<DISTANCE, STYLE>::Find(STYLE value, DISTANCE start) const noexcept {
 	if (start < Length()) {
 		DISTANCE run = start ? RunFromPosition(start) : 0;
-		if (styles->ValueAt(run) == value)
+		if (styles.ValueAt(run) == value)
 			return start;
 		run++;
-		while (run < starts->Partitions()) {
-			if (styles->ValueAt(run) == value)
-				return starts->PositionFromPartition(run);
+		while (run < starts.Partitions()) {
+			if (styles.ValueAt(run) == value)
+				return starts.PositionFromPartition(run);
 			run++;
 		}
 	}
@@ -285,10 +285,10 @@ void RunStyles<DISTANCE, STYLE>::Check() const {
 	if (Length() < 0) {
 		throw std::runtime_error("RunStyles: Length can not be negative.");
 	}
-	if (starts->Partitions() < 1) {
+	if (starts.Partitions() < 1) {
 		throw std::runtime_error("RunStyles: Must always have 1 or more partitions.");
 	}
-	if (starts->Partitions() != styles->Length()-1) {
+	if (starts.Partitions() != styles.Length()-1) {
 		throw std::runtime_error("RunStyles: Partitions and styles different lengths.");
 	}
 	DISTANCE start=0;
@@ -299,11 +299,11 @@ void RunStyles<DISTANCE, STYLE>::Check() const {
 		}
 		start = end;
 	}
-	if (styles->ValueAt(styles->Length()-1) != 0) {
+	if (styles.ValueAt(styles.Length()-1) != 0) {
 		throw std::runtime_error("RunStyles: Unused style at end changed.");
 	}
-	for (ptrdiff_t j=1; j<styles->Length()-1; j++) {
-		if (styles->ValueAt(j) == styles->ValueAt(j-1)) {
+	for (ptrdiff_t j=1; j<styles.Length()-1; j++) {
+		if (styles.ValueAt(j) == styles.ValueAt(j-1)) {
 			throw std::runtime_error("RunStyles: Style of a partition same as previous.");
 		}
 	}
-- 
cgit v1.2.3