GP-1543: Replace Range<Long> with Lifespan, ULongSpan, KeySpan,

FieldSpan

Ghidra/Debug/Framework-TraceModeling/src/main/java/docking/widgets/model/GSpanField.java

@@ -0,0 +1,172 @@
+/* ###
+ * IP: GHIDRA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package docking.widgets.model;
+
+import java.awt.Component;
+import java.awt.event.FocusAdapter;
+import java.awt.event.FocusEvent;
+
+import javax.swing.*;
+
+import ghidra.trace.model.Lifespan;
+
+public class GSpanField extends JPanel {
+	private static final String NEG_INF = "-\u221e";
+	private static final String POS_INF = "+\u221e";
+
+	private final JLabel labelLower = new JLabel("[");
+	private final JComboBox<String> fieldMin = new JComboBox<>();
+	private final JComboBox<String> fieldMax = new JComboBox<>();
+	private final JLabel labelUpper = new JLabel("]");
+
+	private final DefaultComboBoxModel<String> modelMin = new DefaultComboBoxModel<>();
+	private final DefaultComboBoxModel<String> modelMax = new DefaultComboBoxModel<>();
+
+	public GSpanField() {
+		setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
+
+		add(labelLower);
+		add(fieldMin);
+		add(new JLabel("\u2025"));
+		add(fieldMax);
+		add(labelUpper);
+
+		modelMin.addElement(NEG_INF);
+		modelMax.addElement(POS_INF);
+
+		fieldMin.setEditable(true);
+		fieldMin.setModel(modelMin);
+		fieldMax.setEditable(true);
+		fieldMax.setModel(modelMax);
+
+		fieldMin.getEditor().getEditorComponent().addFocusListener(new FocusAdapter() {
+			@Override
+			public void focusLost(FocusEvent e) {
+				minFocusLost(e);
+				checkDispatchFocus(e);
+			}
+		});
+		fieldMax.getEditor().getEditorComponent().addFocusListener(new FocusAdapter() {
+			@Override
+			public void focusLost(FocusEvent e) {
+				maxFocusLost(e);
+				checkDispatchFocus(e);
+			}
+		});
+	}
+
+	protected void checkDispatchFocus(FocusEvent e) {
+		Component opp = e.getOppositeComponent();
+		if (opp == null || !SwingUtilities.isDescendingFrom(opp, this)) {
+			dispatchEvent(e);
+		}
+	}
+
+	protected long parseLong(String text, long defaultVal) {
+		try {
+			return Long.parseLong(text);
+		}
+		catch (NumberFormatException e) {
+			return defaultVal;
+		}
+	}
+
+	protected void revalidateMin() {
+		String value = (String) fieldMin.getSelectedItem();
+		if (NEG_INF.equals(value)) {
+			labelLower.setText("(");
+		}
+		else {
+			fieldMin.setSelectedItem(Long.toString(parseLong(value, 0)));
+			labelLower.setText("[");
+		}
+	}
+
+	protected void revalidateMax() {
+		String value = (String) fieldMax.getSelectedItem();
+		if (POS_INF.equals(value)) {
+			labelUpper.setText(")");
+		}
+		else {
+			fieldMax.setSelectedItem(Long.toString(parseLong(value, 0)));
+			labelUpper.setText("]");
+		}
+	}
+
+	protected void adjustMaxToMin() {
+		if (unbounded()) {
+			return;
+		}
+		long min = parseLong((String) fieldMin.getSelectedItem(), 0);
+		long max = Math.max(min, parseLong((String) fieldMax.getSelectedItem(), min));
+		fieldMax.setSelectedItem(Long.toString(max));
+	}
+
+	protected boolean unbounded() {
+		return NEG_INF.equals(fieldMin.getSelectedItem()) ||
+			POS_INF.equals(fieldMax.getSelectedItem());
+	}
+
+	protected void adjustMinToMax() {
+		if (unbounded()) {
+			return;
+		}
+		long max = parseLong((String) fieldMax.getSelectedItem(), 0);
+		long min = Math.min(max, parseLong((String) fieldMin.getSelectedItem(), max));
+		fieldMin.setSelectedItem(Long.toString(min));
+	}
+
+	protected void minFocusLost(FocusEvent e) {
+		revalidateMin();
+		adjustMaxToMin();
+	}
+
+	protected void maxFocusLost(FocusEvent e) {
+		revalidateMax();
+		adjustMinToMax();
+	}
+
+	public void setLifespan(Lifespan lifespan) {
+		if (!lifespan.minIsFinite()) {
+			fieldMin.setSelectedItem(NEG_INF);
+		}
+		else {
+			fieldMin.setSelectedItem(Long.toString(lifespan.lmin()));
+		}
+
+		if (!lifespan.maxIsFinite()) {
+			fieldMax.setSelectedItem(POS_INF);
+		}
+		else {
+			fieldMax.setSelectedItem(Long.toString(lifespan.lmax()));
+		}
+	}
+
+	public Lifespan getLifespan() {
+		String minStr = (String) fieldMin.getSelectedItem();
+		String maxStr = (String) fieldMax.getSelectedItem();
+		long min = NEG_INF.equals(minStr) ? Lifespan.DOMAIN.lmin() : Long.parseLong(minStr);
+		long max = POS_INF.equals(maxStr) ? Lifespan.DOMAIN.lmax() : Long.parseLong(maxStr);
+		return Lifespan.span(min, max);
+	}
+
+	@Override
+	public void setEnabled(boolean enabled) {
+		super.setEnabled(enabled);
+		fieldMin.setEnabled(enabled);
+		fieldMax.setEnabled(enabled);
+	}
+}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/AbstractCheckedTraceCachedWriteBytesPcodeExecutorStatePiece.java

@@ -15,9 +15,7 @@
  */
 package ghidra.pcode.exec.trace;
 
-import com.google.common.collect.RangeSet;
-import com.google.common.primitives.UnsignedLong;
-
+import generic.ULongSpan.ULongSpanSet;
 import ghidra.pcode.exec.trace.data.PcodeTraceDataAccess;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.Language;
@@ -42,7 +40,7 @@ public abstract class AbstractCheckedTraceCachedWriteBytesPcodeExecutorStatePiec
 
 		@Override
 		public byte[] read(long offset, int size, Reason reason) {
-			RangeSet<UnsignedLong> uninitialized =
+			ULongSpanSet uninitialized =
 				bytes.getUninitialized(offset, offset + size - 1);
 			if (!uninitialized.isEmpty()) {
 				size = checkUninitialized(backing, space.getAddress(offset), size,

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/BytesTracePcodeExecutorStatePiece.java

@@ -17,10 +17,8 @@ package ghidra.pcode.exec.trace;
 
 import java.nio.ByteBuffer;
 
-import com.google.common.collect.Range;
-import com.google.common.collect.RangeSet;
-import com.google.common.primitives.UnsignedLong;
-
+import generic.ULongSpan;
+import generic.ULongSpan.ULongSpanSet;
 import ghidra.pcode.exec.AbstractBytesPcodeExecutorStatePiece;
 import ghidra.pcode.exec.BytesPcodeExecutorStateSpace;
 import ghidra.pcode.exec.trace.BytesTracePcodeExecutorStatePiece.CachedSpace;
@@ -65,21 +63,17 @@ public class BytesTracePcodeExecutorStatePiece
 		}
 
 		@Override
-		protected void readUninitializedFromBacking(RangeSet<UnsignedLong> uninitialized) {
+		protected void readUninitializedFromBacking(ULongSpanSet uninitialized) {
 			if (!uninitialized.isEmpty()) {
 				// TODO: Warn or bail when reading UNKNOWN bytes
 				// NOTE: Read without regard to gaps
 				// NOTE: Cannot write those gaps, though!!!
-				Range<UnsignedLong> toRead = uninitialized.span();
-				assert toRead.hasUpperBound() && toRead.hasLowerBound();
-				long lower = lower(toRead);
-				long upper = upper(toRead);
-				ByteBuffer buf = ByteBuffer.allocate((int) (upper - lower + 1));
-				backing.getBytes(space.getAddress(lower), buf);
-				for (Range<UnsignedLong> rng : uninitialized.asRanges()) {
-					long l = lower(rng);
-					long u = upper(rng);
-					bytes.putData(l, buf.array(), (int) (l - lower), (int) (u - l + 1));
+				ULongSpan bound = uninitialized.bound();
+				ByteBuffer buf = ByteBuffer.allocate((int) bound.length());
+				backing.getBytes(space.getAddress(bound.min()), buf);
+				for (ULongSpan span : uninitialized.spans()) {
+					bytes.putData(span.min(), buf.array(), (int) (span.min() - bound.min()),
+						(int) span.length());
 				}
 			}
 		}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/TraceMemoryStatePcodeExecutorStatePiece.java

@@ -15,11 +15,10 @@
  */
 package ghidra.pcode.exec.trace;
 
-import java.util.Map;
-
-import com.google.common.collect.*;
-import com.google.common.primitives.UnsignedLong;
+import java.util.Map.Entry;
 
+import generic.ULongSpan;
+import generic.ULongSpan.*;
 import ghidra.pcode.exec.*;
 import ghidra.pcode.exec.PcodeArithmetic.Purpose;
 import ghidra.pcode.exec.trace.data.PcodeTraceDataAccess;
@@ -43,7 +42,7 @@ import ghidra.trace.model.memory.TraceMemoryState;
 public class TraceMemoryStatePcodeExecutorStatePiece extends
 		AbstractLongOffsetPcodeExecutorStatePiece<byte[], TraceMemoryState, AddressSpace> {
 
-	protected final RangeMap<UnsignedLong, TraceMemoryState> unique = TreeRangeMap.create();
+	protected final MutableULongSpanMap<TraceMemoryState> unique = new DefaultULongSpanMap<>();
 	protected final PcodeTraceDataAccess data;
 
 	/**
@@ -58,11 +57,6 @@ public class TraceMemoryStatePcodeExecutorStatePiece extends
 		this.data = data;
 	}
 
-	protected Range<UnsignedLong> range(long offset, int size) {
-		return Range.closedOpen(UnsignedLong.fromLongBits(offset),
-			UnsignedLong.fromLongBits(offset + size));
-	}
-
 	protected AddressRange range(AddressSpace space, long offset, int size) {
 		try {
 			return new AddressRangeImpl(space.getAddress(offset), size);
@@ -74,18 +68,15 @@ public class TraceMemoryStatePcodeExecutorStatePiece extends
 
 	@Override
 	protected void setUnique(long offset, int size, TraceMemoryState val) {
-		unique.put(range(offset, size), val);
+		unique.put(ULongSpan.extent(offset, size), val);
 	}
 
 	@Override
 	protected TraceMemoryState getUnique(long offset, int size, Reason reason) {
-		RangeSet<UnsignedLong> remains = TreeRangeSet.create();
-		Range<UnsignedLong> range = range(offset, size);
-		remains.add(range);
-
-		for (Map.Entry<Range<UnsignedLong>, TraceMemoryState> ent : unique.subRangeMap(range)
-				.asMapOfRanges()
-				.entrySet()) {
+		MutableULongSpanSet remains = new DefaultULongSpanSet();
+		ULongSpan span = ULongSpan.extent(offset, size);
+		remains.add(span);
+		for (Entry<ULongSpan, TraceMemoryState> ent : unique.intersectingEntries(span)) {
 			if (ent.getValue() != TraceMemoryState.KNOWN) {
 				return TraceMemoryState.UNKNOWN;
 			}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/data/AbstractPcodeTraceDataAccess.java

@@ -17,10 +17,9 @@ package ghidra.pcode.exec.trace.data;
 
 import java.nio.ByteBuffer;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.Language;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceTimeViewport;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.memory.*;
@@ -131,7 +130,7 @@ public abstract class AbstractPcodeTraceDataAccess implements InternalPcodeTrace
 		return hostSet.isEmpty() ? TraceMemoryState.KNOWN : TraceMemoryState.UNKNOWN;
 	}
 
-	protected AddressSetView doGetKnown(Range<Long> span) {
+	protected AddressSetView doGetKnown(Lifespan span) {
 		TraceMemoryOperations ops = getMemoryOps(false);
 		if (ops == null) {
 			return new AddressSet();
@@ -142,12 +141,12 @@ public abstract class AbstractPcodeTraceDataAccess implements InternalPcodeTrace
 
 	@Override
 	public AddressSetView getKnownNow() {
-		return doGetKnown(Range.singleton(snap));
+		return doGetKnown(Lifespan.at(snap));
 	}
 
 	@Override
 	public AddressSetView getKnownBefore() {
-		return doGetKnown(Range.closed(0L, snap));
+		return doGetKnown(Lifespan.since(snap));
 	}
 
 	@Override

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/data/DefaultPcodeTracePropertyAccess.java

@@ -15,10 +15,8 @@
  */
 package ghidra.pcode.exec.trace.data;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.*;
-import ghidra.trace.database.DBTraceUtils;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.property.*;
 
 /**
@@ -96,7 +94,7 @@ public class DefaultPcodeTracePropertyAccess<T>
 			// TODO: Warn?
 			return;
 		}
-		Range<Long> span = DBTraceUtils.atLeastMaybeScratch(data.getSnap());
+		Lifespan span = Lifespan.nowOnMaybeScratch(data.getSnap());
 		TracePropertyMapOperations<T> ops = getPropertyOperations(true);
 		ops.set(span, toOverlay(ops, hostAddr), value);
 	}
@@ -108,7 +106,7 @@ public class DefaultPcodeTracePropertyAccess<T>
 			// TODO: Warn?
 			return;
 		}
-		Range<Long> span = DBTraceUtils.atLeastMaybeScratch(data.getSnap());
+		Lifespan span = Lifespan.nowOnMaybeScratch(data.getSnap());
 		TracePropertyMapOperations<T> ops = getPropertyOperations(false);
 		if (ops == null) {
 			return;

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/DBTrace.java

@@ -22,7 +22,6 @@ import java.util.function.Consumer;
 import org.apache.commons.collections4.collection.CompositeCollection;
 
 import com.google.common.cache.RemovalNotification;
-import com.google.common.collect.Range;
 
 import db.DBHandle;
 import generic.depends.DependentService;
@@ -55,6 +54,7 @@ import ghidra.trace.database.symbol.*;
 import ghidra.trace.database.target.DBTraceObjectManager;
 import ghidra.trace.database.thread.DBTraceThreadManager;
 import ghidra.trace.database.time.DBTraceTimeManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.memory.TraceMemoryRegion;
 import ghidra.trace.model.program.TraceProgramView;
@@ -794,7 +794,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
 		allViews(v -> v.updateMemoryChangeRegionBlockName(region));
 	}
 
-	public void updateViewsChangeRegionBlockFlags(TraceMemoryRegion region, Range<Long> lifespan) {
+	public void updateViewsChangeRegionBlockFlags(TraceMemoryRegion region, Lifespan lifespan) {
 		allViews(v -> v.updateMemoryChangeRegionBlockFlags(region, lifespan));
 	}
 
@@ -804,7 +804,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
 	}
 
 	public void updateViewsChangeRegionBlockLifespan(TraceMemoryRegion region,
-			Range<Long> oldLifespan, Range<Long> newLifespan) {
+			Lifespan oldLifespan, Lifespan newLifespan) {
 		allViews(v -> v.updateMemoryChangeRegionBlockLifespan(region, oldLifespan, newLifespan));
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/DBTraceCacheForContainingQueries.java

@@ -22,12 +22,10 @@ import org.apache.commons.lang3.tuple.ImmutablePair;
 
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.RemovalNotification;
-import com.google.common.collect.Range;
 
 import ghidra.program.model.address.*;
 import ghidra.trace.database.DBTraceCacheForContainingQueries.GetKey;
-import ghidra.trace.model.ImmutableTraceAddressSnapRange;
-import ghidra.trace.model.TraceAddressSnapRange;
+import ghidra.trace.model.*;
 
 public abstract class DBTraceCacheForContainingQueries<K extends GetKey, V, T> {
 	public static class GetKey {
@@ -141,30 +139,33 @@ public abstract class DBTraceCacheForContainingQueries<K extends GetKey, V, T> {
 		return pointCache.computeIfAbsent(key, this::doGetContaining);
 	}
 
-	public void notifyNewEntry(Range<Long> lifespan, Address address, T item) {
+	public void notifyNewEntry(Lifespan lifespan, Address address, T item) {
 		// TODO: Can this be smarter?
 		pointCache.clear();
-		if (rangeCacheRange != null && rangeCacheRange.getLifespan().isConnected(lifespan) &&
+		if (rangeCacheRange != null &&
+			!rangeCacheRange.getLifespan().intersect(lifespan).isEmpty() &&
 			rangeCacheRange.getRange().contains(address)) {
 			rangeCache.add(new ImmutablePair<>(
 				new ImmutableTraceAddressSnapRange(address, lifespan), item));
 		}
 	}
 
-	public void notifyNewEntry(Range<Long> lifespan, AddressRange range, T item) {
+	public void notifyNewEntry(Lifespan lifespan, AddressRange range, T item) {
 		// TODO: Can this be smarter?
 		pointCache.clear();
-		if (rangeCacheRange != null && rangeCacheRange.getLifespan().isConnected(lifespan) &&
+		if (rangeCacheRange != null &&
+			!rangeCacheRange.getLifespan().intersect(lifespan).isEmpty() &&
 			rangeCacheRange.getRange().intersects(range)) {
 			rangeCache.add(new ImmutablePair<>(
 				new ImmutableTraceAddressSnapRange(range, lifespan), item));
 		}
 	}
 
-	public void notifyNewEntries(Range<Long> lifespan, AddressSetView addresses, T item) {
+	public void notifyNewEntries(Lifespan lifespan, AddressSetView addresses, T item) {
 		// TODO: Can this be smarter?
 		pointCache.clear();
-		if (rangeCacheRange != null && rangeCacheRange.getLifespan().isConnected(lifespan)) {
+		if (rangeCacheRange != null &&
+			!rangeCacheRange.getLifespan().intersect(lifespan).isEmpty()) {
 			for (AddressRange range : addresses) {
 				if (rangeCacheRange.getRange().intersects(range)) {
 					rangeCache.add(new ImmutablePair<>(
@@ -174,12 +175,12 @@ public abstract class DBTraceCacheForContainingQueries<K extends GetKey, V, T> {
 		}
 	}
 
-	public void notifyEntryRemoved(Range<Long> lifespan, AddressRange range, T item) {
+	public void notifyEntryRemoved(Lifespan lifespan, AddressRange range, T item) {
 		// TODO: Can this be smarter?
 		invalidate();
 	}
 
-	public void notifyEntryShapeChanged(Range<Long> lifespan, AddressRange range, T item) {
+	public void notifyEntryShapeChanged(Lifespan lifespan, AddressRange range, T item) {
 		// TODO: Can this be smarter?
 		invalidate();
 	}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/DBTraceCacheForSequenceQueries.java

@@ -18,11 +18,8 @@ package ghidra.trace.database;
 import java.util.*;
 import java.util.Map.Entry;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.*;
-import ghidra.trace.model.ImmutableTraceAddressSnapRange;
-import ghidra.trace.model.TraceAddressSnapRange;
+import ghidra.trace.model.*;
 
 public abstract class DBTraceCacheForSequenceQueries<T> {
 	//protected static long hits = 0;
@@ -172,17 +169,17 @@ public abstract class DBTraceCacheForSequenceQueries<T> {
 		return result;
 	}
 
-	public void notifyNewEntry(Range<Long> lifespan, AddressRangeImpl range, T item) {
+	public void notifyNewEntry(Lifespan lifespan, AddressRangeImpl range, T item) {
 		// TODO: Can this be smarter?
 		invalidate();
 	}
 
-	public void notifyEntryRemoved(Range<Long> lifespan, AddressRange range, T item) {
+	public void notifyEntryRemoved(Lifespan lifespan, AddressRange range, T item) {
 		// TODO: Can this be smarter?
 		invalidate();
 	}
 
-	public void notifyEntryShapeChanged(Range<Long> lifespan, AddressRange range, T item) {
+	public void notifyEntryShapeChanged(Lifespan lifespan, AddressRange range, T item) {
 		// TODO: Can this be smarter?
 		invalidate();
 	}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/DBTraceTimeViewport.java

@@ -22,8 +22,9 @@ import java.util.stream.Collectors;
 import com.google.common.collect.*;
 
 import ghidra.program.model.address.*;
-import ghidra.trace.model.Trace;
-import ghidra.trace.model.TraceTimeViewport;
+import ghidra.trace.model.*;
+import ghidra.trace.model.Lifespan.DefaultLifeSet;
+import ghidra.trace.model.Lifespan.MutableLifeSet;
 import ghidra.trace.model.program.TraceProgramView;
 import ghidra.trace.model.time.TraceSnapshot;
 import ghidra.trace.model.time.TraceTimeManager;
@@ -54,14 +55,14 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 	 * may need the DB's lock, esp., considering user callbacks, then it must <em>first</em> acquire
 	 * the DB lock.
 	 */
-	protected final List<Range<Long>> ordered = new ArrayList<>();
-	protected final RangeSet<Long> spanSet = TreeRangeSet.create();
+	protected final List<Lifespan> ordered = new ArrayList<>();
+	protected final MutableLifeSet spanSet = new DefaultLifeSet();
 	protected final ListenerSet<Runnable> changeListeners = new ListenerSet<>(Runnable.class);
 
 	protected long snap = 0;
 
 	protected DBTraceTimeViewport(Trace trace) {
-		Range<Long> zero = Range.singleton(0L);
+		Lifespan zero = Lifespan.at(0);
 		spanSet.add(zero);
 		ordered.add(zero);
 
@@ -79,12 +80,12 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 	}
 
 	@Override
-	public boolean containsAnyUpper(Range<Long> range) {
+	public boolean containsAnyUpper(Lifespan range) {
 		try (LockHold hold = trace.lockRead()) {
 			synchronized (ordered) {
 				// NB. This should only ever visit the first range intersecting that given
-				for (Range<Long> intersecting : spanSet.subRangeSet(range).asRanges()) {
-					if (range.contains(intersecting.upperEndpoint())) {
+				for (Lifespan intersecting : spanSet.intersecting(range)) {
+					if (range.contains(intersecting.lmax())) {
 						return true;
 					}
 				}
@@ -94,15 +95,15 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 	}
 
 	@Override
-	public <T> boolean isCompletelyVisible(AddressRange range, Range<Long> lifespan, T object,
+	public <T> boolean isCompletelyVisible(AddressRange range, Lifespan lifespan, T object,
 			Occlusion<T> occlusion) {
 		if (range == null) {
 			return false;
 		}
 		try (LockHold hold = trace.lockRead()) {
 			synchronized (ordered) {
-				for (Range<Long> rng : ordered) {
-					if (lifespan.contains(rng.upperEndpoint())) {
+				for (Lifespan rng : ordered) {
+					if (lifespan.contains(rng.lmax())) {
 						return true;
 					}
 					if (occlusion.occluded(object, range, rng)) {
@@ -115,7 +116,7 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 	}
 
 	@Override
-	public <T> AddressSet computeVisibleParts(AddressSetView set, Range<Long> lifespan, T object,
+	public <T> AddressSet computeVisibleParts(AddressSetView set, Lifespan lifespan, T object,
 			Occlusion<T> occlusion) {
 		try (LockHold hold = trace.lockRead()) {
 			if (!containsAnyUpper(lifespan)) {
@@ -123,8 +124,8 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 			}
 			AddressSet remains = new AddressSet(set);
 			synchronized (ordered) {
-				for (Range<Long> rng : ordered) {
-					if (lifespan.contains(rng.upperEndpoint())) {
+				for (Lifespan rng : ordered) {
+					if (lifespan.contains(rng.lmax())) {
 						return remains;
 					}
 					occlusion.remove(object, remains, rng);
@@ -141,21 +142,21 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 	protected boolean isLower(long lower) {
 		try (LockHold hold = trace.lockRead()) {
 			synchronized (ordered) {
-				Range<Long> range = spanSet.rangeContaining(lower);
+				Lifespan range = spanSet.spanContaining(lower);
 				if (range == null) {
 					return false;
 				}
-				return range.lowerEndpoint().longValue() == lower;
+				return range.lmin() == lower;
 			}
 		}
 	}
 
-	protected static boolean addSnapRange(long lower, long upper, RangeSet<Long> spanSet,
-			List<Range<Long>> ordered) {
+	protected static boolean addSnapRange(long lower, long upper, MutableLifeSet spanSet,
+			List<Lifespan> ordered) {
 		if (spanSet.contains(lower)) {
 			return false;
 		}
-		Range<Long> range = Range.closed(lower, upper);
+		Lifespan range = Lifespan.span(lower, upper);
 		spanSet.add(range);
 		ordered.add(range);
 		return true;
@@ -198,7 +199,7 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 	 * @param curSnap the seed snap
 	 */
 	protected static void collectForkRanges(TraceTimeManager timeManager, long curSnap,
-			RangeSet<Long> spanSet, List<Range<Long>> ordered) {
+			MutableLifeSet spanSet, List<Lifespan> ordered) {
 		while (true) {
 			TraceSnapshot fork = locateMostRecentFork(timeManager, curSnap);
 			long prevSnap = fork == null ? Long.MIN_VALUE : fork.getKey();
@@ -213,8 +214,8 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 	}
 
 	protected void refreshSnapRanges() {
-		RangeSet<Long> spanSet = TreeRangeSet.create();
-		List<Range<Long>> ordered = new ArrayList<>();
+		MutableLifeSet spanSet = new DefaultLifeSet();
+		List<Lifespan> ordered = new ArrayList<>();
 		try (LockHold hold = trace.lockRead()) {
 			collectForkRanges(trace.getTimeManager(), snap, spanSet, ordered);
 			synchronized (this.ordered) {
@@ -292,7 +293,7 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 	}
 
 	@Override
-	public List<Range<Long>> getOrderedSpans() {
+	public List<Lifespan> getOrderedSpans() {
 		try (LockHold hold = trace.lockRead()) {
 			synchronized (ordered) {
 				return List.copyOf(ordered);
@@ -300,7 +301,7 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 		}
 	}
 
-	public List<Range<Long>> getOrderedSpans(long snap) {
+	public List<Lifespan> getOrderedSpans(long snap) {
 		try (LockHold hold = trace.lockRead()) {
 			setSnap(snap);
 			return getOrderedSpans();
@@ -313,7 +314,7 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 			synchronized (ordered) {
 				return ordered
 						.stream()
-						.map(Range::upperEndpoint)
+						.map(Lifespan::lmax)
 						.collect(Collectors.toList());
 			}
 		}
@@ -325,7 +326,7 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 			synchronized (ordered) {
 				return Lists.reverse(ordered)
 						.stream()
-						.map(Range::upperEndpoint)
+						.map(Lifespan::lmax)
 						.collect(Collectors.toList());
 			}
 		}
@@ -335,8 +336,8 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 	public <T> T getTop(Function<Long, T> func) {
 		try (LockHold hold = trace.lockRead()) {
 			synchronized (ordered) {
-				for (Range<Long> rng : ordered) {
-					T t = func.apply(rng.upperEndpoint());
+				for (Lifespan rng : ordered) {
+					T t = func.apply(rng.lmax());
 					if (t != null) {
 						return t;
 					}
@@ -356,7 +357,7 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 					return iterFunc.apply(snap);
 				}
 				iters = ordered.stream()
-						.map(rng -> iterFunc.apply(rng.upperEndpoint()))
+						.map(rng -> iterFunc.apply(rng.lmax()))
 						.collect(Collectors.toList());
 			}
 		}
@@ -372,7 +373,7 @@ public class DBTraceTimeViewport implements TraceTimeViewport {
 					return viewFunc.apply(snap);
 				}
 				views = ordered.stream()
-						.map(rng -> viewFunc.apply(rng.upperEndpoint()))
+						.map(rng -> viewFunc.apply(rng.lmax()))
 						.collect(Collectors.toList());
 			}
 		}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/DBTraceUtils.java

@@ -20,20 +20,18 @@ import java.net.MalformedURLException;
 import java.net.URL;
 import java.nio.ByteBuffer;
 import java.util.*;
-import java.util.Map.Entry;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
-import java.util.stream.Collectors;
-
-import com.google.common.collect.*;
 
 import db.*;
+import generic.RangeMapSetter;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.CompilerSpecID;
 import ghidra.program.model.lang.LanguageID;
 import ghidra.program.model.symbol.RefType;
 import ghidra.program.model.symbol.RefTypeFactory;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
+import ghidra.trace.model.Lifespan;
 import ghidra.util.database.DBAnnotatedObject;
 import ghidra.util.database.DBCachedObjectStoreFactory.AbstractDBFieldCodec;
 
@@ -88,7 +86,7 @@ public enum DBTraceUtils {
 		}
 
 		public boolean isScratch() {
-			return DBTraceUtils.isScratch(snap);
+			return Lifespan.isScratch(snap);
 		}
 	}
 
@@ -335,199 +333,6 @@ public enum DBTraceUtils {
 		}
 	}
 
-	/**
-	 * A method outline for setting an entry in a range map where coalescing is desired
-	 *
-	 * @param <E> the type of entries
-	 * @param <D> the type of range bounds
-	 * @param <R> the type of ranges
-	 * @param <V> the type of values
-	 */
-	public static abstract class RangeMapSetter<E, D extends Comparable<D>, R, V> {
-		/**
-		 * Get the range of the given entry
-		 * 
-		 * @param entry the entry
-		 * @return the range
-		 */
-		protected abstract R getRange(E entry);
-
-		/**
-		 * Get the value of the given entry
-		 * 
-		 * @param entry the entry
-		 * @return the value
-		 */
-		protected abstract V getValue(E entry);
-
-		/**
-		 * Remove an entry from the map
-		 * 
-		 * @param entry the entry
-		 */
-		protected abstract void remove(E entry);
-
-		/**
-		 * Get the lower bound of the range
-		 * 
-		 * @param range the range
-		 * @return the lower bound
-		 */
-		protected abstract D getLower(R range);
-
-		/**
-		 * Get the upper bound of the range
-		 * 
-		 * @param range the range
-		 * @return the upper bound
-		 */
-		protected abstract D getUpper(R range);
-
-		/**
-		 * Create a closed range with the given bounds
-		 * 
-		 * @param lower the lower bound
-		 * @param upper the upper bound
-		 * @return the range
-		 */
-		protected abstract R toRange(D lower, D upper);
-
-		/**
-		 * Get the number immediately preceding the given bound
-		 * 
-		 * @param d the bound
-		 * @return the previous bound, or null if it doesn't exist
-		 */
-		protected abstract D getPrevious(D d);
-
-		/**
-		 * Get the number immediately following the given bound
-		 * 
-		 * @param d the bound
-		 * @return the next bound, or null if it doesn't exist
-		 */
-		protected abstract D getNext(D d);
-
-		/**
-		 * Get all entries intersecting the closed range formed by the given bounds
-		 * 
-		 * @param lower the lower bound
-		 * @param upper the upper bound
-		 * @return the intersecting entries
-		 */
-		protected abstract Iterable<E> getIntersecting(D lower, D upper);
-
-		/**
-		 * Place an entry into the map
-		 * 
-		 * @param range the range of the entry
-		 * @param value the value of the entry
-		 * @return the new entry (or an existing entry)
-		 */
-		protected abstract E put(R range, V value);
-
-		/**
-		 * Get the previous bound or this same bound, if the previous doesn't exist
-		 * 
-		 * @param d the bound
-		 * @return the previous or same bound
-		 */
-		protected D getPreviousOrSame(D d) {
-			D prev = getPrevious(d);
-			if (prev == null) {
-				return d;
-			}
-			return prev;
-		}
-
-		/**
-		 * Get the next bound or this same bound, if the next doesn't exist
-		 * 
-		 * @param d the bound
-		 * @return the next or same bound
-		 */
-		protected D getNextOrSame(D d) {
-			D next = getNext(d);
-			if (next == null) {
-				return d;
-			}
-			return next;
-		}
-
-		/**
-		 * Check if the two ranges are connected
-		 * 
-		 * <p>
-		 * The ranges are connected if they intersect, or if their bounds abut.
-		 * 
-		 * @param r1 the first range
-		 * @param r2 the second range
-		 * @return true if connected
-		 */
-		protected boolean connects(R r1, R r2) {
-			return getPreviousOrSame(getLower(r1)).compareTo(getUpper(r2)) <= 0 ||
-				getPreviousOrSame(getLower(r2)).compareTo(getUpper(r1)) <= 0;
-		}
-
-		/**
-		 * Entry point: Set the given range to the given value, coalescing where possible
-		 * 
-		 * @param range the range
-		 * @param value the value
-		 * @return the entry containing the value
-		 */
-		public E set(R range, V value) {
-			return set(getLower(range), getUpper(range), value);
-		}
-
-		/**
-		 * Entry point: Set the given range to the given value, coalescing where possible
-		 * 
-		 * @param lower the lower bound
-		 * @param upper the upper bound
-		 * @param value the value
-		 * @return the entry containing the value
-		 */
-		public E set(D lower, D upper, V value) {
-			// Go one out to find abutting ranges, too.
-			D prev = getPreviousOrSame(lower);
-			D next = getNextOrSame(upper);
-			Map<R, V> toPut = new HashMap<>();
-			for (E entry : getIntersecting(prev, next)) {
-				R r = getRange(entry);
-				boolean precedesMin = getLower(r).compareTo(lower) < 0;
-				boolean succeedsMax = getUpper(r).compareTo(upper) > 0;
-				boolean sameVal = Objects.equals(getValue(entry), value);
-				if (precedesMin && succeedsMax && sameVal) {
-					return entry; // The value in this range is already set as specified
-				}
-				remove(entry);
-				if (precedesMin) {
-					if (sameVal) {
-						lower = getLower(r);
-					}
-					else {
-						toPut.put(toRange(getLower(r), prev), getValue(entry));
-					}
-				}
-				if (succeedsMax) {
-					if (sameVal) {
-						upper = getUpper(r);
-					}
-					else {
-						toPut.put(toRange(next, getUpper(r)), getValue(entry));
-					}
-				}
-			}
-			E result = put(toRange(lower, upper), value);
-			assert toPut.size() <= 2;
-			for (Entry<R, V> ent : toPut.entrySet()) {
-				put(ent.getKey(), ent.getValue());
-			}
-			return result;
-		}
-	}
-
 	/**
 	 * A setter which works on ranges of addresses
 	 *
@@ -536,6 +341,11 @@ public enum DBTraceUtils {
 	 */
 	public static abstract class AddressRangeMapSetter<E, V>
 			extends RangeMapSetter<E, Address, AddressRange, V> {
+		@Override
+		protected int compare(Address d1, Address d2) {
+			return d1.compareTo(d2);
+		}
+
 		@Override
 		protected Address getLower(AddressRange range) {
 			return range.getMinAddress();
@@ -547,7 +357,7 @@ public enum DBTraceUtils {
 		}
 
 		@Override
-		protected AddressRange toRange(Address lower, Address upper) {
+		protected AddressRange toSpan(Address lower, Address upper) {
 			return new AddressRangeImpl(lower, upper);
 		}
 
@@ -569,21 +379,26 @@ public enum DBTraceUtils {
 	 * @param <V> the type of value
 	 */
 	public static abstract class LifespanMapSetter<E, V>
-			extends RangeMapSetter<E, Long, Range<Long>, V> {
+			extends RangeMapSetter<E, Long, Lifespan, V> {
 
 		@Override
-		protected Long getLower(Range<Long> range) {
-			return lowerEndpoint(range);
+		protected int compare(Long d1, Long d2) {
+			return Lifespan.DOMAIN.compare(d1, d2);
 		}
 
 		@Override
-		protected Long getUpper(Range<Long> range) {
-			return upperEndpoint(range);
+		protected Long getLower(Lifespan span) {
+			return span.min();
 		}
 
 		@Override
-		protected Range<Long> toRange(Long lower, Long upper) {
-			return DBTraceUtils.toRange(lower, upper);
+		protected Long getUpper(Lifespan span) {
+			return span.max();
+		}
+
+		@Override
+		protected Lifespan toSpan(Long lower, Long upper) {
+			return Lifespan.span(lower, upper);
 		}
 
 		@Override
@@ -603,175 +418,6 @@ public enum DBTraceUtils {
 		}
 	}
 
-	/**
-	 * Get the lower endpoint as stored in the database
-	 * 
-	 * <p>
-	 * {@link Long#MIN_VALUE} represents no lower bound. Endpoints should always be closed unless
-	 * unbounded. If open, it will be converted to closed (at one greater).
-	 * 
-	 * @param range the range
-	 * @return the endpoint
-	 */
-	public static long lowerEndpoint(Range<Long> range) {
-		if (!range.hasLowerBound()) {
-			return Long.MIN_VALUE;
-		}
-		if (range.lowerBoundType() == BoundType.CLOSED) {
-			return range.lowerEndpoint().longValue();
-		}
-		return range.lowerEndpoint().longValue() + 1;
-	}
-
-	/**
-	 * Get the upper endpoint as stored in the database
-	 * 
-	 * <p>
-	 * {@link Long#MAX_VALUE} represents no upper bound. Endpoints should alwyas be closed unless
-	 * unbounded. If open, it will be converted to closed (at one less).
-	 * 
-	 * @param range the range
-	 * @return the endpoint
-	 */
-	public static long upperEndpoint(Range<Long> range) {
-		if (!range.hasUpperBound()) {
-			return Long.MAX_VALUE;
-		}
-		if (range.upperBoundType() == BoundType.CLOSED) {
-			return range.upperEndpoint().longValue();
-		}
-		return range.upperEndpoint().longValue() - 1;
-	}
-
-	/**
-	 * Convert the given enpoints to a range
-	 * 
-	 * @param lowerEndpoint the lower endpoint, where {@link Long#MIN_VALUE} indicates unbounded
-	 * @param upperEndpoint the upper endpoint, where {@link Long#MAX_VALUE} indicates unbounded
-	 * @return the range
-	 */
-	public static Range<Long> toRange(long lowerEndpoint, long upperEndpoint) {
-		if (lowerEndpoint == Long.MIN_VALUE && upperEndpoint == Long.MAX_VALUE) {
-			return Range.all();
-		}
-		if (lowerEndpoint == Long.MIN_VALUE) {
-			return Range.atMost(upperEndpoint);
-		}
-		if (upperEndpoint == Long.MAX_VALUE) {
-			return Range.atLeast(lowerEndpoint);
-		}
-		return Range.closed(lowerEndpoint, upperEndpoint);
-	}
-
-	/**
-	 * Create the range starting at the given snap, to infinity
-	 * 
-	 * @param snap the starting snap
-	 * @return the range [snap, +inf)
-	 */
-	public static Range<Long> toRange(long snap) {
-		return toRange(snap, Long.MAX_VALUE);
-	}
-
-	/**
-	 * Check if the two ranges intersect
-	 * 
-	 * <p>
-	 * This is a bit obtuse in Guava's API, so here's the convenience method
-	 * 
-	 * @param <T> the type of range endpoints
-	 * @param a the first range
-	 * @param b the second range
-	 * @return true if they intersect
-	 */
-	public static <T extends Comparable<T>> boolean intersect(Range<T> a, Range<T> b) {
-		// Because we're working with a discrete domain, we have to be careful to never use open
-		// lower bounds. Otherwise, the following two inputs would cause a true return value when,
-		// in fact, the intersection contains no elements: (0, 1], [0, 1).
-		return a.isConnected(b) && !a.intersection(b).isEmpty();
-	}
-
-	/**
-	 * Check if a given snapshot key is designated as scratch space
-	 * 
-	 * <p>
-	 * Conventionally, negative snaps are scratch space.
-	 * 
-	 * @param snap the snap
-	 * @return true if scratch space
-	 */
-	public static boolean isScratch(long snap) {
-		return snap < 0;
-	}
-
-	/**
-	 * Form a range starting at the given snap that does not traverse both scratch and non-scratch
-	 * space
-	 * 
-	 * @param start the starting snap
-	 * @return the range [start,0] if start is in scratch space, or [start, +inf) if start is not in
-	 *         scratch space
-	 */
-	public static Range<Long> atLeastMaybeScratch(long start) {
-		if (start < 0) {
-			return Range.closed(start, -1L);
-		}
-		return Range.atLeast(start);
-	}
-
-	/**
-	 * "Compare" two ranges
-	 * 
-	 * <p>
-	 * This is just to impose a sorting order for display.
-	 * 
-	 * @param <C> the type of endpoints
-	 * @param a the first range
-	 * @param b the second range
-	 * @return the result as in {@link Comparable#compareTo(Object)}
-	 */
-	public static <C extends Comparable<C>> int compareRanges(Range<C> a, Range<C> b) {
-		int result;
-		if (!a.hasLowerBound() && b.hasLowerBound()) {
-			return -1;
-		}
-		if (!b.hasLowerBound() && a.hasLowerBound()) {
-			return 1;
-		}
-		if (a.hasLowerBound()) { // Implies b.hasLowerBound()
-			result = a.lowerEndpoint().compareTo(b.lowerEndpoint());
-			if (result != 0) {
-				return result;
-			}
-			if (a.lowerBoundType() == BoundType.CLOSED && b.lowerBoundType() == BoundType.OPEN) {
-				return -1;
-			}
-			if (b.lowerBoundType() == BoundType.CLOSED && a.lowerBoundType() == BoundType.OPEN) {
-				return 1;
-			}
-		}
-
-		if (!a.hasUpperBound() && b.hasUpperBound()) {
-			return 1;
-		}
-		if (!b.hasUpperBound() && a.hasUpperBound()) {
-			return -1;
-		}
-		if (a.hasUpperBound()) { // Implies b.hasUpperBound()
-			result = a.upperEndpoint().compareTo(b.upperEndpoint());
-			if (result != 0) {
-				return result;
-			}
-			if (a.upperBoundType() == BoundType.CLOSED && b.upperBoundType() == BoundType.OPEN) {
-				return 1;
-			}
-			if (b.upperBoundType() == BoundType.CLOSED && a.upperBoundType() == BoundType.OPEN) {
-				return -1;
-			}
-		}
-		return 0;
-	}
-
 	/**
 	 * Derive the table name for a given addres/register space
 	 * 
@@ -806,7 +452,7 @@ public enum DBTraceUtils {
 	 * @param deleter the method used to delete the entry
 	 */
 	public static <DR extends AbstractDBTraceAddressSnapRangePropertyMapData<?>> void makeWay(
-			DR data, Range<Long> span, BiConsumer<? super DR, Range<Long>> lifespanSetter,
+			DR data, Lifespan span, BiConsumer<? super DR, Lifespan> lifespanSetter,
 			Consumer<? super DR> deleter) {
 		// TODO: Not sure I like this rule....
 		if (span.contains(data.getY1())) {
@@ -814,24 +460,7 @@ public enum DBTraceUtils {
 			return;
 		}
 		// NOTE: We know it intersects 
-		lifespanSetter.accept(data, toRange(data.getY1(), lowerEndpoint(span) - 1));
-	}
-
-	/**
-	 * Sutract two ranges, yielding 0, 1, or 2 ranges
-	 * 
-	 * @param a the first range
-	 * @param b the second range
-	 * @return the list of ranges
-	 */
-	public static List<Range<Long>> subtract(Range<Long> a, Range<Long> b) {
-		RangeSet<Long> set = TreeRangeSet.create();
-		set.add(a);
-		set.remove(b);
-		return set.asRanges()
-				.stream()
-				.map(r -> toRange(lowerEndpoint(r), upperEndpoint(r)))
-				.collect(Collectors.toList());
+		lifespanSetter.accept(data, Lifespan.span(data.getY1(), span.lmin() - 1));
 	}
 
 	/**
@@ -847,31 +476,6 @@ public enum DBTraceUtils {
 		return (Iterator<T>) it;
 	}
 
-	/**
-	 * Iterate over all the longs contained in a given range
-	 * 
-	 * @param span the range
-	 * @return the iterator
-	 */
-	public static Iterator<Long> iterateSpan(Range<Long> span) {
-		return new Iterator<>() {
-			final long end = upperEndpoint(span);
-			long val = lowerEndpoint(span);
-
-			@Override
-			public boolean hasNext() {
-				return val <= end;
-			}
-
-			@Override
-			public Long next() {
-				long next = val;
-				val++;
-				return next;
-			}
-		};
-	}
-
 	/**
 	 * Get all the addresses in a factory, starting at the given place
 	 * 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/bookmark/DBTraceBookmark.java

@@ -15,8 +15,6 @@
  */
 package ghidra.trace.database.bookmark;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.program.model.address.Address;
 import ghidra.program.model.address.AddressSpace;
@@ -25,6 +23,7 @@ import ghidra.trace.database.DBTrace;
 import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceBookmarkChangeType;
 import ghidra.trace.model.bookmark.TraceBookmark;
 import ghidra.trace.model.bookmark.TraceBookmarkType;
@@ -89,7 +88,7 @@ public class DBTraceBookmark extends AbstractDBTraceAddressSnapRangePropertyMapD
 	}
 
 	@Override
-	public void setLifespan(Range<Long> lifespan) {
+	public void setLifespan(Lifespan lifespan) {
 		doSetLifespan(lifespan);
 	}
 
@@ -159,7 +158,7 @@ public class DBTraceBookmark extends AbstractDBTraceAddressSnapRangePropertyMapD
 		}
 		TraceBookmark that = (TraceBookmark) o;
 		int result;
-		result = DBTraceUtils.compareRanges(this.getLifespan(), that.getLifespan());
+		result = this.getLifespan().compareTo(that.getLifespan());
 		if (result != 0) {
 			return result;
 		}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/bookmark/DBTraceBookmarkManager.java

@@ -23,8 +23,6 @@ import java.util.concurrent.locks.ReadWriteLock;
 
 import javax.swing.ImageIcon;
 
-import com.google.common.collect.Range;
-
 import db.DBHandle;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.Language;
@@ -32,6 +30,7 @@ import ghidra.trace.database.DBTrace;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
 import ghidra.trace.database.space.*;
 import ghidra.trace.database.thread.DBTraceThreadManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceBookmarkChangeType;
 import ghidra.trace.model.bookmark.TraceBookmarkManager;
 import ghidra.trace.model.bookmark.TraceBookmarkType;
@@ -293,7 +292,7 @@ public class DBTraceBookmarkManager extends AbstractDBTraceSpaceBasedManager<DBT
 	}
 
 	@Override
-	public DBTraceBookmark addBookmark(Range<Long> lifespan, Address address,
+	public DBTraceBookmark addBookmark(Lifespan lifespan, Address address,
 			TraceBookmarkType type, String category, String comment) {
 		return delegateWrite(address.getAddressSpace(),
 			m -> m.addBookmark(lifespan, address, type, category, comment));
@@ -311,14 +310,14 @@ public class DBTraceBookmarkManager extends AbstractDBTraceSpaceBasedManager<DBT
 	}
 
 	@Override
-	public Iterable<? extends DBTraceBookmark> getBookmarksEnclosed(Range<Long> lifespan,
+	public Iterable<? extends DBTraceBookmark> getBookmarksEnclosed(Lifespan lifespan,
 			AddressRange range) {
 		return delegateRead(range.getAddressSpace(), m -> m.getBookmarksEnclosed(lifespan, range),
 			Set.of());
 	}
 
 	@Override
-	public Iterable<? extends DBTraceBookmark> getBookmarksIntersecting(Range<Long> lifespan,
+	public Iterable<? extends DBTraceBookmark> getBookmarksIntersecting(Lifespan lifespan,
 			AddressRange range) {
 		return delegateRead(range.getAddressSpace(),
 			m -> m.getBookmarksIntersecting(lifespan, range), Set.of());

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/bookmark/DBTraceBookmarkSpace.java

@@ -19,13 +19,12 @@ import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.locks.ReadWriteLock;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.*;
 import ghidra.trace.database.DBTrace;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapSpace;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
 import ghidra.trace.database.space.DBTraceSpaceBased;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceBookmarkChangeType;
 import ghidra.trace.model.bookmark.TraceBookmarkSpace;
 import ghidra.trace.model.bookmark.TraceBookmarkType;
@@ -105,7 +104,7 @@ public class DBTraceBookmarkSpace implements TraceBookmarkSpace, DBTraceSpaceBas
 	}
 
 	@Override
-	public DBTraceBookmark addBookmark(Range<Long> lifespan, Address address,
+	public DBTraceBookmark addBookmark(Lifespan lifespan, Address address,
 			TraceBookmarkType type, String category, String comment) {
 		assertInTrace(type);
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
@@ -128,14 +127,14 @@ public class DBTraceBookmarkSpace implements TraceBookmarkSpace, DBTraceSpaceBas
 	}
 
 	@Override
-	public Iterable<DBTraceBookmark> getBookmarksEnclosed(Range<Long> lifespan,
+	public Iterable<DBTraceBookmark> getBookmarksEnclosed(Lifespan lifespan,
 			AddressRange range) {
 		return bookmarkMapSpace.reduce(
 			TraceAddressSnapRangeQuery.enclosed(range, lifespan)).values();
 	}
 
 	@Override
-	public Iterable<DBTraceBookmark> getBookmarksIntersecting(Range<Long> lifespan,
+	public Iterable<DBTraceBookmark> getBookmarksIntersecting(Lifespan lifespan,
 			AddressRange range) {
 		return bookmarkMapSpace.reduce(
 			TraceAddressSnapRangeQuery.intersecting(range, lifespan)).values();

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/breakpoint/DBTraceBreakpoint.java

@@ -18,8 +18,6 @@ package ghidra.trace.database.breakpoint;
 import java.io.IOException;
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.program.model.address.*;
 import ghidra.trace.database.DBTrace;
@@ -27,6 +25,7 @@ import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
 import ghidra.trace.database.thread.DBTraceThreadManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceBreakpointChangeType;
 import ghidra.trace.model.breakpoint.TraceBreakpoint;
 import ghidra.trace.model.breakpoint.TraceBreakpointKind;
@@ -242,8 +241,8 @@ public class DBTraceBreakpoint
 		}
 	}
 
-	protected void setLifespan(Range<Long> newLifespan) throws DuplicateNameException {
-		Range<Long> oldLifespan;
+	protected void setLifespan(Lifespan newLifespan) throws DuplicateNameException {
+		Lifespan oldLifespan;
 		try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
 			space.manager.checkDuplicatePath(this, path, newLifespan);
 			oldLifespan = lifespan;
@@ -254,7 +253,7 @@ public class DBTraceBreakpoint
 	}
 
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		try (LockHold hold = LockHold.lock(space.lock.readLock())) {
 			return lifespan;
 		}
@@ -263,19 +262,19 @@ public class DBTraceBreakpoint
 	@Override
 	public long getPlacedSnap() {
 		try (LockHold hold = LockHold.lock(space.lock.readLock())) {
-			return DBTraceUtils.lowerEndpoint(lifespan);
+			return lifespan.lmin();
 		}
 	}
 
 	@Override
 	public void setClearedSnap(long clearedSnap) throws DuplicateNameException {
-		setLifespan(DBTraceUtils.toRange(getPlacedSnap(), clearedSnap));
+		setLifespan(Lifespan.span(getPlacedSnap(), clearedSnap));
 	}
 
 	@Override
 	public long getClearedSnap() {
 		try (LockHold hold = LockHold.lock(space.lock.readLock())) {
-			return DBTraceUtils.upperEndpoint(lifespan);
+			return lifespan.lmax();
 		}
 	}
 
@@ -289,8 +288,8 @@ public class DBTraceBreakpoint
 	public DBTraceBreakpoint splitAndSet(long snap, boolean en,
 			Collection<TraceBreakpointKind> kinds) {
 		DBTraceBreakpoint that;
-		Range<Long> oldLifespan = null;
-		Range<Long> newLifespan = null;
+		Lifespan oldLifespan = null;
+		Lifespan newLifespan = null;
 		try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
 			if (!lifespan.contains(snap)) {
 				throw new IllegalArgumentException("snap = " + snap);
@@ -304,10 +303,10 @@ public class DBTraceBreakpoint
 			}
 			else {
 				that = doCopy();
-				that.doSetLifespan(DBTraceUtils.toRange(snap, getClearedSnap()));
+				that.doSetLifespan(Lifespan.span(snap, getClearedSnap()));
 				that.doSetFlags(en, kinds);
 				oldLifespan = lifespan;
-				newLifespan = DBTraceUtils.toRange(getPlacedSnap(), snap - 1);
+				newLifespan = Lifespan.span(getPlacedSnap(), snap - 1);
 				this.doSetLifespan(newLifespan);
 			}
 		}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/breakpoint/DBTraceBreakpointManager.java

@@ -21,17 +21,15 @@ import java.util.Collections;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReadWriteLock;
 
-import com.google.common.collect.Range;
-
 import db.DBHandle;
 import ghidra.dbg.target.TargetBreakpointLocation;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.Language;
 import ghidra.trace.database.DBTrace;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager;
 import ghidra.trace.database.space.DBTraceDelegatingManager;
 import ghidra.trace.database.thread.DBTraceThreadManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.breakpoint.*;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.util.LockHold;
@@ -80,13 +78,13 @@ public class DBTraceBreakpointManager
 		return lock.writeLock();
 	}
 
-	protected void checkDuplicatePath(TraceBreakpoint ignore, String path, Range<Long> lifespan)
+	protected void checkDuplicatePath(TraceBreakpoint ignore, String path, Lifespan lifespan)
 			throws DuplicateNameException {
 		for (TraceBreakpoint pc : getBreakpointsByPath(path)) {
 			if (pc == ignore) {
 				continue;
 			}
-			if (!DBTraceUtils.intersect(lifespan, pc.getLifespan())) {
+			if (!lifespan.intersects(pc.getLifespan())) {
 				continue;
 			}
 			throw new DuplicateNameException("A breakpoint having path '" + path +
@@ -95,7 +93,7 @@ public class DBTraceBreakpointManager
 	}
 
 	@Override
-	public TraceBreakpoint addBreakpoint(String path, Range<Long> lifespan, AddressRange range,
+	public TraceBreakpoint addBreakpoint(String path, Lifespan lifespan, AddressRange range,
 			Collection<TraceThread> threads, Collection<TraceBreakpointKind> kinds, boolean enabled,
 			String comment) throws DuplicateNameException {
 		if (trace.getObjectManager().hasSchema()) {
@@ -152,7 +150,7 @@ public class DBTraceBreakpointManager
 	}
 
 	@Override
-	public Collection<? extends TraceBreakpoint> getBreakpointsIntersecting(Range<Long> span,
+	public Collection<? extends TraceBreakpoint> getBreakpointsIntersecting(Lifespan span,
 			AddressRange range) {
 		if (trace.getObjectManager().hasSchema()) {
 			return trace.getObjectManager()

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/breakpoint/DBTraceBreakpointSpace.java

@@ -20,8 +20,6 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.concurrent.locks.ReadWriteLock;
 
-import com.google.common.collect.Range;
-
 import db.DBHandle;
 import ghidra.program.model.address.*;
 import ghidra.trace.database.DBTrace;
@@ -32,6 +30,7 @@ import ghidra.trace.database.space.DBTraceSpaceBased;
 import ghidra.trace.database.thread.DBTraceThread;
 import ghidra.trace.database.thread.DBTraceThreadManager;
 import ghidra.trace.model.ImmutableTraceAddressSnapRange;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceBreakpointChangeType;
 import ghidra.trace.model.breakpoint.TraceBreakpoint;
 import ghidra.trace.model.breakpoint.TraceBreakpointKind;
@@ -89,7 +88,7 @@ public class DBTraceBreakpointSpace implements DBTraceSpaceBased {
 		return 0;
 	}
 
-	protected DBTraceBreakpoint addBreakpoint(String path, Range<Long> lifespan, AddressRange range,
+	protected DBTraceBreakpoint addBreakpoint(String path, Lifespan lifespan, AddressRange range,
 			Collection<TraceThread> threads, Collection<TraceBreakpointKind> kinds, boolean enabled,
 			String comment) {
 		// NOTE: thread here is not about address/register spaces.
@@ -121,7 +120,7 @@ public class DBTraceBreakpointSpace implements DBTraceSpaceBased {
 			breakpointMapSpace.reduce(TraceAddressSnapRangeQuery.at(address, snap)).values());
 	}
 
-	public Collection<? extends DBTraceBreakpoint> getBreakpointsIntersecting(Range<Long> span,
+	public Collection<? extends DBTraceBreakpoint> getBreakpointsIntersecting(Lifespan span,
 			AddressRange range) {
 		return Collections.unmodifiableCollection(breakpointMapSpace.reduce(
 			TraceAddressSnapRangeQuery.intersecting(range, span)).orderedValues());

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/breakpoint/DBTraceObjectBreakpointLocation.java

@@ -19,15 +19,13 @@ import java.util.Collection;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.target.*;
 import ghidra.dbg.target.schema.TargetObjectSchema;
 import ghidra.dbg.util.PathMatcher;
 import ghidra.program.model.address.Address;
 import ghidra.program.model.address.AddressRange;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.target.*;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.Trace.TraceBreakpointChangeType;
 import ghidra.trace.model.breakpoint.*;
@@ -53,7 +51,7 @@ public class DBTraceObjectBreakpointLocation
 		}
 
 		@Override
-		protected TraceChangeType<TraceBreakpoint, Range<Long>> getLifespanChangedType() {
+		protected TraceChangeType<TraceBreakpoint, Lifespan> getLifespanChangedType() {
 			return TraceBreakpointChangeType.LIFESPAN_CHANGED;
 		}
 
@@ -81,7 +79,7 @@ public class DBTraceObjectBreakpointLocation
 
 	// Keep copies here for when the object gets invalidated
 	private AddressRange range;
-	private Range<Long> lifespan;
+	private Lifespan lifespan;
 
 	public DBTraceObjectBreakpointLocation(DBTraceObject object) {
 		this.object = object;
@@ -100,7 +98,7 @@ public class DBTraceObjectBreakpointLocation
 	}
 
 	@Override
-	public void setName(Range<Long> lifespan, String name) {
+	public void setName(Lifespan lifespan, String name) {
 		object.setValue(lifespan, TargetObject.DISPLAY_ATTRIBUTE_NAME, name);
 	}
 
@@ -120,7 +118,7 @@ public class DBTraceObjectBreakpointLocation
 	}
 
 	@Override
-	public void setRange(Range<Long> lifespan, AddressRange range) {
+	public void setRange(Lifespan lifespan, AddressRange range) {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			object.setValue(lifespan, TargetBreakpointLocation.RANGE_ATTRIBUTE_NAME, range);
 			this.range = range;
@@ -157,7 +155,7 @@ public class DBTraceObjectBreakpointLocation
 	}
 
 	@Override
-	public void setLifespan(Range<Long> lifespan) throws DuplicateNameException {
+	public void setLifespan(Lifespan lifespan) throws DuplicateNameException {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			TraceObjectInterfaceUtils.setLifespan(TraceObjectBreakpointLocation.class, object,
 				lifespan);
@@ -166,9 +164,9 @@ public class DBTraceObjectBreakpointLocation
 	}
 
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		try (LockHold hold = object.getTrace().lockRead()) {
-			Range<Long> computed = computeSpan();
+			Lifespan computed = computeSpan();
 			if (computed != null) {
 				lifespan = computed;
 			}
@@ -177,8 +175,8 @@ public class DBTraceObjectBreakpointLocation
 	}
 
 	@Override
-	public Range<Long> computeSpan() {
-		Range<Long> span = TraceObjectBreakpointLocation.super.computeSpan();
+	public Lifespan computeSpan() {
+		Lifespan span = TraceObjectBreakpointLocation.super.computeSpan();
 		if (span != null) {
 			return span;
 		}
@@ -187,19 +185,19 @@ public class DBTraceObjectBreakpointLocation
 
 	@Override
 	public long getPlacedSnap() {
-		return DBTraceUtils.lowerEndpoint(getLifespan());
+		return getLifespan().lmin();
 	}
 
 	@Override
 	public void setClearedSnap(long clearedSnap) throws DuplicateNameException {
 		try (LockHold hold = object.getTrace().lockWrite()) {
-			setLifespan(DBTraceUtils.toRange(getPlacedSnap(), clearedSnap));
+			setLifespan(Lifespan.span(getPlacedSnap(), clearedSnap));
 		}
 	}
 
 	@Override
 	public long getClearedSnap() {
-		return DBTraceUtils.upperEndpoint(getLifespan());
+		return getLifespan().lmax();
 	}
 
 	@Override
@@ -207,7 +205,7 @@ public class DBTraceObjectBreakpointLocation
 			Collection<TraceBreakpointKind> kinds) {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			if (enabled != isEnabled(snap)) {
-				object.setValue(DBTraceUtils.toRange(snap, getClearedSnap()),
+				object.setValue(Lifespan.span(snap, getClearedSnap()),
 					TargetBreakpointSpec.ENABLED_ATTRIBUTE_NAME, enabled);
 			}
 			return this;
@@ -215,7 +213,7 @@ public class DBTraceObjectBreakpointLocation
 	}
 
 	@Override
-	public void setEnabled(Range<Long> lifespan, boolean enabled) {
+	public void setEnabled(Lifespan lifespan, boolean enabled) {
 		object.setValue(lifespan, TargetBreakpointSpec.ENABLED_ATTRIBUTE_NAME, enabled);
 	}
 
@@ -239,7 +237,7 @@ public class DBTraceObjectBreakpointLocation
 	}
 
 	@Override
-	public void setKinds(Range<Long> lifespan, Collection<TraceBreakpointKind> kinds) {
+	public void setKinds(Lifespan lifespan, Collection<TraceBreakpointKind> kinds) {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			TraceObjectBreakpointSpec spec = getSpecification();
 			if (spec.getObject() != this.getObject()) {
@@ -286,7 +284,7 @@ public class DBTraceObjectBreakpointLocation
 	}
 
 	@Override
-	public void setComment(Range<Long> lifespan, String comment) {
+	public void setComment(Lifespan lifespan, String comment) {
 		object.setValue(lifespan, KEY_COMMENT, comment);
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/breakpoint/DBTraceObjectBreakpointSpec.java

@@ -19,15 +19,13 @@ import java.util.Collection;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.target.TargetBreakpointSpec;
 import ghidra.dbg.target.TargetObject;
 import ghidra.program.model.address.Address;
 import ghidra.program.model.address.AddressRange;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.target.DBTraceObject;
 import ghidra.trace.database.target.DBTraceObjectInterface;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.Trace.TraceBreakpointChangeType;
 import ghidra.trace.model.Trace.TraceObjectChangeType;
@@ -98,7 +96,7 @@ public class DBTraceObjectBreakpointSpec
 	}
 
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		return computeSpan();
 	}
 
@@ -110,7 +108,7 @@ public class DBTraceObjectBreakpointSpec
 	@Override
 	public void setClearedSnap(long clearedSnap) throws DuplicateNameException {
 		try (LockHold hold = object.getTrace().lockWrite()) {
-			setLifespan(DBTraceUtils.toRange(getPlacedSnap(), clearedSnap));
+			setLifespan(Lifespan.span(getPlacedSnap(), clearedSnap));
 		}
 	}
 
@@ -120,7 +118,7 @@ public class DBTraceObjectBreakpointSpec
 	}
 
 	@Override
-	public void setLifespan(Range<Long> lifespan) throws DuplicateNameException {
+	public void setLifespan(Lifespan lifespan) throws DuplicateNameException {
 		TraceObjectInterfaceUtils.setLifespan(TraceObjectThread.class, object, lifespan);
 	}
 
@@ -144,7 +142,7 @@ public class DBTraceObjectBreakpointSpec
 	}
 
 	@Override
-	public void setKinds(Range<Long> lifespan, Collection<TraceBreakpointKind> kinds) {
+	public void setKinds(Lifespan lifespan, Collection<TraceBreakpointKind> kinds) {
 		// TODO: More efficient encoding
 		// TODO: Target-Trace mapping is implied by encoded name. Seems bad.
 		try (LockHold hold = object.getTrace().lockWrite()) {

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/context/DBTraceRegisterContextManager.java

@@ -22,8 +22,6 @@ import java.util.Map.Entry;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReadWriteLock;
 
-import com.google.common.collect.Range;
-
 import db.DBHandle;
 import db.DBRecord;
 import ghidra.program.model.address.*;
@@ -37,6 +35,7 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.Abstract
 import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager;
 import ghidra.trace.database.space.DBTraceDelegatingManager;
 import ghidra.trace.database.thread.DBTraceThreadManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.context.TraceRegisterContextManager;
 import ghidra.trace.model.guest.TracePlatform;
@@ -79,7 +78,7 @@ public class DBTraceRegisterContextManager
 			return value;
 		}
 
-		void setLifespan(Range<Long> lifespan) {
+		void setLifespan(Lifespan lifespan) {
 			super.doSetLifespan(lifespan);
 		}
 	}
@@ -155,13 +154,13 @@ public class DBTraceRegisterContextManager
 	}
 
 	@Override
-	public void setValue(Language language, RegisterValue value, Range<Long> lifespan,
+	public void setValue(Language language, RegisterValue value, Lifespan lifespan,
 			AddressRange range) {
 		delegateWriteV(range.getAddressSpace(), m -> m.setValue(language, value, lifespan, range));
 	}
 
 	@Override
-	public void removeValue(Language language, Register register, Range<Long> span,
+	public void removeValue(Language language, Register register, Lifespan span,
 			AddressRange range) {
 		delegateDeleteV(range.getAddressSpace(),
 			m -> m.removeValue(language, register, span, range));
@@ -223,7 +222,7 @@ public class DBTraceRegisterContextManager
 	}
 
 	@Override
-	public void clear(Range<Long> span, AddressRange range) {
+	public void clear(Lifespan span, AddressRange range) {
 		delegateDeleteV(range.getAddressSpace(), m -> m.clear(span, range));
 	}
 }

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/context/DBTraceRegisterContextSpace.java

@@ -23,8 +23,6 @@ import java.util.concurrent.locks.ReadWriteLock;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
 
-import com.google.common.collect.Range;
-
 import db.DBHandle;
 import db.DBRecord;
 import ghidra.program.model.address.*;
@@ -38,8 +36,7 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapSpace;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
 import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager.DBTraceSpaceEntry;
 import ghidra.trace.database.space.DBTraceSpaceBased;
-import ghidra.trace.model.ImmutableTraceAddressSnapRange;
-import ghidra.trace.model.TraceAddressSnapRange;
+import ghidra.trace.model.*;
 import ghidra.trace.model.context.TraceRegisterContextSpace;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.thread.TraceThread;
@@ -211,11 +208,11 @@ public class DBTraceRegisterContextSpace implements TraceRegisterContextSpace, D
 		}
 		if (from.getY1().compareTo(inter.getY1()) < 0) {
 			diff.add(new ImmutableTraceAddressSnapRange(from.getRange(),
-				Range.closed(from.getY1(), inter.getY1() - 1)));
+				Lifespan.span(from.getY1(), inter.getY1() - 1)));
 		}
 		if (from.getY2().compareTo(inter.getY2()) > 0) {
 			diff.add(new ImmutableTraceAddressSnapRange(from.getRange(),
-				Range.closed(inter.getY2() + 1, from.getY2())));
+				Lifespan.span(inter.getY2() + 1, from.getY2())));
 		}
 		return diff;
 	}
@@ -241,7 +238,7 @@ public class DBTraceRegisterContextSpace implements TraceRegisterContextSpace, D
 		}
 	}
 
-	protected void doSetBaseValue(Language language, RegisterValue baseValue, Range<Long> lifespan,
+	protected void doSetBaseValue(Language language, RegisterValue baseValue, Lifespan lifespan,
 			AddressRange range) {
 		TraceAddressSnapRange tasr = new ImmutableTraceAddressSnapRange(range, lifespan);
 		Register base = baseValue.getRegister();
@@ -271,7 +268,7 @@ public class DBTraceRegisterContextSpace implements TraceRegisterContextSpace, D
 	}
 
 	@Override
-	public void setValue(Language language, RegisterValue value, Range<Long> lifespan,
+	public void setValue(Language language, RegisterValue value, Lifespan lifespan,
 			AddressRange range) {
 		assertInSpace(range);
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
@@ -281,7 +278,7 @@ public class DBTraceRegisterContextSpace implements TraceRegisterContextSpace, D
 	}
 
 	@Override
-	public void removeValue(Language language, Register register, Range<Long> span,
+	public void removeValue(Language language, Register register, Lifespan span,
 			AddressRange range) {
 		Register base = register.getBaseRegister();
 		TraceAddressSnapRange tasr = new ImmutableTraceAddressSnapRange(range, span);
@@ -410,7 +407,7 @@ public class DBTraceRegisterContextSpace implements TraceRegisterContextSpace, D
 			return new DBTraceAddressSnapRangePropertyMapAddressSetView<>(within.getAddressSpace(),
 				lock,
 				valueMap.reduce(
-					TraceAddressSnapRangeQuery.intersecting(within, Range.closed(snap, snap))),
+					TraceAddressSnapRangeQuery.intersecting(within, Lifespan.at(snap))),
 				val -> new RegisterValue(base, val).getRegisterValue(register).hasAnyValue());
 		}
 	}
@@ -432,8 +429,7 @@ public class DBTraceRegisterContextSpace implements TraceRegisterContextSpace, D
 				return false;
 			}
 			for (Entry<TraceAddressSnapRange, byte[]> entry : valueMap.reduce(
-				TraceAddressSnapRangeQuery.intersecting(within,
-					Range.closed(snap, snap))).entries()) {
+				TraceAddressSnapRangeQuery.intersecting(within, Lifespan.at(snap))).entries()) {
 				RegisterValue baseValue = new RegisterValue(base, entry.getValue());
 				if (baseValue.getRegisterValue(register).hasAnyValue()) {
 					return true;
@@ -449,7 +445,7 @@ public class DBTraceRegisterContextSpace implements TraceRegisterContextSpace, D
 	}
 
 	@Override
-	public void clear(Range<Long> span, AddressRange range) {
+	public void clear(Lifespan span, AddressRange range) {
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
 			for (DBTraceAddressSnapRangePropertyMapSpace<byte[], DBTraceRegisterContextEntry> valueMap : registerValueMaps
 					.values()) {

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/data/DBTraceDataSettingsAdapter.java

@@ -18,8 +18,6 @@ package ghidra.trace.database.data;
 import java.io.IOException;
 import java.util.concurrent.locks.ReadWriteLock;
 
-import com.google.common.collect.Range;
-
 import db.DBHandle;
 import db.DBRecord;
 import ghidra.program.model.address.AddressSpace;
@@ -30,6 +28,7 @@ import ghidra.trace.database.data.DBTraceDataSettingsAdapter.DBTraceSettingsEntr
 import ghidra.trace.database.map.*;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
 import ghidra.trace.database.thread.DBTraceThreadManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.util.database.*;
 import ghidra.util.database.annot.*;
@@ -150,7 +149,7 @@ public class DBTraceDataSettingsAdapter
 			return longValue;
 		}
 
-		protected void setLifespan(Range<Long> lifespan) {
+		protected void setLifespan(Lifespan lifespan) {
 			super.doSetLifespan(lifespan);
 		}
 	}
@@ -167,7 +166,7 @@ public class DBTraceDataSettingsAdapter
 		}
 
 		@Override
-		public void makeWay(DBTraceSettingsEntry entry, Range<Long> span) {
+		public void makeWay(DBTraceSettingsEntry entry, Lifespan span) {
 			DBTraceUtils.makeWay(entry, span, (e, s) -> e.setLifespan(s), e -> deleteData(e));
 		}
 
@@ -213,7 +212,7 @@ public class DBTraceDataSettingsAdapter
 	}
 
 	@Override
-	public void makeWay(DBTraceSettingsEntry entry, Range<Long> span) {
+	public void makeWay(DBTraceSettingsEntry entry, Lifespan span) {
 		DBTraceUtils.makeWay(entry, span, (e, s) -> e.setLifespan(s), e -> deleteData(e));
 	}
 }

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/data/DBTraceDataSettingsOperations.java

@@ -18,13 +18,11 @@ package ghidra.trace.database.data;
 import java.util.*;
 import java.util.concurrent.locks.ReadWriteLock;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.Address;
 import ghidra.program.model.address.AddressRangeImpl;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.data.DBTraceDataSettingsAdapter.DBTraceSettingsEntry;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.map.TraceAddressSnapRangePropertyMapOperations;
 import ghidra.util.LockHold;
 
@@ -44,14 +42,14 @@ public interface DBTraceDataSettingsOperations
 		throw new IllegalArgumentException("Value is not a known settings type");
 	}
 
-	void makeWay(DBTraceSettingsEntry entry, Range<Long> span);
+	void makeWay(DBTraceSettingsEntry entry, Lifespan span);
 
 	ReadWriteLock getLock();
 
-	default DBTraceSettingsEntry doGetExactEntry(Range<Long> lifespan, Address address,
+	default DBTraceSettingsEntry doGetExactEntry(Lifespan lifespan, Address address,
 			String name) {
-		for (DBTraceSettingsEntry entry : reduce(TraceAddressSnapRangeQuery.at(address,
-			DBTraceUtils.lowerEndpoint(lifespan))).values()) {
+		for (DBTraceSettingsEntry entry : reduce(
+			TraceAddressSnapRangeQuery.at(address, lifespan.lmin())).values()) {
 			if (!lifespan.equals(entry.getLifespan())) {
 				continue;
 			}
@@ -63,7 +61,7 @@ public interface DBTraceDataSettingsOperations
 		return null;
 	}
 
-	default void doMakeWay(Range<Long> span, Address address, String name) {
+	default void doMakeWay(Lifespan span, Address address, String name) {
 		for (DBTraceSettingsEntry entry : reduce(TraceAddressSnapRangeQuery.intersecting(
 			new AddressRangeImpl(address, address), span)).values()) {
 			if (name == null || name.equals(entry.name)) {
@@ -72,7 +70,7 @@ public interface DBTraceDataSettingsOperations
 		}
 	}
 
-	default DBTraceSettingsEntry doExactOrNew(Range<Long> lifespan, Address address, String name) {
+	default DBTraceSettingsEntry doExactOrNew(Lifespan lifespan, Address address, String name) {
 		DBTraceSettingsEntry exact = doGetExactEntry(lifespan, address, name);
 		if (exact != null) {
 			return exact;
@@ -94,7 +92,7 @@ public interface DBTraceDataSettingsOperations
 		return null;
 	}
 
-	default void setLong(Range<Long> lifespan, Address address, String name, long value) {
+	default void setLong(Lifespan lifespan, Address address, String name, long value) {
 		try (LockHold hold = LockHold.lock(getLock().writeLock())) {
 			doExactOrNew(lifespan, address, name).setLong(value);
 		}
@@ -107,7 +105,7 @@ public interface DBTraceDataSettingsOperations
 		}
 	}
 
-	default void setString(Range<Long> lifespan, Address address, String name, String value) {
+	default void setString(Lifespan lifespan, Address address, String name, String value) {
 		try (LockHold hold = LockHold.lock(getLock().writeLock())) {
 			doExactOrNew(lifespan, address, name).setString(value);
 		}
@@ -120,7 +118,7 @@ public interface DBTraceDataSettingsOperations
 		}
 	}
 
-	default void setValue(Range<Long> lifespan, Address address, String name, Object value) {
+	default void setValue(Lifespan lifespan, Address address, String name, Object value) {
 		assertKnownType(value);
 		try (LockHold hold = LockHold.lock(getLock().writeLock())) {
 			doExactOrNew(lifespan, address, name).setValue(value);
@@ -134,13 +132,13 @@ public interface DBTraceDataSettingsOperations
 		}
 	}
 
-	default void clear(Range<Long> span, Address address, String name) {
+	default void clear(Lifespan span, Address address, String name) {
 		try (LockHold hold = LockHold.lock(getLock().writeLock())) {
 			doMakeWay(span, address, name);
 		}
 	}
 
-	default Collection<String> getSettingNames(Range<Long> lifespan, Address address) {
+	default Collection<String> getSettingNames(Lifespan lifespan, Address address) {
 		List<String> result = new ArrayList<>();
 		try (LockHold hold = LockHold.lock(getLock().readLock())) {
 			for (DBTraceSettingsEntry entry : reduce(TraceAddressSnapRangeQuery.intersecting(
@@ -151,7 +149,7 @@ public interface DBTraceDataSettingsOperations
 		}
 	}
 
-	default boolean isEmpty(Range<Long> lifespan, Address address) {
+	default boolean isEmpty(Lifespan lifespan, Address address) {
 		try (LockHold hold = LockHold.lock(getLock().readLock())) {
 			return reduce(TraceAddressSnapRangeQuery.intersecting(
 				new AddressRangeImpl(address, address), lifespan)).isEmpty();

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/guest/DBTraceGuestPlatform.java

@@ -21,8 +21,6 @@ import java.util.Map.Entry;
 
 import org.apache.commons.lang3.tuple.Pair;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.app.util.PseudoInstruction;
 import ghidra.lifecycle.Internal;
@@ -34,6 +32,7 @@ import ghidra.program.model.mem.MemBuffer;
 import ghidra.program.util.DefaultLanguageService;
 import ghidra.trace.database.DBTraceUtils.CompilerSpecIDDBFieldCodec;
 import ghidra.trace.database.DBTraceUtils.LanguageIDDBFieldCodec;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.Trace.TracePlatformChangeType;
 import ghidra.trace.model.guest.TraceGuestPlatform;
@@ -209,7 +208,7 @@ public class DBTraceGuestPlatform extends DBAnnotatedObject
 			throws CancelledException {
 		try (LockHold hold = LockHold.lock(manager.lock.writeLock())) {
 			manager.trace.getCodeManager()
-					.clearPlatform(Range.all(), range.getHostRange(), this, monitor);
+					.clearPlatform(Lifespan.ALL, range.getHostRange(), this, monitor);
 			manager.rangeMappingStore.delete(range);
 			AddressRange hostRange = range.getHostRange();
 			AddressRange guestRange = range.getGuestRange();

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/guest/DBTraceObjectRegisterSupport.java

@@ -20,8 +20,6 @@ import java.nio.ByteBuffer;
 import java.util.List;
 import java.util.stream.Stream;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.target.TargetRegister;
 import ghidra.dbg.target.TargetRegisterContainer;
 import ghidra.dbg.target.schema.TargetObjectSchema;
@@ -33,9 +31,8 @@ import ghidra.program.model.address.Address;
 import ghidra.program.model.address.AddressSpace;
 import ghidra.program.model.lang.Register;
 import ghidra.program.model.lang.RegisterValue;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.*;
-import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.guest.*;
 import ghidra.trace.model.memory.TraceMemoryManager;
 import ghidra.trace.model.memory.TraceMemorySpace;
@@ -236,7 +233,7 @@ public enum DBTraceObjectRegisterSupport {
 		if (register == null || !register.getAddressSpace().isRegisterSpace()) {
 			return;
 		}
-		for (TraceObjectValue registerValue : it(registerObject.getOrderedValues(Range.all(),
+		for (TraceObjectValue registerValue : it(registerObject.getOrderedValues(Lifespan.ALL,
 			TargetRegister.VALUE_ATTRIBUTE_NAME, true))) {
 			transferValueToPlatformRegister(registerValue, platform, mem, register);
 		}
@@ -245,7 +242,7 @@ public enum DBTraceObjectRegisterSupport {
 	protected void onSpaceAddedCheckTransferToPlatformRegisters(TracePlatform platform,
 			TraceObject regContainer, TraceMemorySpace mem) {
 		for (TraceObjectValPath path : it(
-			regContainer.querySuccessorsTargetInterface(Range.all(), TargetRegister.class))) {
+			regContainer.querySuccessorsTargetInterface(Lifespan.ALL, TargetRegister.class))) {
 			TraceObject registerObject =
 				path.getDestination(platform.getTrace().getObjectManager().getRootObject());
 			onSpaceAddedCheckTransferObjectToPlatformRegister(registerObject, platform, mem);
@@ -431,7 +428,7 @@ public enum DBTraceObjectRegisterSupport {
 		TraceMemorySpace mem = registerObject.getTrace()
 				.getMemoryManager()
 				.getMemorySpace(hostAddr.getAddressSpace(), true);
-		for (TraceObjectValue registerValue : it(registerObject.getOrderedValues(Range.all(),
+		for (TraceObjectValue registerValue : it(registerObject.getOrderedValues(Lifespan.ALL,
 			TargetRegister.VALUE_ATTRIBUTE_NAME, true))) {
 			transferValueToPlatformRegister(registerValue, guest, mem, register);
 		}
@@ -440,7 +437,7 @@ public enum DBTraceObjectRegisterSupport {
 	public void onMappingAddedCheckTransferMemoryMapped(TraceObject root,
 			TraceGuestPlatformMappedRange mapped) {
 		for (TraceObjectValPath path : it(
-			root.querySuccessorsTargetInterface(Range.all(), TargetRegister.class))) {
+			root.querySuccessorsTargetInterface(Lifespan.ALL, TargetRegister.class))) {
 			TraceObject registerObject = path.getDestination(root);
 			onMappingAddedCheckTransferRegisterObjectMemoryMapped(registerObject, mapped);
 		}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/AbstractBaseDBTraceCodeUnitsMemoryView.java

@@ -20,14 +20,12 @@ import java.util.Collections;
 import java.util.concurrent.locks.Lock;
 
 import com.google.common.collect.Collections2;
-import com.google.common.collect.Range;
 
 import generic.NestedIterator;
 import ghidra.program.model.address.*;
 import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.space.DBTraceDelegatingManager;
-import ghidra.trace.model.Trace;
-import ghidra.trace.model.TraceAddressSnapRange;
+import ghidra.trace.model.*;
 import ghidra.trace.model.listing.TraceBaseCodeUnitsView;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.util.LockHold;
@@ -427,9 +425,9 @@ public abstract class AbstractBaseDBTraceCodeUnitsMemoryView<T extends DBTraceCo
 	}
 
 	/**
-	 * @see TraceBaseCodeUnitsView#coversRange(Range, AddressRange)
+	 * @see TraceBaseCodeUnitsView#coversRange(Lifespan, AddressRange)
 	 */
-	public boolean coversRange(Range<Long> span, AddressRange range) {
+	public boolean coversRange(Lifespan span, AddressRange range) {
 		return delegateRead(range.getAddressSpace(), m -> m.coversRange(span, range),
 			falseOrTrueUndefined());
 	}
@@ -443,9 +441,9 @@ public abstract class AbstractBaseDBTraceCodeUnitsMemoryView<T extends DBTraceCo
 	}
 
 	/**
-	 * @see TraceBaseCodeUnitsView#intersectsRange(Range, AddressRange)
+	 * @see TraceBaseCodeUnitsView#intersectsRange(Lifespan, AddressRange)
 	 */
-	public boolean intersectsRange(Range<Long> span, AddressRange range) {
+	public boolean intersectsRange(Lifespan span, AddressRange range) {
 		return delegateRead(range.getAddressSpace(), m -> m.intersectsRange(span, range),
 			falseOrTrueUndefined());
 	}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/AbstractBaseDBTraceCodeUnitsView.java

@@ -15,12 +15,9 @@
  */
 package ghidra.trace.database.listing;
 
-import com.google.common.collect.Range;
-
 import generic.NestedIterator;
 import ghidra.program.model.address.*;
-import ghidra.trace.model.Trace;
-import ghidra.trace.model.TraceAddressSnapRange;
+import ghidra.trace.model.*;
 import ghidra.trace.model.listing.TraceBaseCodeUnitsView;
 import ghidra.trace.model.thread.TraceThread;
 
@@ -188,9 +185,9 @@ public abstract class AbstractBaseDBTraceCodeUnitsView<T extends DBTraceCodeUnit
 	public abstract boolean containsAddress(long snap, Address address);
 
 	/**
-	 * @see TraceBaseCodeUnitsView#coversRange(Range, AddressRange)
+	 * @see TraceBaseCodeUnitsView#coversRange(Lifespan, AddressRange)
 	 */
-	public abstract boolean coversRange(Range<Long> span, AddressRange range);
+	public abstract boolean coversRange(Lifespan span, AddressRange range);
 
 	/**
 	 * @see TraceBaseCodeUnitsView#coversRange(TraceAddressSnapRange)
@@ -200,9 +197,9 @@ public abstract class AbstractBaseDBTraceCodeUnitsView<T extends DBTraceCodeUnit
 	}
 
 	/**
-	 * @see TraceBaseCodeUnitsView#intersectsRange(Range, AddressRange)
+	 * @see TraceBaseCodeUnitsView#intersectsRange(Lifespan, AddressRange)
 	 */
-	public abstract boolean intersectsRange(Range<Long> span, AddressRange range);
+	public abstract boolean intersectsRange(Lifespan span, AddressRange range);
 
 	/**
 	 * @see TraceBaseCodeUnitsView#intersectsRange(TraceAddressSnapRange)

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/AbstractBaseDBTraceDefinedUnitsView.java

@@ -18,8 +18,6 @@ package ghidra.trace.database.listing;
 import java.util.*;
 import java.util.Map.Entry;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.*;
 import ghidra.program.model.util.CodeUnitInsertionException;
 import ghidra.trace.database.*;
@@ -28,9 +26,8 @@ import ghidra.trace.database.context.DBTraceRegisterContextSpace;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapAddressSetView;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapSpace;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
-import ghidra.trace.model.ImmutableTraceAddressSnapRange;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.TraceCodeChangeType;
-import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.listing.TraceBaseDefinedUnitsView;
 import ghidra.trace.util.TraceChangeRecord;
 import ghidra.util.LockHold;
@@ -169,7 +166,7 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
 	 * @param set2 a temporary set for working
 	 * @return the result of subtraction, identical to one of the temporary working sets
 	 */
-	protected Set<TraceAddressSnapRange> subtractFrom(Range<Long> span, AddressRange range,
+	protected Set<TraceAddressSnapRange> subtractFrom(Lifespan span, AddressRange range,
 			Set<TraceAddressSnapRange> cur, Set<TraceAddressSnapRange> set1,
 			Set<TraceAddressSnapRange> set2) {
 		Set<TraceAddressSnapRange> prevLeftOver = cur;
@@ -197,11 +194,11 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
 				}
 				if (lo.getY1().compareTo(intersection.getY1()) < 0) {
 					nextLeftOver.add(new ImmutableTraceAddressSnapRange(intersection.getRange(),
-						Range.closed(lo.getY1(), intersection.getY1() - 1)));
+						Lifespan.span(lo.getY1(), intersection.getY1() - 1)));
 				}
 				if (lo.getY2().compareTo(intersection.getY2()) > 0) {
 					nextLeftOver.add(new ImmutableTraceAddressSnapRange(intersection.getRange(),
-						Range.closed(intersection.getY2() + 1, lo.getY2())));
+						Lifespan.span(intersection.getY2() + 1, lo.getY2())));
 				}
 			}
 			if (nextLeftOver.isEmpty()) {
@@ -217,7 +214,7 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
 	}
 
 	@Override
-	public boolean coversRange(Range<Long> span, AddressRange range) {
+	public boolean coversRange(Lifespan span, AddressRange range) {
 		try (LockHold hold = LockHold.lock(space.lock.readLock())) {
 			Set<TraceAddressSnapRange> set1 = new HashSet<>();
 			Set<TraceAddressSnapRange> set2 = new HashSet<>();
@@ -228,7 +225,7 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
 	}
 
 	@Override
-	public boolean intersectsRange(Range<Long> lifespan, AddressRange range) {
+	public boolean intersectsRange(Lifespan lifespan, AddressRange range) {
 		return !mapSpace.reduce(TraceAddressSnapRangeQuery.intersecting(range, lifespan)).isEmpty();
 	}
 
@@ -293,7 +290,7 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
 	 * @param span the lifespan of the box
 	 * @param range the address range of the box
 	 */
-	protected void clearContext(Range<Long> span, AddressRange range) {
+	protected void clearContext(Lifespan span, AddressRange range) {
 		DBTraceRegisterContextSpace ctxSpace =
 			space.trace.getRegisterContextManager().get(space, false);
 		if (ctxSpace == null) {
@@ -303,11 +300,11 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
 	}
 
 	/**
-	 * @see TraceBaseDefinedUnitsView#clear(Range, AddressRange, boolean, TaskMonitor)
+	 * @see TraceBaseDefinedUnitsView#clear(Lifespan, AddressRange, boolean, TaskMonitor)
 	 */
-	public void clear(Range<Long> span, AddressRange range, boolean clearContext,
+	public void clear(Lifespan span, AddressRange range, boolean clearContext,
 			TaskMonitor monitor) throws CancelledException {
-		long startSnap = DBTraceUtils.lowerEndpoint(span);
+		long startSnap = span.lmin();
 		try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
 			cacheForContaining.invalidate();
 			cacheForSequence.invalidate();
@@ -315,10 +312,9 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
 				TraceAddressSnapRangeQuery.intersecting(range, span)).values()) {
 				monitor.checkCanceled();
 				if (unit.getStartSnap() < startSnap) {
-					Range<Long> oldSpan = unit.getLifespan();
+					Lifespan oldSpan = unit.getLifespan();
 					if (clearContext) {
-						clearContext(DBTraceUtils.toRange(DBTraceUtils.lowerEndpoint(span),
-							DBTraceUtils.upperEndpoint(oldSpan)), unit.getRange());
+						clearContext(Lifespan.span(span.lmin(), oldSpan.lmax()), unit.getRange());
 					}
 					unit.setEndSnap(startSnap - 1);
 				}
@@ -351,7 +347,7 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
 	 * @param oldSpan the old snap
 	 * @param unit the unit (having the new span)
 	 */
-	protected void unitSpanChanged(Range<Long> oldSpan, T unit) {
+	protected void unitSpanChanged(Lifespan oldSpan, T unit) {
 		cacheForContaining.notifyEntryShapeChanged(unit.getLifespan(), unit.getRange(), unit);
 		cacheForSequence.notifyEntryShapeChanged(unit.getLifespan(), unit.getRange(), unit);
 		space.undefinedData.invalidateCache();
@@ -371,7 +367,7 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
 	 * @return the selected sub-lifespan
 	 * @throws CodeUnitInsertionException if the start snap is contained in an existing unit
 	 */
-	protected Range<Long> truncateSoonestDefined(Range<Long> span, AddressRange range)
+	protected Lifespan truncateSoonestDefined(Lifespan span, AddressRange range)
 			throws CodeUnitInsertionException {
 		T truncateBy =
 			mapSpace.reduce(TraceAddressSnapRangeQuery.intersecting(range, span)
@@ -381,11 +377,10 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
 		if (truncateBy == null) {
 			return span;
 		}
-		if (truncateBy.getStartSnap() <= DBTraceUtils.lowerEndpoint(span)) {
+		if (truncateBy.getStartSnap() <= span.lmin()) {
 			throw new CodeUnitInsertionException("Code units cannot overlap");
 		}
-		return DBTraceUtils.toRange(DBTraceUtils.lowerEndpoint(span),
-			truncateBy.getStartSnap() - 1);
+		return Lifespan.span(span.lmin(), truncateBy.getStartSnap() - 1);
 	}
 
 	/**

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/AbstractDBTraceCodeUnit.java

@@ -97,7 +97,7 @@ public abstract class AbstractDBTraceCodeUnit<T extends AbstractDBTraceCodeUnit<
 
 	@Override
 	public void setEndSnap(long endSnap) {
-		doSetLifespan(DBTraceUtils.toRange(DBTraceUtils.lowerEndpoint(lifespan), endSnap));
+		doSetLifespan(lifespan.withMax(endSnap));
 	}
 
 	@Override

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/AbstractDBTraceDataComponent.java

@@ -17,14 +17,13 @@ package ghidra.trace.database.listing;
 
 import java.nio.ByteBuffer;
 
-import com.google.common.collect.Range;
-
 import ghidra.docking.settings.Settings;
 import ghidra.program.model.address.Address;
 import ghidra.program.model.data.DataType;
 import ghidra.program.model.lang.Language;
 import ghidra.trace.database.DBTrace;
 import ghidra.trace.database.data.DBTraceDataSettingsAdapter.DBTraceDataSettingsSpace;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.listing.TraceData;
 import ghidra.trace.model.thread.TraceThread;
@@ -114,7 +113,7 @@ public abstract class AbstractDBTraceDataComponent implements DBTraceDefinedData
 	}
 
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		return root.getLifespan();
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/AbstractWithUndefinedDBTraceCodeUnitsMemoryView.java

@@ -20,7 +20,6 @@ import java.util.Iterator;
 import com.google.common.collect.Iterators;
 
 import ghidra.program.model.address.*;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.listing.TraceBaseCodeUnitsView;
 
@@ -85,7 +84,7 @@ public abstract class AbstractWithUndefinedDBTraceCodeUnitsMemoryView<T extends
 	@Override
 	public Iterable<? extends T> emptyOrFullIterableUndefined(TraceAddressSnapRange tasr) {
 		Iterator<Iterator<? extends T>> itIt =
-			Iterators.transform(DBTraceUtils.iterateSpan(tasr.getLifespan()),
+			Iterators.transform(tasr.getLifespan().iterator(),
 				snap -> emptyOrFullIterableUndefined(snap, tasr.getRange(), true).iterator());
 		return () -> Iterators.concat(itIt);
 	}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceCodeManager.java

@@ -25,7 +25,6 @@ import java.util.concurrent.locks.ReadWriteLock;
 
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.RemovalNotification;
-import com.google.common.collect.Range;
 
 import db.DBHandle;
 import db.DBRecord;
@@ -49,8 +48,7 @@ import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager;
 import ghidra.trace.database.space.DBTraceDelegatingManager;
 import ghidra.trace.database.symbol.DBTraceReferenceManager;
 import ghidra.trace.database.thread.DBTraceThreadManager;
-import ghidra.trace.model.AddressSnap;
-import ghidra.trace.model.DefaultAddressSnap;
+import ghidra.trace.model.*;
 import ghidra.trace.model.listing.*;
 import ghidra.trace.model.stack.TraceStackFrame;
 import ghidra.trace.model.thread.TraceThread;
@@ -474,7 +472,7 @@ public class DBTraceCodeManager extends AbstractDBTraceSpaceBasedManager<DBTrace
 	}
 
 	@Internal
-	public void clearPlatform(Range<Long> span, AddressRange range, DBTraceGuestPlatform guest,
+	public void clearPlatform(Lifespan span, AddressRange range, DBTraceGuestPlatform guest,
 			TaskMonitor monitor) throws CancelledException {
 		delegateDeleteV(range.getAddressSpace(),
 			m -> m.clearPlatform(span, range, guest, monitor));
@@ -485,7 +483,7 @@ public class DBTraceCodeManager extends AbstractDBTraceSpaceBasedManager<DBTrace
 			throws CancelledException {
 		// TODO: Use sub-monitors when available
 		for (DBTraceCodeSpace codeSpace : memSpaces.values()) {
-			codeSpace.clearPlatform(Range.all(), codeSpace.all, guest, monitor);
+			codeSpace.clearPlatform(Lifespan.ALL, codeSpace.all, guest, monitor);
 		}
 		for (DBTraceCodeSpace codeSpace : regSpaces.values()) {
 			// TODO: I don't know any way to get guest instructions into register space
@@ -493,7 +491,7 @@ public class DBTraceCodeManager extends AbstractDBTraceSpaceBasedManager<DBTrace
 			// TODO: Test this if I ever get guest data units
 			// TODO: I think explicit per-thread/frame register spaces will be going away, anyway
 			// They'll just be path-named overlays on register space?
-			codeSpace.clearPlatform(Range.all(), codeSpace.all, guest, monitor);
+			codeSpace.clearPlatform(Lifespan.ALL, codeSpace.all, guest, monitor);
 		}
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceCodeSpace.java

@@ -20,8 +20,6 @@ import java.util.HashSet;
 import java.util.Set;
 import java.util.concurrent.locks.ReadWriteLock;
 
-import com.google.common.collect.Range;
-
 import db.DBHandle;
 import ghidra.program.model.address.*;
 import ghidra.program.model.data.DataType;
@@ -30,7 +28,6 @@ import ghidra.program.model.lang.Language;
 import ghidra.program.model.mem.*;
 import ghidra.program.model.util.CodeUnitInsertionException;
 import ghidra.trace.database.DBTrace;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.data.DBTraceDataTypeManager;
 import ghidra.trace.database.guest.DBTraceGuestPlatform;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapSpace;
@@ -38,6 +35,7 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAdd
 import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager.DBTraceSpaceEntry;
 import ghidra.trace.database.space.DBTraceSpaceBased;
 import ghidra.trace.database.symbol.DBTraceReferenceManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.listing.TraceCodeManager;
 import ghidra.trace.model.listing.TraceCodeSpace;
@@ -176,7 +174,7 @@ public class DBTraceCodeSpace implements TraceCodeSpace, DBTraceSpaceBased {
 	 * @param monitor a monitor for progress
 	 * @throws CancelledException if the monitor was cancelled
 	 */
-	void clearPlatform(Range<Long> span, AddressRange range, DBTraceGuestPlatform guest,
+	void clearPlatform(Lifespan span, AddressRange range, DBTraceGuestPlatform guest,
 			TaskMonitor monitor) throws CancelledException {
 		// Note "makeWay" does not apply here.
 		// Units should be enclosed by guest mapping.
@@ -336,7 +334,7 @@ public class DBTraceCodeSpace implements TraceCodeSpace, DBTraceSpaceBased {
 				}
 				if (reApply) {
 					try {
-						definedData.create(DBTraceUtils.toRange(unitStartSnap, unitEndSnap),
+						definedData.create(Lifespan.span(unitStartSnap, unitEndSnap),
 							unit.getAddress(), dataType, unit.getLength());
 					}
 					catch (CodeUnitInsertionException e) {

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceCodeUnitAdapter.java

@@ -15,14 +15,13 @@
  */
 package ghidra.trace.database.listing;
 
-import static ghidra.lifecycle.Unfinished.*;
+import static ghidra.lifecycle.Unfinished.TODO;
 
 import java.nio.ByteBuffer;
 import java.util.*;
 import java.util.Map.Entry;
 
 import com.google.common.collect.Iterators;
-import com.google.common.collect.Range;
 
 import ghidra.program.model.address.Address;
 import ghidra.program.model.address.AddressRangeImpl;
@@ -32,6 +31,7 @@ import ghidra.program.model.mem.*;
 import ghidra.program.model.symbol.*;
 import ghidra.trace.database.DBTrace;
 import ghidra.trace.database.symbol.DBTraceReference;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.listing.TraceCodeUnit;
 import ghidra.trace.model.memory.TraceMemoryRegion;
 import ghidra.trace.model.program.TraceProgramView;
@@ -171,7 +171,7 @@ public interface DBTraceCodeUnitAdapter extends TraceCodeUnit, MemBufferAdapter
 				return false;
 			}
 			// NOTE: Properties all defined at start snap
-			return map.getAddressSetView(Range.singleton(getStartSnap())).contains(getAddress());
+			return map.getAddressSetView(Lifespan.at(getStartSnap())).contains(getAddress());
 		}
 	}
 
@@ -189,13 +189,13 @@ public interface DBTraceCodeUnitAdapter extends TraceCodeUnit, MemBufferAdapter
 			if (space == null) {
 				return false;
 			}
-			return map.getAddressSetView(Range.singleton(getStartSnap())).contains(getAddress());
+			return map.getAddressSetView(Lifespan.at(getStartSnap())).contains(getAddress());
 		}
 	}
 
 	@Override
 	default Iterator<String> propertyNames() {
-		Range<Long> span = Range.singleton(getStartSnap());
+		Lifespan span = Lifespan.at(getStartSnap());
 		return Iterators.transform(Iterators.filter(
 			getTrace().getInternalAddressPropertyManager().getAllProperties().entrySet().iterator(),
 			e -> e.getValue().getAddressSetView(span).contains(getAddress())), Entry::getKey);

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceCodeUnitsView.java

@@ -17,9 +17,8 @@ package ghidra.trace.database.listing;
 
 import java.util.List;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.AddressRange;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.listing.*;
 
 /**
@@ -39,13 +38,13 @@ public class DBTraceCodeUnitsView extends
 	}
 
 	@Override
-	public boolean coversRange(Range<Long> span, AddressRange range) {
+	public boolean coversRange(Lifespan span, AddressRange range) {
 		// Every address has a code unit, defined or undefined
 		return true;
 	}
 
 	@Override
-	public boolean intersectsRange(Range<Long> span, AddressRange range) {
+	public boolean intersectsRange(Lifespan span, AddressRange range) {
 		// Every address has a code unit, defined or undefined
 		return true;
 	}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceCommentAdapter.java

@@ -20,8 +20,6 @@ import java.util.concurrent.locks.ReadWriteLock;
 
 import org.apache.commons.lang3.StringUtils;
 
-import com.google.common.collect.Range;
-
 import db.DBHandle;
 import db.DBRecord;
 import ghidra.program.model.address.*;
@@ -37,9 +35,8 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.Abstract
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
 import ghidra.trace.database.space.DBTraceSpaceKey;
 import ghidra.trace.database.thread.DBTraceThreadManager;
-import ghidra.trace.model.ImmutableTraceAddressSnapRange;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.TraceCommentChangeType;
-import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.util.TraceChangeRecord;
 import ghidra.util.LockHold;
 import ghidra.util.database.*;
@@ -97,7 +94,7 @@ public class DBTraceCommentAdapter
 			update(TYPE_COLUMN, COMMENT_COLUMN);
 		}
 
-		void setLifespan(Range<Long> lifespan) {
+		void setLifespan(Lifespan lifespan) {
 			super.doSetLifespan(lifespan);
 		}
 
@@ -125,7 +122,7 @@ public class DBTraceCommentAdapter
 	 * @param entry the entry to truncate or delete
 	 * @param span the span that must be clear
 	 */
-	protected void makeWay(DBTraceCommentEntry entry, Range<Long> span) {
+	protected void makeWay(DBTraceCommentEntry entry, Lifespan span) {
 		DBTraceUtils.makeWay(entry, span, (e, s) -> e.setLifespan(s), e -> deleteData(e));
 	}
 
@@ -137,7 +134,7 @@ public class DBTraceCommentAdapter
 	 * @param commentType the type of comment as in {@link Listing#setComment(Address, int, String)}
 	 * @param comment the comment
 	 */
-	public void setComment(Range<Long> lifespan, Address address, int commentType, String comment) {
+	public void setComment(Lifespan lifespan, Address address, int commentType, String comment) {
 		if (commentType < MIN_COMMENT_TYPE || commentType > MAX_COMMENT_TYPE) {
 			throw new IllegalArgumentException("commentType");
 		}
@@ -146,8 +143,7 @@ public class DBTraceCommentAdapter
 			for (DBTraceCommentEntry entry : reduce(TraceAddressSnapRangeQuery.intersecting(
 				new AddressRangeImpl(address, address), lifespan)).values()) {
 				if (entry.type == commentType) {
-					if (lifespan.hasLowerBound() &&
-						entry.getLifespan().contains(lifespan.lowerEndpoint())) {
+					if (entry.getLifespan().contains(lifespan.lmin())) {
 						oldValue = entry.comment;
 					}
 					makeWay(entry, lifespan);
@@ -213,7 +209,7 @@ public class DBTraceCommentAdapter
 	 * @param range the address range of the box
 	 * @param commentType a comment type to clear, or {@link CodeUnit#NO_COMMENT} to clear all.
 	 */
-	public void clearComments(Range<Long> span, AddressRange range, int commentType) {
+	public void clearComments(Lifespan span, AddressRange range, int commentType) {
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
 			for (DBTraceCommentEntry entry : reduce(
 				TraceAddressSnapRangeQuery.intersecting(range, span)).values()) {

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceData.java

@@ -17,8 +17,6 @@ package ghidra.trace.database.listing;
 
 import java.io.IOException;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.docking.settings.Settings;
 import ghidra.program.model.address.AddressSpace;
@@ -29,6 +27,7 @@ import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.data.DBTraceDataSettingsOperations;
 import ghidra.trace.database.guest.InternalTracePlatform;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.listing.TraceData;
 import ghidra.util.LockHold;
@@ -177,7 +176,7 @@ public class DBTraceData extends AbstractDBTraceCodeUnit<DBTraceData>
 
 	@Override
 	public void setEndSnap(long endSnap) {
-		Range<Long> oldSpan;
+		Lifespan oldSpan;
 		try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
 			oldSpan = getLifespan();
 			super.setEndSnap(endSnap);

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceDataView.java

@@ -17,9 +17,8 @@ package ghidra.trace.database.listing;
 
 import java.util.List;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.AddressRange;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.listing.*;
 
 /**
@@ -39,12 +38,12 @@ public class DBTraceDataView extends
 	}
 
 	@Override
-	public boolean coversRange(Range<Long> span, AddressRange range) {
+	public boolean coversRange(Lifespan span, AddressRange range) {
 		return !space.instructions.intersectsRange(span, range);
 	}
 
 	@Override
-	public boolean intersectsRange(Range<Long> span, AddressRange range) {
+	public boolean intersectsRange(Lifespan span, AddressRange range) {
 		return !space.instructions.coversRange(span, range);
 	}
 }

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceDefinedDataMemoryView.java

@@ -15,11 +15,11 @@
  */
 package ghidra.trace.database.listing;
 
-import com.google.common.collect.Range;
-
-import ghidra.program.model.address.*;
+import ghidra.program.model.address.Address;
+import ghidra.program.model.address.AddressRange;
 import ghidra.program.model.data.DataType;
 import ghidra.program.model.util.CodeUnitInsertionException;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.listing.TraceCodeManager;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;
@@ -46,20 +46,20 @@ public class DBTraceDefinedDataMemoryView
 	}
 
 	@Override
-	public void clear(Range<Long> span, AddressRange range, boolean clearContext,
+	public void clear(Lifespan span, AddressRange range, boolean clearContext,
 			TaskMonitor monitor) throws CancelledException {
 		delegateDeleteV(range.getAddressSpace(), m -> m.clear(span, range, clearContext, monitor));
 	}
 
 	@Override
-	public DBTraceDataAdapter create(Range<Long> lifespan, Address address, DataType dataType,
+	public DBTraceDataAdapter create(Lifespan lifespan, Address address, DataType dataType,
 			int length) throws CodeUnitInsertionException {
 		return delegateWrite(address.getAddressSpace(),
 			m -> m.create(lifespan, address, dataType, length));
 	}
 
 	@Override
-	public DBTraceDataAdapter create(Range<Long> lifespan, Address address, DataType dataType)
+	public DBTraceDataAdapter create(Lifespan lifespan, Address address, DataType dataType)
 			throws CodeUnitInsertionException {
 		return delegateWrite(address.getAddressSpace(), m -> m.create(lifespan, address, dataType));
 	}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceDefinedDataView.java

@@ -15,18 +15,14 @@
  */
 package ghidra.trace.database.listing;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.*;
 import ghidra.program.model.data.*;
 import ghidra.program.model.mem.MemBuffer;
 import ghidra.program.model.util.CodeUnitInsertionException;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.memory.DBTraceMemorySpace;
-import ghidra.trace.model.ImmutableTraceAddressSnapRange;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.TraceCodeChangeType;
 import ghidra.trace.model.Trace.TraceCompositeDataChangeType;
-import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.listing.TraceCodeSpace;
 import ghidra.trace.util.TraceChangeRecord;
 import ghidra.util.LockHold;
@@ -46,7 +42,7 @@ public class DBTraceDefinedDataView extends AbstractBaseDBTraceDefinedUnitsView<
 	}
 
 	@Override // NOTE: "Adapter" because using DataType.DEFAULT gives UndefinedDBTraceData
-	public DBTraceDataAdapter create(Range<Long> lifespan, Address address, DataType dataType)
+	public DBTraceDataAdapter create(Lifespan lifespan, Address address, DataType dataType)
 			throws CodeUnitInsertionException {
 		return create(lifespan, address, dataType, dataType.getLength());
 	}
@@ -73,14 +69,14 @@ public class DBTraceDefinedDataView extends AbstractBaseDBTraceDefinedUnitsView<
 
 	@Override
 	// TODO: Probably add language parameter....
-	public DBTraceDataAdapter create(Range<Long> lifespan, Address address, DataType origType,
+	public DBTraceDataAdapter create(Lifespan lifespan, Address address, DataType origType,
 			int origLength) throws CodeUnitInsertionException {
 		try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
 			DBTraceMemorySpace memSpace = space.trace.getMemoryManager().get(space, true);
 			// NOTE: User-given length could be ignored....
 			// Check start address first. After I know length, I can check for other existing units
-			long startSnap = DBTraceUtils.lowerEndpoint(lifespan);
-			if (!space.undefinedData.coversRange(Range.closed(startSnap, startSnap),
+			long startSnap = lifespan.lmin();
+			if (!space.undefinedData.coversRange(Lifespan.at(startSnap),
 				new AddressRangeImpl(address, address))) {
 				// TODO: Figure out the conflicting unit?
 				throw new CodeUnitInsertionException("Code units cannot overlap");
@@ -135,8 +131,8 @@ public class DBTraceDefinedDataView extends AbstractBaseDBTraceDefinedUnitsView<
 			Address endAddress = address.addNoWrap(length - 1);
 			AddressRangeImpl createdRange = new AddressRangeImpl(address, endAddress);
 
-			// First, truncate lifespan to the next unit in the range, if end is unbounded
-			if (!lifespan.hasUpperBound()) {
+			// First, truncate lifespan to the next code unit when upper bound is max
+			if (!lifespan.maxIsFinite()) {
 				lifespan = space.instructions.truncateSoonestDefined(lifespan, createdRange);
 				lifespan = space.definedData.truncateSoonestDefined(lifespan, createdRange);
 			}
@@ -145,13 +141,13 @@ public class DBTraceDefinedDataView extends AbstractBaseDBTraceDefinedUnitsView<
 			// Then, check that against existing code units.
 			long endSnap = memSpace.getFirstChange(lifespan, createdRange);
 			if (endSnap == Long.MIN_VALUE) {
-				endSnap = DBTraceUtils.upperEndpoint(lifespan);
+				endSnap = lifespan.lmax();
 			}
 			else {
 				endSnap--;
 			}
 			TraceAddressSnapRange tasr = new ImmutableTraceAddressSnapRange(createdRange,
-				DBTraceUtils.toRange(startSnap, endSnap));
+				Lifespan.span(startSnap, endSnap));
 			if (!space.undefinedData.coversRange(tasr)) {
 				// TODO: Figure out the conflicting unit?
 				throw new CodeUnitInsertionException("Code units cannot overlap");
@@ -198,7 +194,7 @@ public class DBTraceDefinedDataView extends AbstractBaseDBTraceDefinedUnitsView<
 	}
 
 	@Override
-	protected void unitSpanChanged(Range<Long> oldSpan, DBTraceData unit) {
+	protected void unitSpanChanged(Lifespan oldSpan, DBTraceData unit) {
 		super.unitSpanChanged(oldSpan, unit);
 		DataType dataType = unit.getBaseDataType();
 		if (dataType instanceof Composite || dataType instanceof Array ||

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceDefinedUnitsMemoryView.java

@@ -15,9 +15,8 @@
  */
 package ghidra.trace.database.listing;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.AddressRange;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.listing.*;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;
@@ -44,7 +43,7 @@ public class DBTraceDefinedUnitsMemoryView extends
 	}
 
 	@Override
-	public void clear(Range<Long> span, AddressRange range, boolean clearContext,
+	public void clear(Lifespan span, AddressRange range, boolean clearContext,
 			TaskMonitor monitor) throws CancelledException {
 		delegateDeleteV(range.getAddressSpace(), m -> m.clear(span, range, clearContext, monitor));
 	}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceDefinedUnitsView.java

@@ -17,11 +17,8 @@ package ghidra.trace.database.listing;
 
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.AddressRange;
-import ghidra.trace.model.ImmutableTraceAddressSnapRange;
-import ghidra.trace.model.TraceAddressSnapRange;
+import ghidra.trace.model.*;
 import ghidra.trace.model.listing.*;
 import ghidra.util.LockHold;
 import ghidra.util.exception.CancelledException;
@@ -44,7 +41,7 @@ public class DBTraceDefinedUnitsView extends
 	}
 
 	@Override
-	public boolean coversRange(Range<Long> span, AddressRange range) {
+	public boolean coversRange(Lifespan span, AddressRange range) {
 		try (LockHold hold = LockHold.lock(space.lock.readLock())) {
 			Set<TraceAddressSnapRange> set1 = new HashSet<>();
 			Set<TraceAddressSnapRange> set2 = new HashSet<>();
@@ -58,7 +55,7 @@ public class DBTraceDefinedUnitsView extends
 	}
 
 	@Override
-	public boolean intersectsRange(Range<Long> span, AddressRange range) {
+	public boolean intersectsRange(Lifespan span, AddressRange range) {
 		try (LockHold hold = LockHold.lock(space.lock.readLock())) {
 			for (AbstractBaseDBTraceDefinedUnitsView<? extends AbstractDBTraceCodeUnit<?>> p : parts) {
 				if (p.intersectsRange(span, range)) {
@@ -70,7 +67,7 @@ public class DBTraceDefinedUnitsView extends
 	}
 
 	@Override
-	public void clear(Range<Long> span, AddressRange range, boolean clearContext,
+	public void clear(Lifespan span, AddressRange range, boolean clearContext,
 			TaskMonitor monitor) throws CancelledException {
 		for (AbstractBaseDBTraceDefinedUnitsView<? extends AbstractDBTraceCodeUnit<?>> view : parts) {
 			view.clear(span, range, clearContext, monitor);

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceInstruction.java

@@ -19,8 +19,6 @@ import java.io.IOException;
 import java.math.BigInteger;
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.*;
@@ -38,6 +36,7 @@ import ghidra.trace.database.guest.InternalTracePlatform;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
 import ghidra.trace.database.symbol.DBTraceReference;
 import ghidra.trace.database.symbol.DBTraceReferenceSpace;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceInstructionChangeType;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.listing.TraceInstruction;
@@ -224,7 +223,7 @@ public class DBTraceInstruction extends AbstractDBTraceCodeUnit<DBTraceInstructi
 
 	@Override
 	public void setEndSnap(long endSnap) {
-		Range<Long> oldSpan;
+		Lifespan oldSpan;
 		try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
 			oldSpan = getLifespan();
 			super.setEndSnap(endSnap);

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceInstructionsMemoryView.java

@@ -19,11 +19,10 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.Map.Entry;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.*;
 import ghidra.program.model.util.CodeUnitInsertionException;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.listing.*;
 import ghidra.util.LockHold;
@@ -52,13 +51,13 @@ public class DBTraceInstructionsMemoryView
 	}
 
 	@Override
-	public void clear(Range<Long> span, AddressRange range, boolean clearContext,
+	public void clear(Lifespan span, AddressRange range, boolean clearContext,
 			TaskMonitor monitor) throws CancelledException {
 		delegateDeleteV(range.getAddressSpace(), m -> m.clear(span, range, clearContext, monitor));
 	}
 
 	@Override
-	public DBTraceInstruction create(Range<Long> lifespan, Address address,
+	public DBTraceInstruction create(Lifespan lifespan, Address address,
 			TracePlatform platform, InstructionPrototype prototype,
 			ProcessorContextView context) throws CodeUnitInsertionException {
 		return delegateWrite(address.getAddressSpace(),
@@ -66,7 +65,7 @@ public class DBTraceInstructionsMemoryView
 	}
 
 	@Override
-	public AddressSetView addInstructionSet(Range<Long> lifespan, TracePlatform platform,
+	public AddressSetView addInstructionSet(Lifespan lifespan, TracePlatform platform,
 			InstructionSet instructionSet, boolean overwrite) {
 		InstructionSet mappedSet = platform.mapGuestInstructionAddressesToHost(instructionSet);
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceInstructionsView.java

@@ -19,21 +19,17 @@ import java.util.*;
 
 import org.apache.commons.lang3.tuple.Pair;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.*;
 import ghidra.program.model.lang.InstructionError.InstructionErrorType;
 import ghidra.program.model.listing.*;
 import ghidra.program.model.util.CodeUnitInsertionException;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.context.DBTraceRegisterContextManager;
 import ghidra.trace.database.context.DBTraceRegisterContextSpace;
 import ghidra.trace.database.guest.InternalTracePlatform;
 import ghidra.trace.database.memory.DBTraceMemorySpace;
-import ghidra.trace.model.ImmutableTraceAddressSnapRange;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.TraceCodeChangeType;
-import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.listing.*;
 import ghidra.trace.util.OverlappingObjectIterator;
@@ -57,7 +53,7 @@ public class DBTraceInstructionsView extends AbstractBaseDBTraceDefinedUnitsView
 	 */
 	protected class InstructionBlockAdder {
 		private final Set<Address> skipDelaySlots;
-		private final Range<Long> lifespan;
+		private final Lifespan lifespan;
 		private final InternalTracePlatform platform;
 		private final InstructionBlock block;
 		private final Address errorAddress;
@@ -80,7 +76,7 @@ public class DBTraceInstructionsView extends AbstractBaseDBTraceDefinedUnitsView
 		 * @param conflict a description of the error, if any
 		 * @param conflictCodeUnit if a conflict, the code unit that already exists
 		 */
-		private InstructionBlockAdder(Set<Address> skipDelaySlots, Range<Long> lifespan,
+		private InstructionBlockAdder(Set<Address> skipDelaySlots, Lifespan lifespan,
 				InternalTracePlatform platform, InstructionBlock block, Address errorAddress,
 				InstructionError conflict, CodeUnit conflictCodeUnit) {
 			this.skipDelaySlots = skipDelaySlots;
@@ -252,7 +248,7 @@ public class DBTraceInstructionsView extends AbstractBaseDBTraceDefinedUnitsView
 	 *             unit
 	 * @throws AddressOverflowException if the instruction would fall off the address space
 	 */
-	protected DBTraceInstruction doCreate(Range<Long> lifespan, Address address,
+	protected DBTraceInstruction doCreate(Lifespan lifespan, Address address,
 			InternalTracePlatform platform, InstructionPrototype prototype,
 			ProcessorContextView context)
 			throws CodeUnitInsertionException, AddressOverflowException {
@@ -263,8 +259,8 @@ public class DBTraceInstructionsView extends AbstractBaseDBTraceDefinedUnitsView
 		Address endAddress = address.addNoWrap(prototype.getLength() - 1);
 		AddressRangeImpl createdRange = new AddressRangeImpl(address, endAddress);
 
-		// First, truncate lifespan to the next unit in the range, if end is unbounded
-		if (!lifespan.hasUpperBound()) {
+		// First, truncate lifespan to the next code unit when upper bound is max
+		if (!lifespan.maxIsFinite()) {
 			lifespan = space.instructions.truncateSoonestDefined(lifespan, createdRange);
 			lifespan = space.definedData.truncateSoonestDefined(lifespan, createdRange);
 		}
@@ -275,13 +271,13 @@ public class DBTraceInstructionsView extends AbstractBaseDBTraceDefinedUnitsView
 			space.trace.getMemoryManager().getMemorySpace(space.space, true);
 		long endSnap = memSpace.getFirstChange(lifespan, createdRange);
 		if (endSnap == Long.MIN_VALUE) {
-			endSnap = DBTraceUtils.upperEndpoint(lifespan);
+			endSnap = lifespan.lmax();
 		}
 		else {
 			endSnap--;
 		}
-		TraceAddressSnapRange tasr = new ImmutableTraceAddressSnapRange(createdRange,
-			DBTraceUtils.toRange(DBTraceUtils.lowerEndpoint(lifespan), endSnap));
+		TraceAddressSnapRange tasr =
+			new ImmutableTraceAddressSnapRange(createdRange, lifespan.withMax(endSnap));
 
 		if (!space.undefinedData.coversRange(tasr)) {
 			// TODO: Figure out the conflicting unit or snap boundary?
@@ -304,7 +300,7 @@ public class DBTraceInstructionsView extends AbstractBaseDBTraceDefinedUnitsView
 	}
 
 	@Override
-	public DBTraceInstruction create(Range<Long> lifespan, Address address, TracePlatform platform,
+	public DBTraceInstruction create(Lifespan lifespan, Address address, TracePlatform platform,
 			InstructionPrototype prototype, ProcessorContextView context)
 			throws CodeUnitInsertionException {
 		InternalTracePlatform dbPlatform = space.manager.platformManager.assertMine(platform);
@@ -354,7 +350,7 @@ public class DBTraceInstructionsView extends AbstractBaseDBTraceDefinedUnitsView
 	 * @param block the block of instructions to add
 	 * @return the adder, or null
 	 */
-	protected InstructionBlockAdder startAddingBlock(Range<Long> lifespan,
+	protected InstructionBlockAdder startAddingBlock(Lifespan lifespan,
 			Set<Address> skipDelaySlots, InternalTracePlatform platform, InstructionBlock block) {
 		InstructionError conflict = block.getInstructionConflict();
 		if (conflict == null) {
@@ -369,7 +365,7 @@ public class DBTraceInstructionsView extends AbstractBaseDBTraceDefinedUnitsView
 			return new InstructionBlockAdder(skipDelaySlots, lifespan, platform, block,
 				errorAddress, conflict, null);
 		}
-		long startSnap = DBTraceUtils.lowerEndpoint(lifespan);
+		long startSnap = lifespan.lmin();
 		CodeUnit conflictCodeUnit =
 			space.definedUnits.getAt(startSnap, conflict.getConflictAddress());
 		return new InstructionBlockAdder(skipDelaySlots, lifespan, platform, block, errorAddress,
@@ -463,14 +459,14 @@ public class DBTraceInstructionsView extends AbstractBaseDBTraceDefinedUnitsView
 	}
 
 	@Override
-	public AddressSetView addInstructionSet(Range<Long> lifespan, TracePlatform platform,
+	public AddressSetView addInstructionSet(Lifespan lifespan, TracePlatform platform,
 			InstructionSet instructionSet, boolean overwrite) {
 		InternalTracePlatform dbPlatform = space.manager.platformManager.assertMine(platform);
 		// NOTE: Partly derived from CodeManager#addInstructions()
 		// Attempted to factor more fluently
 		AddressSet result = new AddressSet();
 		try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
-			long startSnap = DBTraceUtils.lowerEndpoint(lifespan);
+			long startSnap = lifespan.lmin();
 			Set<Address> skipDelaySlots = new HashSet<>();
 			if (overwrite) {
 				for (AddressRange range : instructionSet.getAddressSet()) {

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceUndefinedDataView.java

@@ -21,10 +21,9 @@ import java.util.Map;
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.RemovalNotification;
 import com.google.common.collect.Iterators;
-import com.google.common.collect.Range;
 
 import ghidra.program.model.address.*;
-import ghidra.trace.database.DBTraceUtils;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.listing.*;
 import ghidra.util.*;
@@ -100,12 +99,12 @@ public class DBTraceUndefinedDataView extends
 	}
 
 	@Override
-	public boolean coversRange(Range<Long> lifespan, AddressRange range) {
+	public boolean coversRange(Lifespan lifespan, AddressRange range) {
 		return !space.definedUnits.intersectsRange(lifespan, range);
 	}
 
 	@Override
-	public boolean intersectsRange(Range<Long> lifespan, AddressRange range) {
+	public boolean intersectsRange(Lifespan lifespan, AddressRange range) {
 		return !space.definedUnits.coversRange(lifespan, range);
 	}
 
@@ -157,7 +156,7 @@ public class DBTraceUndefinedDataView extends
 	@Override
 	public Iterable<? extends UndefinedDBTraceData> getIntersecting(TraceAddressSnapRange tasr) {
 		Iterator<Iterator<? extends UndefinedDBTraceData>> itIt =
-			Iterators.transform(DBTraceUtils.iterateSpan(tasr.getLifespan()),
+			Iterators.transform(tasr.getLifespan().iterator(),
 				snap -> get(snap, tasr.getX1(), tasr.getX2(), true).iterator());
 		return () -> Iterators.concat(itIt);
 	}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/InternalTraceBaseDefinedUnitsView.java

@@ -15,10 +15,9 @@
  */
 package ghidra.trace.database.listing;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.AddressRange;
 import ghidra.program.model.lang.Register;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.listing.TraceBaseDefinedUnitsView;
 import ghidra.trace.model.listing.TraceCodeUnit;
@@ -29,7 +28,7 @@ public interface InternalTraceBaseDefinedUnitsView<T extends TraceCodeUnit>
 		extends TraceBaseDefinedUnitsView<T>, InternalBaseCodeUnitsView<T> {
 
 	@Override
-	default void clear(TracePlatform platform, Range<Long> span, Register register,
+	default void clear(TracePlatform platform, Lifespan span, Register register,
 			TaskMonitor monitor) throws CancelledException {
 		AddressRange range = platform.getConventionalRegisterRange(getSpace(), register);
 		clear(span, range, true, monitor);

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/InternalTraceDefinedDataView.java

@@ -15,12 +15,11 @@
  */
 package ghidra.trace.database.listing;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.AddressRange;
 import ghidra.program.model.data.DataType;
 import ghidra.program.model.lang.Register;
 import ghidra.program.model.util.CodeUnitInsertionException;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.listing.TraceData;
 import ghidra.trace.model.listing.TraceDefinedDataView;
@@ -30,7 +29,7 @@ public interface InternalTraceDefinedDataView
 		extends TraceDefinedDataView, InternalTraceBaseDefinedUnitsView<TraceData> {
 
 	@Override
-	default TraceData create(TracePlatform platform, Range<Long> lifespan, Register register,
+	default TraceData create(TracePlatform platform, Lifespan lifespan, Register register,
 			DataType dataType) throws CodeUnitInsertionException {
 		TraceRegisterUtils.requireByteBound(register);
 		AddressRange range = platform.getConventionalRegisterRange(getSpace(), register);

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/UndefinedDBTraceData.java

@@ -19,20 +19,16 @@ import java.nio.ByteBuffer;
 import java.util.Collections;
 import java.util.List;
 
-import com.google.common.collect.Range;
-
 import ghidra.docking.settings.Settings;
 import ghidra.program.model.address.*;
 import ghidra.program.model.data.DataType;
 import ghidra.program.model.lang.Language;
 import ghidra.program.model.listing.Data;
 import ghidra.trace.database.DBTrace;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.data.DBTraceDataSettingsOperations;
 import ghidra.trace.database.memory.DBTraceMemorySpace;
 import ghidra.trace.database.space.DBTraceSpaceKey;
-import ghidra.trace.model.ImmutableTraceAddressSnapRange;
-import ghidra.trace.model.TraceAddressSnapRange;
+import ghidra.trace.model.*;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.listing.TraceData;
 import ghidra.trace.model.thread.TraceThread;
@@ -48,7 +44,7 @@ import ghidra.trace.util.TraceAddressSpace;
 public class UndefinedDBTraceData implements DBTraceDataAdapter, DBTraceSpaceKey {
 	protected final DBTrace trace;
 	protected final long snap;
-	protected final Range<Long> lifespan;
+	protected final Lifespan lifespan;
 	protected final Address address;
 	protected final TraceThread thread;
 	protected final int frameLevel;
@@ -66,7 +62,7 @@ public class UndefinedDBTraceData implements DBTraceDataAdapter, DBTraceSpaceKey
 			int frameLevel) {
 		this.trace = trace;
 		this.snap = snap;
-		this.lifespan = DBTraceUtils.toRange(snap, snap);
+		this.lifespan = Lifespan.at(snap);
 		this.address = address;
 		this.thread = thread;
 		this.frameLevel = frameLevel;
@@ -115,7 +111,7 @@ public class UndefinedDBTraceData implements DBTraceDataAdapter, DBTraceSpaceKey
 	}
 
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		return lifespan;
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/AbstractDBTraceAddressSnapRangePropertyMapOcclusionIterable.java

@@ -20,13 +20,10 @@ import java.util.NoSuchElementException;
 
 import org.apache.commons.lang3.tuple.ImmutablePair;
 
-import com.google.common.collect.Range;
-
 import generic.util.PeekableIterator;
 import ghidra.program.model.address.Address;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
-import ghidra.trace.model.ImmutableTraceAddressSnapRange;
-import ghidra.trace.model.TraceAddressSnapRange;
+import ghidra.trace.model.*;
 import ghidra.util.database.spatial.rect.Rectangle2DDirection;
 
 public abstract class AbstractDBTraceAddressSnapRangePropertyMapOcclusionIterable<T>
@@ -48,7 +45,7 @@ public abstract class AbstractDBTraceAddressSnapRangePropertyMapOcclusionIterabl
 	 * @param range the given range
 	 * @return the range possibly containing entries which occlude the given range
 	 */
-	protected abstract Range<Long> getOcclusionRange(Range<Long> range);
+	protected abstract Lifespan getOcclusionRange(Lifespan range);
 
 	@Override
 	public PeekableIterator<Entry<TraceAddressSnapRange, T>> iterator() {
@@ -90,7 +87,7 @@ public abstract class AbstractDBTraceAddressSnapRangePropertyMapOcclusionIterabl
 				}
 				// Now, I must check if another entry will occlude it
 				Entry<TraceAddressSnapRange, T> occludes = null;
-				Range<Long> occlusionRange = getOcclusionRange(topAtAddress.getKey().getLifespan());
+				Lifespan occlusionRange = getOcclusionRange(topAtAddress.getKey().getLifespan());
 				if (occlusionRange != null) {
 					occludes = space.reduce(TraceAddressSnapRangeQuery.intersecting(address,
 						within.getX2(), within.getY1(), within.getY2()))

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/AbstractDBTracePropertyMap.java

@@ -22,8 +22,6 @@ import java.util.Collection;
 import java.util.Map.Entry;
 import java.util.concurrent.locks.ReadWriteLock;
 
-import com.google.common.collect.Range;
-
 import db.*;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.Language;
@@ -32,8 +30,7 @@ import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
 import ghidra.trace.database.thread.DBTraceThreadManager;
-import ghidra.trace.model.Trace;
-import ghidra.trace.model.TraceAddressSnapRange;
+import ghidra.trace.model.*;
 import ghidra.trace.model.property.TracePropertyMap;
 import ghidra.trace.model.property.TracePropertyMapSpace;
 import ghidra.trace.model.thread.TraceThread;
@@ -60,25 +57,25 @@ public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAd
 	// TODO: These next several methods are repeated thrice in this file....
 
 	@SuppressWarnings("unchecked")
-	protected void makeWay(Entry<TraceAddressSnapRange, T> entry, Range<Long> span) {
+	protected void makeWay(Entry<TraceAddressSnapRange, T> entry, Lifespan span) {
 		// TODO: Would rather not rely on implementation knowledge here
 		// The shape is the database record in AbstractDBTraceAddressSnapRangePropertyMapData
 		makeWay((DR) entry.getKey(), span);
 	}
 
-	protected void makeWay(DR data, Range<Long> span) {
+	protected void makeWay(DR data, Lifespan span) {
 		DBTraceUtils.makeWay(data, span, (d, s) -> d.doSetLifespan(s), d -> deleteData(d));
 		// TODO: Any events?
 	}
 
 	@Override
-	public void set(Range<Long> lifespan, Address address, T value) {
+	public void set(Lifespan lifespan, Address address, T value) {
 		// NOTE: No null -> clear, so that Void properties make sense
 		put(address, lifespan, value);
 	}
 
 	@Override
-	public void set(Range<Long> lifespan, AddressRange range, T value) {
+	public void set(Lifespan lifespan, AddressRange range, T value) {
 		put(range, lifespan, value);
 	}
 
@@ -93,13 +90,13 @@ public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAd
 	}
 
 	@Override
-	public Collection<Entry<TraceAddressSnapRange, T>> getEntries(Range<Long> lifespan,
+	public Collection<Entry<TraceAddressSnapRange, T>> getEntries(Lifespan lifespan,
 			AddressRange range) {
 		return reduce(TraceAddressSnapRangeQuery.intersecting(range, lifespan)).entries();
 	}
 
 	@Override
-	public boolean clear(Range<Long> span, AddressRange range) {
+	public boolean clear(Lifespan span, AddressRange range) {
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
 			boolean result = false;
 			for (Entry<TraceAddressSnapRange, T> entry : reduce(
@@ -180,24 +177,24 @@ public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAd
 		}
 
 		@SuppressWarnings("unchecked")
-		protected void makeWay(Entry<TraceAddressSnapRange, T> entry, Range<Long> span) {
+		protected void makeWay(Entry<TraceAddressSnapRange, T> entry, Lifespan span) {
 			// TODO: Would rather not rely on implementation knowledge here
 			// The shape is the database record in AbstractDBTraceAddressSnapRangePropertyMapData
 			makeWay((DR) entry.getKey(), span);
 		}
 
-		protected void makeWay(DR data, Range<Long> span) {
+		protected void makeWay(DR data, Lifespan span) {
 			DBTraceUtils.makeWay(data, span, (d, s) -> d.doSetLifespan(s), d -> deleteData(d));
 			// TODO: Any events?
 		}
 
 		@Override
-		public void set(Range<Long> lifespan, Address address, T value) {
+		public void set(Lifespan lifespan, Address address, T value) {
 			put(address, lifespan, value);
 		}
 
 		@Override
-		public void set(Range<Long> lifespan, AddressRange range, T value) {
+		public void set(Lifespan lifespan, AddressRange range, T value) {
 			put(range, lifespan, value);
 		}
 
@@ -212,13 +209,13 @@ public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAd
 		}
 
 		@Override
-		public Collection<Entry<TraceAddressSnapRange, T>> getEntries(Range<Long> lifespan,
+		public Collection<Entry<TraceAddressSnapRange, T>> getEntries(Lifespan lifespan,
 				AddressRange range) {
 			return reduce(TraceAddressSnapRangeQuery.intersecting(range, lifespan)).entries();
 		}
 
 		@Override
-		public boolean clear(Range<Long> span, AddressRange range) {
+		public boolean clear(Lifespan span, AddressRange range) {
 			try (LockHold hold = LockHold.lock(lock.writeLock())) {
 				boolean result = false;
 				for (Entry<TraceAddressSnapRange, T> entry : reduce(

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMap.java

@@ -23,7 +23,6 @@ import java.util.concurrent.locks.ReadWriteLock;
 import java.util.function.Predicate;
 
 import com.google.common.collect.Collections2;
-import com.google.common.collect.Range;
 
 import db.DBHandle;
 import db.DBRecord;
@@ -36,6 +35,7 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAdd
 import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager;
 import ghidra.trace.database.space.DBTraceDelegatingManager;
 import ghidra.trace.database.thread.DBTraceThreadManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.map.TraceAddressSnapRangePropertyMap;
 import ghidra.trace.model.stack.TraceStackFrame;
@@ -233,13 +233,13 @@ public class DBTraceAddressSnapRangePropertyMap<T, DR extends AbstractDBTraceAdd
 	}
 
 	@Override
-	public AddressSetView getAddressSetView(Range<Long> span, Predicate<T> predicate) {
+	public AddressSetView getAddressSetView(Lifespan span, Predicate<T> predicate) {
 		return new UnionAddressSetView(
 			Collections2.transform(memSpacesView, m -> m.getAddressSetView(span, predicate)));
 	}
 
 	@Override
-	public AddressSetView getAddressSetView(Range<Long> span) {
+	public AddressSetView getAddressSetView(Lifespan span) {
 		return getAddressSetView(span, t -> true);
 	}
 }

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapAddressSetView.java

@@ -22,10 +22,10 @@ import java.util.concurrent.locks.ReadWriteLock;
 import java.util.function.Predicate;
 
 import com.google.common.collect.Iterators;
-import com.google.common.collect.Range;
 
 import ghidra.program.model.address.*;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.util.*;
 import ghidra.util.database.spatial.SpatialMap;
@@ -104,7 +104,7 @@ public class DBTraceAddressSnapRangePropertyMapAddressSetView<T> extends Abstrac
 	public Address getMinAddress() {
 		try (LockHold hold = LockHold.lock(lock.readLock())) {
 			for (Entry<TraceAddressSnapRange, T> entry : map
-					.reduce(TraceAddressSnapRangeQuery.intersecting(fullSpace, Range.all())
+					.reduce(TraceAddressSnapRangeQuery.intersecting(fullSpace, Lifespan.ALL)
 							.starting(Rectangle2DDirection.LEFTMOST))
 					.orderedEntries()) {
 				if (predicate.test(entry.getValue())) {
@@ -119,7 +119,7 @@ public class DBTraceAddressSnapRangePropertyMapAddressSetView<T> extends Abstrac
 	public Address getMaxAddress() {
 		try (LockHold hold = LockHold.lock(lock.readLock())) {
 			for (Entry<TraceAddressSnapRange, T> entry : map
-					.reduce(TraceAddressSnapRangeQuery.intersecting(fullSpace, Range.all())
+					.reduce(TraceAddressSnapRangeQuery.intersecting(fullSpace, Lifespan.ALL)
 							.starting(Rectangle2DDirection.RIGHTMOST))
 					.orderedEntries()) {
 				if (predicate.test(entry.getValue())) {
@@ -164,7 +164,7 @@ public class DBTraceAddressSnapRangePropertyMapAddressSetView<T> extends Abstrac
 		AddressRange within = forward ? new AddressRangeImpl(start, fullSpace.getMaxAddress())
 				: new AddressRangeImpl(fullSpace.getMinAddress(), start);
 		Iterator<Entry<TraceAddressSnapRange, T>> mapIt = map
-				.reduce(TraceAddressSnapRangeQuery.intersecting(within, Range.all())
+				.reduce(TraceAddressSnapRangeQuery.intersecting(within, Lifespan.ALL)
 						.starting(forward
 								? Rectangle2DDirection.LEFTMOST
 								: Rectangle2DDirection.RIGHTMOST))

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapOcclusionIntoFutureIterable.java

@@ -15,9 +15,7 @@
  */
 package ghidra.trace.database.map;
 
-import com.google.common.collect.Range;
-
-import ghidra.trace.database.DBTraceUtils;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.util.database.spatial.rect.Rectangle2DDirection;
 
@@ -35,11 +33,11 @@ public class DBTraceAddressSnapRangePropertyMapOcclusionIntoFutureIterable<T>
 	}
 
 	@Override
-	protected Range<Long> getOcclusionRange(Range<Long> range) {
-		long lowerEndpoint = DBTraceUtils.lowerEndpoint(range);
+	protected Lifespan getOcclusionRange(Lifespan range) {
+		long lowerEndpoint = range.lmin();
 		if (lowerEndpoint == Long.MIN_VALUE) {
 			return null;
 		}
-		return DBTraceUtils.toRange(Long.MIN_VALUE, lowerEndpoint - 1);
+		return Lifespan.span(Long.MIN_VALUE, lowerEndpoint - 1);
 	}
 }

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapOcclusionIntoPastIterable.java

@@ -15,9 +15,7 @@
  */
 package ghidra.trace.database.map;
 
-import com.google.common.collect.Range;
-
-import ghidra.trace.database.DBTraceUtils;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.util.database.spatial.rect.Rectangle2DDirection;
 
@@ -35,11 +33,11 @@ public class DBTraceAddressSnapRangePropertyMapOcclusionIntoPastIterable<T>
 	}
 
 	@Override
-	protected Range<Long> getOcclusionRange(Range<Long> range) {
-		long upperEndpoint = DBTraceUtils.upperEndpoint(range);
+	protected Lifespan getOcclusionRange(Lifespan range) {
+		long upperEndpoint = range.lmax();
 		if (upperEndpoint == Long.MAX_VALUE) {
 			return null;
 		}
-		return DBTraceUtils.toRange(upperEndpoint + 1, Long.MAX_VALUE);
+		return Lifespan.span(upperEndpoint + 1, Long.MAX_VALUE);
 	}
 }

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapSpace.java

@@ -21,14 +21,13 @@ import java.util.Map.Entry;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.function.Predicate;
 
-import com.google.common.collect.Range;
-
 import ghidra.lifecycle.Internal;
 import ghidra.program.model.address.*;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMap.DBTraceAddressSnapRangePropertyMapDataFactory;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
 import ghidra.trace.database.space.DBTraceSpaceBased;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.map.TraceAddressSnapRangePropertyMapSpace;
 import ghidra.trace.model.thread.TraceThread;
@@ -193,13 +192,13 @@ public class DBTraceAddressSnapRangePropertyMapSpace<T, DR extends AbstractDBTra
 	}
 
 	@Override
-	public AddressSetView getAddressSetView(Range<Long> span, Predicate<T> predicate) {
+	public AddressSetView getAddressSetView(Lifespan span, Predicate<T> predicate) {
 		return new DBTraceAddressSnapRangePropertyMapAddressSetView<T>(space, lock,
 			reduce(TraceAddressSnapRangeQuery.intersecting(fullSpace, span)), predicate);
 	}
 
 	@Override
-	public AddressSetView getAddressSetView(Range<Long> span) {
+	public AddressSetView getAddressSetView(Lifespan span) {
 		return getAddressSetView(span, t -> true);
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapTree.java

@@ -18,11 +18,8 @@ package ghidra.trace.database.map;
 import java.io.IOException;
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.program.model.address.*;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMap.DBTraceAddressSnapRangePropertyMapDataFactory;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.*;
 import ghidra.trace.model.*;
@@ -95,7 +92,7 @@ public class DBTraceAddressSnapRangePropertyMapTree<T, DR extends AbstractDBTrac
 		protected final DBTraceAddressSnapRangePropertyMapTree<?, ?> tree;
 
 		private AddressRange range;
-		private Range<Long> lifespan;
+		private Lifespan lifespan;
 
 		public DBTraceAddressSnapRangePropertyMapNode(
 				DBTraceAddressSnapRangePropertyMapTree<?, ?> tree, DBCachedObjectStore<?> store,
@@ -110,13 +107,13 @@ public class DBTraceAddressSnapRangePropertyMapTree<T, DR extends AbstractDBTrac
 			if (created) {
 				Address min = tree.mapSpace.getAddressSpace().getMinAddress();
 				range = new AddressRangeImpl(min, min);
-				lifespan = Range.closed(0L, 0L);
+				lifespan = Lifespan.at(0);
 				return;
 			}
 			Address minAddr = tree.mapSpace.toAddress(minOffset);
 			Address maxAddr = tree.mapSpace.toAddress(maxOffset);
 			range = new AddressRangeImpl(minAddr, maxAddr);
-			lifespan = DBTraceUtils.toRange(minSnap, maxSnap);
+			lifespan = Lifespan.span(minSnap, maxSnap);
 		}
 
 		@Override
@@ -199,7 +196,7 @@ public class DBTraceAddressSnapRangePropertyMapTree<T, DR extends AbstractDBTrac
 		}
 
 		@Override
-		public Range<Long> getLifespan() {
+		public Lifespan getLifespan() {
 			return lifespan;
 		}
 	}
@@ -238,7 +235,7 @@ public class DBTraceAddressSnapRangePropertyMapTree<T, DR extends AbstractDBTrac
 		protected final DBTraceAddressSnapRangePropertyMapTree<T, ? extends AbstractDBTraceAddressSnapRangePropertyMapData<T>> tree;
 
 		protected AddressRange range;
-		protected Range<Long> lifespan;
+		protected Lifespan lifespan;
 
 		public AbstractDBTraceAddressSnapRangePropertyMapData(
 				DBTraceAddressSnapRangePropertyMapTree<T, ?> tree, DBCachedObjectStore<?> store,
@@ -256,7 +253,7 @@ public class DBTraceAddressSnapRangePropertyMapTree<T, DR extends AbstractDBTrac
 			Address minAddr = tree.mapSpace.toAddress(minOffset);
 			Address maxAddr = tree.mapSpace.toAddress(maxOffset);
 			range = new AddressRangeImpl(minAddr, maxAddr);
-			lifespan = DBTraceUtils.toRange(minSnap, maxSnap);
+			lifespan = Lifespan.span(minSnap, maxSnap);
 		}
 
 		@Override
@@ -316,19 +313,19 @@ public class DBTraceAddressSnapRangePropertyMapTree<T, DR extends AbstractDBTrac
 		}
 
 		@SuppressWarnings({ "unchecked", "hiding" })
-		protected void doSetLifespan(Range<Long> lifespan) {
+		protected void doSetLifespan(Lifespan lifespan) {
 			@SuppressWarnings("rawtypes")
 			DBTraceAddressSnapRangePropertyMapTree tree = this.tree;
 			tree.doUnparentEntry(this);
-			minSnap = DBTraceUtils.lowerEndpoint(lifespan);
-			maxSnap = DBTraceUtils.upperEndpoint(lifespan);
+			minSnap = lifespan.lmin();
+			maxSnap = lifespan.lmax();
 			update(MIN_SNAP_COLUMN, MAX_SNAP_COLUMN);
 			this.lifespan = lifespan;
 			tree.doInsertDataEntry(this);
 		}
 
 		@Override
-		public Range<Long> getLifespan() {
+		public Lifespan getLifespan() {
 			return lifespan;
 		}
 
@@ -418,7 +415,7 @@ public class DBTraceAddressSnapRangePropertyMapTree<T, DR extends AbstractDBTrac
 		}
 
 		public static TraceAddressSnapRangeQuery enclosed(AddressRange range,
-				Range<Long> lifespan) {
+				Lifespan lifespan) {
 			return enclosed(new ImmutableTraceAddressSnapRange(range, lifespan), null,
 				TraceAddressSnapRangeQuery::new);
 		}
@@ -434,7 +431,7 @@ public class DBTraceAddressSnapRangePropertyMapTree<T, DR extends AbstractDBTrac
 		}
 
 		public static TraceAddressSnapRangeQuery intersecting(AddressRange range,
-				Range<Long> lifespan) {
+				Lifespan lifespan) {
 			return intersecting(new ImmutableTraceAddressSnapRange(range, lifespan), null,
 				TraceAddressSnapRangeQuery::new);
 		}
@@ -451,7 +448,7 @@ public class DBTraceAddressSnapRangePropertyMapTree<T, DR extends AbstractDBTrac
 				space.getMaxAddress(), snap, snap), null, TraceAddressSnapRangeQuery::new);
 		}
 
-		public static TraceAddressSnapRangeQuery intersecting(Range<Long> lifespan,
+		public static TraceAddressSnapRangeQuery intersecting(Lifespan lifespan,
 				AddressSpace space) {
 			return intersecting(new ImmutableTraceAddressSnapRange(space.getMinAddress(),
 				space.getMaxAddress(), lifespan), null, TraceAddressSnapRangeQuery::new);
@@ -474,8 +471,8 @@ public class DBTraceAddressSnapRangePropertyMapTree<T, DR extends AbstractDBTrac
 			}
 			AddressRangeImpl rng =
 				new AddressRangeImpl(space.getMinAddress(), space.getMaxAddress());
-			return intersecting(rng, Range.closed(from + 1, to))
-					.and(intersecting(rng, Range.atLeast(to)));
+			return intersecting(rng, Lifespan.span(from + 1, to))
+					.and(intersecting(rng, Lifespan.nowOn(to)));
 		}
 
 		/**
@@ -495,8 +492,8 @@ public class DBTraceAddressSnapRangePropertyMapTree<T, DR extends AbstractDBTrac
 			}
 			AddressRangeImpl rng =
 				new AddressRangeImpl(space.getMinAddress(), space.getMaxAddress());
-			return intersecting(rng, Range.closed(from, to - 1))
-					.and(enclosed(rng, Range.atMost(from)));
+			return intersecting(rng, Lifespan.span(from, to - 1))
+					.and(enclosed(rng, Lifespan.toNow(from)));
 		}
 
 		public static TraceAddressSnapRangeQuery mostRecent(Address address, long snap) {
@@ -505,7 +502,7 @@ public class DBTraceAddressSnapRangePropertyMapTree<T, DR extends AbstractDBTrac
 				Rectangle2DDirection.TOPMOST, TraceAddressSnapRangeQuery::new);
 		}
 
-		public static TraceAddressSnapRangeQuery mostRecent(Address address, Range<Long> span) {
+		public static TraceAddressSnapRangeQuery mostRecent(Address address, Lifespan span) {
 			return intersecting(
 				new ImmutableTraceAddressSnapRange(address, span),
 				Rectangle2DDirection.TOPMOST, TraceAddressSnapRangeQuery::new);

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceMemoryBlockEntry.java

@@ -23,6 +23,7 @@ import ghidra.program.model.address.AddressSpace;
 import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.DBTraceUtils.OffsetSnap;
 import ghidra.trace.database.DBTraceUtils.OffsetThenSnapDBFieldCodec;
+import ghidra.trace.model.Lifespan;
 import ghidra.util.database.*;
 import ghidra.util.database.annot.*;
 
@@ -77,7 +78,7 @@ class DBTraceMemoryBlockEntry extends DBAnnotatedObject {
 	}
 
 	public boolean isScratch() {
-		return DBTraceUtils.isScratch(location.snap);
+		return Lifespan.isScratch(location.snap);
 	}
 
 	private int getBlockNumber() {

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceMemoryManager.java

@@ -25,7 +25,6 @@ import java.util.concurrent.locks.ReadWriteLock;
 import java.util.function.Predicate;
 
 import com.google.common.collect.Collections2;
-import com.google.common.collect.Range;
 
 import db.DBHandle;
 import ghidra.dbg.target.TargetMemoryRegion;
@@ -38,6 +37,7 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAdd
 import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager;
 import ghidra.trace.database.space.DBTraceDelegatingManager;
 import ghidra.trace.database.thread.DBTraceThreadManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.memory.*;
 import ghidra.trace.model.stack.TraceStackFrame;
@@ -138,7 +138,7 @@ public class DBTraceMemoryManager extends AbstractDBTraceSpaceBasedManager<DBTra
 	}
 
 	@Override
-	public TraceMemoryRegion addRegion(String path, Range<Long> lifespan,
+	public TraceMemoryRegion addRegion(String path, Lifespan lifespan,
 			AddressRange range, Collection<TraceMemoryFlag> flags)
 			throws TraceOverlappedRegionException, DuplicateNameException {
 		if (trace.getObjectManager().hasSchema()) {
@@ -185,7 +185,7 @@ public class DBTraceMemoryManager extends AbstractDBTraceSpaceBasedManager<DBTra
 	}
 
 	@Override
-	public Collection<? extends TraceMemoryRegion> getRegionsIntersecting(Range<Long> lifespan,
+	public Collection<? extends TraceMemoryRegion> getRegionsIntersecting(Lifespan lifespan,
 			AddressRange range) {
 		if (trace.getObjectManager().hasSchema()) {
 			return trace.getObjectManager()
@@ -204,7 +204,7 @@ public class DBTraceMemoryManager extends AbstractDBTraceSpaceBasedManager<DBTra
 		return delegateCollection(memSpaces.values(), m -> m.getRegionsAtSnap(snap));
 	}
 
-	public Collection<TraceMemoryRegion> getRegionsWithPathInLifespan(Range<Long> lifespan,
+	public Collection<TraceMemoryRegion> getRegionsWithPathInLifespan(Lifespan lifespan,
 			String regionPath) {
 		// Not efficient, but I don't anticipate many regions
 		Collection<TraceMemoryRegion> result = new HashSet<>();
@@ -303,7 +303,7 @@ public class DBTraceMemoryManager extends AbstractDBTraceSpaceBasedManager<DBTra
 	}
 
 	@Override
-	public AddressSetView getAddressesWithState(Range<Long> lifespan,
+	public AddressSetView getAddressesWithState(Lifespan lifespan,
 			Predicate<TraceMemoryState> predicate) {
 		return new UnionAddressSetView(Collections2.transform(getActiveMemorySpaces(),
 			m -> m.getAddressesWithState(lifespan, predicate)));
@@ -416,7 +416,7 @@ public class DBTraceMemoryManager extends AbstractDBTraceSpaceBasedManager<DBTra
 		if (from == to) {
 			return Collections.emptySet();
 		}
-		Range<Long> between = from < to ? Range.closed(from + 1, to) : Range.closed(to + 1, from);
+		Lifespan between = from < to ? Lifespan.span(from + 1, to) : Lifespan.span(to + 1, from);
 		Collection<Entry<TraceAddressSnapRange, TraceMemoryState>> result = new ArrayList<>();
 		for (DBTraceMemorySpace space : memSpaces.values()) {
 			AddressRange rng =

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceMemoryRegion.java

@@ -18,14 +18,13 @@ package ghidra.trace.database.memory;
 import java.io.IOException;
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.program.model.address.*;
 import ghidra.trace.database.DBTrace;
 import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceMemoryRegionChangeType;
 import ghidra.trace.model.memory.*;
 import ghidra.trace.util.TraceChangeRecord;
@@ -107,7 +106,7 @@ public class DBTraceMemoryRegion
 	}
 
 	@SuppressWarnings("hiding")
-	protected void checkOverlapConflicts(Range<Long> lifespan, AddressRange range)
+	protected void checkOverlapConflicts(Lifespan lifespan, AddressRange range)
 			throws TraceOverlappedRegionException {
 		Collection<? extends DBTraceMemoryRegion> overlapConflicts =
 			space.getRegionsIntersecting(lifespan, range);
@@ -120,7 +119,7 @@ public class DBTraceMemoryRegion
 	}
 
 	@SuppressWarnings("hiding")
-	protected void checkPathConflicts(Range<Long> lifespan, String path)
+	protected void checkPathConflicts(Lifespan lifespan, String path)
 			throws DuplicateNameException {
 		Collection<TraceMemoryRegion> pathConflicts =
 			space.manager.getRegionsWithPathInLifespan(lifespan, path);
@@ -164,12 +163,12 @@ public class DBTraceMemoryRegion
 	}
 
 	@Override
-	public void setLifespan(Range<Long> newLifespan)
+	public void setLifespan(Lifespan newLifespan)
 			throws TraceOverlappedRegionException, DuplicateNameException {
 		try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
 			checkOverlapConflicts(newLifespan, range);
 			checkPathConflicts(newLifespan, path);
-			Range<Long> oldLifespan = getLifespan();
+			Lifespan oldLifespan = getLifespan();
 			doSetLifespan(newLifespan);
 			space.trace.updateViewsChangeRegionBlockLifespan(this, oldLifespan, newLifespan);
 			space.trace.setChanged(
@@ -181,26 +180,26 @@ public class DBTraceMemoryRegion
 	@Override
 	public void setCreationSnap(long creationSnap)
 			throws DuplicateNameException, TraceOverlappedRegionException {
-		setLifespan(DBTraceUtils.toRange(creationSnap, getDestructionSnap()));
+		setLifespan(Lifespan.span(creationSnap, getDestructionSnap()));
 	}
 
 	@Override
 	public long getCreationSnap() {
 		try (LockHold hold = LockHold.lock(space.lock.readLock())) {
-			return DBTraceUtils.lowerEndpoint(lifespan);
+			return lifespan.lmin();
 		}
 	}
 
 	@Override
 	public void setDestructionSnap(long destructionSnap)
 			throws DuplicateNameException, TraceOverlappedRegionException {
-		setLifespan(DBTraceUtils.toRange(getCreationSnap(), destructionSnap));
+		setLifespan(Lifespan.span(getCreationSnap(), destructionSnap));
 	}
 
 	@Override
 	public long getDestructionSnap() {
 		try (LockHold hold = LockHold.lock(space.lock.readLock())) {
-			return DBTraceUtils.upperEndpoint(lifespan);
+			return lifespan.lmax();
 		}
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceMemorySpace.java

@@ -25,12 +25,12 @@ import java.util.function.Predicate;
 
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.RemovalNotification;
-import com.google.common.collect.Range;
 
 import db.DBHandle;
 import ghidra.program.model.address.*;
 import ghidra.program.model.mem.MemBuffer;
-import ghidra.trace.database.*;
+import ghidra.trace.database.DBTrace;
+import ghidra.trace.database.DBTraceTimeViewport;
 import ghidra.trace.database.DBTraceUtils.AddressRangeMapSetter;
 import ghidra.trace.database.DBTraceUtils.OffsetSnap;
 import ghidra.trace.database.listing.DBTraceCodeSpace;
@@ -162,7 +162,7 @@ public class DBTraceMemorySpace
 	}
 
 	@Override
-	public DBTraceMemoryRegion addRegion(String path, Range<Long> lifespan,
+	public DBTraceMemoryRegion addRegion(String path, Lifespan lifespan,
 			AddressRange range, Collection<TraceMemoryFlag> flags)
 			throws TraceOverlappedRegionException, DuplicateNameException {
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
@@ -233,7 +233,7 @@ public class DBTraceMemorySpace
 	}
 
 	@Override
-	public Collection<? extends DBTraceMemoryRegion> getRegionsIntersecting(Range<Long> lifespan,
+	public Collection<? extends DBTraceMemoryRegion> getRegionsIntersecting(Lifespan lifespan,
 			AddressRange range) {
 		return Collections.unmodifiableCollection(regionMapSpace.reduce(
 			TraceAddressSnapRangeQuery.intersecting(range, lifespan)).values());
@@ -395,16 +395,16 @@ public class DBTraceMemorySpace
 
 	@Override
 	public Entry<Long, TraceMemoryState> getViewState(long snap, Address address) {
-		for (Range<Long> span : viewport.getOrderedSpans(snap)) {
-			TraceMemoryState state = getState(span.upperEndpoint(), address);
+		for (Lifespan span : viewport.getOrderedSpans(snap)) {
+			TraceMemoryState state = getState(span.lmax(), address);
 			switch (state) {
 				case KNOWN:
 				case ERROR:
-					return Map.entry(span.upperEndpoint(), state);
+					return Map.entry(span.lmax(), state);
 				default: // fall through
 			}
 			// Only the snap with the schedule specified gets the source snap's states
-			if (span.upperEndpoint() - span.lowerEndpoint() > 0) {
+			if (span.lmax() - span.lmin() > 0) {
 				return Map.entry(snap, TraceMemoryState.UNKNOWN);
 			}
 		}
@@ -421,7 +421,7 @@ public class DBTraceMemorySpace
 	@Override
 	public Entry<TraceAddressSnapRange, TraceMemoryState> getViewMostRecentStateEntry(long snap,
 			Address address) {
-		for (Range<Long> span : viewport.getOrderedSpans(snap)) {
+		for (Lifespan span : viewport.getOrderedSpans(snap)) {
 			Entry<TraceAddressSnapRange, TraceMemoryState> entry =
 				stateMapSpace.reduce(TraceAddressSnapRangeQuery.mostRecent(address, span))
 						.firstEntry();
@@ -440,7 +440,7 @@ public class DBTraceMemorySpace
 	}
 
 	@Override
-	public AddressSetView getAddressesWithState(Range<Long> lifespan,
+	public AddressSetView getAddressesWithState(Lifespan lifespan,
 			Predicate<TraceMemoryState> predicate) {
 		return new DBTraceAddressSnapRangePropertyMapAddressSetView<>(space, lock,
 			stateMapSpace.reduce(TraceAddressSnapRangeQuery.intersecting(lifespan, space)),
@@ -613,7 +613,7 @@ public class DBTraceMemorySpace
 			long endSnap = next.getSnap() - 1;
 			for (AddressRange rng : withState) {
 				changed.add(
-					new ImmutableTraceAddressSnapRange(rng, Range.closed(loc.snap, endSnap)));
+					new ImmutableTraceAddressSnapRange(rng, Lifespan.span(loc.snap, endSnap)));
 			}
 			if (remaining.isEmpty()) {
 				lastSnap.snap = endSnap;
@@ -628,7 +628,7 @@ public class DBTraceMemorySpace
 		if (!remaining.isEmpty()) {
 			lastSnap.snap = Long.MAX_VALUE;
 			for (AddressRange rng : remaining) {
-				changed.add(new ImmutableTraceAddressSnapRange(rng, Range.atLeast(loc.snap)));
+				changed.add(new ImmutableTraceAddressSnapRange(rng, Lifespan.nowOn(loc.snap)));
 			}
 		}
 		buf.position(pos);
@@ -758,7 +758,7 @@ public class DBTraceMemorySpace
 		Map<AddressRange, Long> sources = new TreeMap<>();
 		AddressSet remains = new AddressSet(toRead);
 
-		spans: for (Range<Long> span : viewport.getOrderedSpans(snap)) {
+		spans: for (Lifespan span : viewport.getOrderedSpans(snap)) {
 			Iterator<AddressRange> arit =
 				getAddressesWithState(span, s -> s == TraceMemoryState.KNOWN).iterator(start, true);
 			while (arit.hasNext()) {
@@ -768,7 +768,7 @@ public class DBTraceMemorySpace
 				}
 				for (AddressRange sub : remains.intersectRange(rng.getMinAddress(),
 					rng.getMaxAddress())) {
-					sources.put(sub, span.upperEndpoint());
+					sources.put(sub, span.lmax());
 				}
 				remains.delete(rng);
 				if (remains.isEmpty()) {
@@ -848,7 +848,7 @@ public class DBTraceMemorySpace
 		// We could do for this and previous snaps, but that's where the viewport comes in.
 		// TODO: Potentially costly to pre-compute the set concretely
 		AddressSet known = new AddressSet(
-			stateMapSpace.getAddressSetView(Range.all(), s -> s == TraceMemoryState.KNOWN))
+			stateMapSpace.getAddressSetView(Lifespan.ALL, s -> s == TraceMemoryState.KNOWN))
 					.intersect(new AddressSet(range));
 		monitor.initialize(known.getNumAddresses());
 		for (AddressRange knownRange : known.getAddressRanges(forward)) {
@@ -947,10 +947,10 @@ public class DBTraceMemorySpace
 	 * @return the first snap that should be excluded, or {@link Long#MIN_VALUE} to indicate no
 	 *         change.
 	 */
-	public long getFirstChange(Range<Long> span, AddressRange range) {
+	public long getFirstChange(Lifespan span, AddressRange range) {
 		assertInSpace(range);
-		long lower = DBTraceUtils.lowerEndpoint(span);
-		long upper = DBTraceUtils.upperEndpoint(span);
+		long lower = span.lmin();
+		long upper = span.lmax();
 		if (lower == upper) {
 			return Long.MIN_VALUE;
 		}
@@ -958,7 +958,7 @@ public class DBTraceMemorySpace
 		if (cross && lower == -1) {
 			return 0; // Avoid reversal of range end points. 
 		}
-		Range<Long> fwdOne = DBTraceUtils.toRange(lower + 1, cross ? -1 : upper);
+		Lifespan fwdOne = Lifespan.span(lower + 1, cross ? -1 : upper);
 		ByteBuffer buf1 = ByteBuffer.allocate(BLOCK_SIZE);
 		ByteBuffer buf2 = ByteBuffer.allocate(BLOCK_SIZE);
 		try (LockHold hold = LockHold.lock(lock.readLock())) {

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceObjectMemoryRegion.java

@@ -17,8 +17,6 @@ package ghidra.trace.database.memory;
 
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.target.TargetMemoryRegion;
 import ghidra.dbg.target.TargetObject;
 import ghidra.program.model.address.*;
@@ -26,6 +24,7 @@ import ghidra.trace.database.DBTrace;
 import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.target.DBTraceObject;
 import ghidra.trace.database.target.DBTraceObjectInterface;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.Trace.TraceMemoryRegionChangeType;
 import ghidra.trace.model.memory.*;
@@ -50,7 +49,7 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 		}
 
 		@Override
-		protected TraceChangeType<TraceMemoryRegion, Range<Long>> getLifespanChangedType() {
+		protected TraceChangeType<TraceMemoryRegion, Lifespan> getLifespanChangedType() {
 			return TraceMemoryRegionChangeType.LIFESPAN_CHANGED;
 		}
 
@@ -79,12 +78,12 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 		}
 
 		@Override
-		protected void emitExtraLifespanChanged(Range<Long> oldLifespan, Range<Long> newLifespan) {
+		protected void emitExtraLifespanChanged(Lifespan oldLifespan, Lifespan newLifespan) {
 			updateViewsLifespanChanged(oldLifespan, newLifespan);
 		}
 
 		@Override
-		protected void emitExtraValueChanged(Range<Long> lifespan, String key, Object oldValue,
+		protected void emitExtraValueChanged(Lifespan lifespan, String key, Object oldValue,
 				Object newValue) {
 			updateViewsValueChanged(lifespan, key, oldValue, newValue);
 		}
@@ -100,7 +99,7 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 
 	// Keep copies here for when the object gets invalidated
 	private AddressRange range;
-	private Range<Long> lifespan;
+	private Lifespan lifespan;
 
 	public DBTraceObjectMemoryRegion(DBTraceObject object) {
 		this.object = object;
@@ -119,7 +118,7 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 	}
 
 	@Override
-	public void setName(Range<Long> lifespan, String name) {
+	public void setName(Lifespan lifespan, String name) {
 		object.setValue(lifespan, TargetObject.DISPLAY_ATTRIBUTE_NAME, name);
 	}
 
@@ -138,7 +137,7 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 	}
 
 	@Override
-	public void setLifespan(Range<Long> newLifespan) throws DuplicateNameException {
+	public void setLifespan(Lifespan newLifespan) throws DuplicateNameException {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			TraceObjectInterfaceUtils.setLifespan(TraceObjectMemoryRegion.class, object,
 				newLifespan);
@@ -147,9 +146,9 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 	}
 
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		try (LockHold hold = object.getTrace().lockRead()) {
-			Range<Long> computed = computeSpan();
+			Lifespan computed = computeSpan();
 			if (computed != null) {
 				lifespan = computed;
 			}
@@ -160,7 +159,7 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 	@Override
 	public void setCreationSnap(long creationSnap) throws DuplicateNameException {
 		try (LockHold hold = object.getTrace().lockWrite()) {
-			setLifespan(DBTraceUtils.toRange(creationSnap, getDestructionSnap()));
+			setLifespan(Lifespan.span(creationSnap, getDestructionSnap()));
 		}
 	}
 
@@ -172,7 +171,7 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 	@Override
 	public void setDestructionSnap(long destructionSnap) throws DuplicateNameException {
 		try (LockHold hold = object.getTrace().lockWrite()) {
-			setLifespan(DBTraceUtils.toRange(getCreationSnap(), destructionSnap));
+			setLifespan(Lifespan.span(getCreationSnap(), destructionSnap));
 		}
 	}
 
@@ -182,7 +181,7 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 	}
 
 	@Override
-	public void setRange(Range<Long> lifespan, AddressRange newRange) {
+	public void setRange(Lifespan lifespan, AddressRange newRange) {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			object.setValue(lifespan, TargetMemoryRegion.RANGE_ATTRIBUTE_NAME, newRange);
 			this.range = newRange;
@@ -261,7 +260,7 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 	}
 
 	@Override
-	public void setFlags(Range<Long> lifespan, Collection<TraceMemoryFlag> flags) {
+	public void setFlags(Lifespan lifespan, Collection<TraceMemoryFlag> flags) {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			for (TraceMemoryFlag flag : TraceMemoryFlag.values()) {
 				Boolean val = flags.contains(flag) ? true : null;
@@ -271,7 +270,7 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 	}
 
 	@Override
-	public void addFlags(Range<Long> lifespan, Collection<TraceMemoryFlag> flags) {
+	public void addFlags(Lifespan lifespan, Collection<TraceMemoryFlag> flags) {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			for (TraceMemoryFlag flag : flags) {
 				object.setValue(lifespan, keyForFlag(flag), true);
@@ -280,7 +279,7 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 	}
 
 	@Override
-	public void clearFlags(Range<Long> lifespan, Collection<TraceMemoryFlag> flags) {
+	public void clearFlags(Lifespan lifespan, Collection<TraceMemoryFlag> flags) {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			for (TraceMemoryFlag flag : flags) {
 				object.setValue(lifespan, keyForFlag(flag), null);
@@ -348,11 +347,11 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
 		object.getTrace().updateViewsAddRegionBlock(this);
 	}
 
-	protected void updateViewsLifespanChanged(Range<Long> oldLifespan, Range<Long> newLifespan) {
+	protected void updateViewsLifespanChanged(Lifespan oldLifespan, Lifespan newLifespan) {
 		object.getTrace().updateViewsChangeRegionBlockLifespan(this, oldLifespan, newLifespan);
 	}
 
-	protected void updateViewsValueChanged(Range<Long> lifespan, String key, Object oldValue,
+	protected void updateViewsValueChanged(Lifespan lifespan, String key, Object oldValue,
 			Object newValue) {
 		DBTrace trace = object.getTrace();
 		switch (key) {

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceObjectRegister.java

@@ -17,13 +17,12 @@ package ghidra.trace.database.memory;
 
 import java.math.BigInteger;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.target.TargetRegister;
 import ghidra.dbg.util.PathUtils;
 import ghidra.pcode.utils.Utils;
 import ghidra.trace.database.target.DBTraceObject;
 import ghidra.trace.database.target.DBTraceObjectInterface;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemoryState;
 import ghidra.trace.model.memory.TraceObjectRegister;
 import ghidra.trace.model.target.*;
@@ -66,7 +65,7 @@ public class DBTraceObjectRegister implements TraceObjectRegister, DBTraceObject
 	}
 
 	@Override
-	public void setValue(Range<Long> lifespan, byte[] value) {
+	public void setValue(Lifespan lifespan, byte[] value) {
 		int length = getByteLength();
 		if (length != 0 && value.length != length) {
 			throw new IllegalArgumentException("Length must match the register");
@@ -94,7 +93,7 @@ public class DBTraceObjectRegister implements TraceObjectRegister, DBTraceObject
 	}
 
 	@Override
-	public void setState(Range<Long> lifespan, TraceMemoryState state) {
+	public void setState(Lifespan lifespan, TraceMemoryState state) {
 		// NB. There's no model equivalent, so encode using ordinal
 		object.setValue(lifespan, KEY_STATE, state.ordinal());
 	}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceModule.java

@@ -17,14 +17,13 @@ package ghidra.trace.database.module;
 
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.program.model.address.*;
 import ghidra.trace.database.DBTrace;
 import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceModuleChangeType;
 import ghidra.trace.model.modules.TraceModule;
 import ghidra.trace.model.modules.TraceSection;
@@ -176,8 +175,8 @@ public class DBTraceModule extends AbstractDBTraceAddressSnapRangePropertyMapDat
 	}
 
 	@Override
-	public void setLifespan(Range<Long> newLifespan) throws DuplicateNameException {
-		Range<Long> oldLifespan;
+	public void setLifespan(Lifespan newLifespan) throws DuplicateNameException {
+		Lifespan oldLifespan;
 		try (LockHold hold = LockHold.lock(space.manager.writeLock())) {
 			space.manager.checkModulePathConflicts(this, path, newLifespan);
 			ArrayList<? extends DBTraceSection> sections = new ArrayList<>(getSections());
@@ -196,7 +195,7 @@ public class DBTraceModule extends AbstractDBTraceAddressSnapRangePropertyMapDat
 	}
 
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		try (LockHold hold = LockHold.lock(space.manager.readLock())) {
 			return lifespan;
 		}
@@ -204,25 +203,25 @@ public class DBTraceModule extends AbstractDBTraceAddressSnapRangePropertyMapDat
 
 	@Override
 	public void setLoadedSnap(long loadedSnap) throws DuplicateNameException {
-		setLifespan(DBTraceUtils.toRange(loadedSnap, DBTraceUtils.upperEndpoint(lifespan)));
+		setLifespan(Lifespan.span(loadedSnap, getUnloadedSnap()));
 	}
 
 	@Override
 	public long getLoadedSnap() {
 		try (LockHold hold = LockHold.lock(space.manager.readLock())) {
-			return DBTraceUtils.lowerEndpoint(lifespan);
+			return lifespan.lmin();
 		}
 	}
 
 	@Override
 	public void setUnloadedSnap(long unloadedSnap) throws DuplicateNameException {
-		setLifespan(DBTraceUtils.toRange(DBTraceUtils.lowerEndpoint(lifespan), unloadedSnap));
+		setLifespan(Lifespan.span(getLoadedSnap(), unloadedSnap));
 	}
 
 	@Override
 	public long getUnloadedSnap() {
 		try (LockHold hold = LockHold.lock(space.manager.readLock())) {
-			return DBTraceUtils.upperEndpoint(lifespan);
+			return lifespan.lmax();
 		}
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceModuleManager.java

@@ -20,17 +20,15 @@ import java.util.*;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReadWriteLock;
 
-import com.google.common.collect.Range;
-
 import db.DBHandle;
 import ghidra.dbg.target.TargetModule;
 import ghidra.dbg.target.TargetSection;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.Language;
 import ghidra.trace.database.DBTrace;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager;
 import ghidra.trace.database.space.DBTraceDelegatingManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceModuleChangeType;
 import ghidra.trace.model.modules.*;
 import ghidra.trace.model.thread.TraceThread;
@@ -64,12 +62,12 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
 	}
 
 	protected void checkModulePathConflicts(TraceModule ignore, String modulePath,
-			Range<Long> moduleLifespan) throws DuplicateNameException {
+			Lifespan moduleLifespan) throws DuplicateNameException {
 		for (TraceModule pc : doGetModulesByPath(modulePath)) {
 			if (pc == ignore) {
 				continue;
 			}
-			if (!DBTraceUtils.intersect(pc.getLifespan(), moduleLifespan)) {
+			if (!pc.getLifespan().intersects(moduleLifespan)) {
 				continue;
 			}
 			throw new DuplicateNameException("Module with path '" +
@@ -78,7 +76,7 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
 	}
 
 	protected void checkSectionPathConflicts(DBTraceSection ignore, String sectionPath,
-			Range<Long> moduleLifespan) throws DuplicateNameException {
+			Lifespan moduleLifespan) throws DuplicateNameException {
 		Collection<? extends TraceSection> pathConflicts = doGetSectionsByPath(sectionPath);
 		for (TraceSection pc : pathConflicts) {
 			if (pc == ignore) {
@@ -89,7 +87,7 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
 			 * so have the same lifespan, no? I suppose this logic is only true in objects mode...,
 			 * and there, the logic is performed by the value key duplicate check.
 			 */
-			if (!DBTraceUtils.intersect(pc.getModule().getLifespan(), moduleLifespan)) {
+			if (!pc.getModule().getLifespan().intersects(moduleLifespan)) {
 				continue;
 			}
 			throw new DuplicateNameException("Section with path '" + sectionPath +
@@ -99,14 +97,14 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
 
 	@Override
 	public TraceModule addModule(String modulePath, String moduleName, AddressRange range,
-			Range<Long> lifespan) throws DuplicateNameException {
+			Lifespan lifespan) throws DuplicateNameException {
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
 			return doAddModule(modulePath, moduleName, range, lifespan);
 		}
 	}
 
 	protected TraceModule doAddModule(String modulePath, String moduleName, AddressRange range,
-			Range<Long> lifespan) throws DuplicateNameException {
+			Lifespan lifespan) throws DuplicateNameException {
 		if (trace.getObjectManager().hasSchema()) {
 			return trace.getObjectManager().addModule(modulePath, moduleName, lifespan, range);
 		}
@@ -170,7 +168,7 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
 	}
 
 	@Override
-	public Collection<? extends TraceModule> getModulesIntersecting(Range<Long> lifespan,
+	public Collection<? extends TraceModule> getModulesIntersecting(Lifespan lifespan,
 			AddressRange range) {
 		if (trace.getObjectManager().hasSchema()) {
 			return trace.getObjectManager()
@@ -198,7 +196,7 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
 	}
 
 	@Override
-	public Collection<? extends TraceSection> getSectionsIntersecting(Range<Long> lifespan,
+	public Collection<? extends TraceSection> getSectionsIntersecting(Lifespan lifespan,
 			AddressRange range) {
 		if (trace.getObjectManager().hasSchema()) {
 			return trace.getObjectManager()

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceModuleSpace.java

@@ -19,8 +19,6 @@ import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.locks.ReadWriteLock;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.*;
 import ghidra.trace.database.DBTrace;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapSpace;
@@ -28,6 +26,7 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAdd
 import ghidra.trace.database.space.DBTraceSpaceBased;
 import ghidra.trace.database.thread.DBTraceThread;
 import ghidra.trace.model.ImmutableTraceAddressSnapRange;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceModuleChangeType;
 import ghidra.trace.model.Trace.TraceSectionChangeType;
 import ghidra.trace.model.modules.TraceModuleSpace;
@@ -95,7 +94,7 @@ public class DBTraceModuleSpace implements TraceModuleSpace, DBTraceSpaceBased {
 	}
 
 	protected DBTraceModule doAddModule(String modulePath, String moduleName, AddressRange range,
-			Range<Long> lifespan) {
+			Lifespan lifespan) {
 		DBTraceModule module = moduleMapSpace
 				.put(new ImmutableTraceAddressSnapRange(range, lifespan), null);
 		module.set(modulePath, moduleName);
@@ -125,7 +124,7 @@ public class DBTraceModuleSpace implements TraceModuleSpace, DBTraceSpaceBased {
 	}
 
 	@Override
-	public Collection<? extends DBTraceModule> getModulesIntersecting(Range<Long> lifespan,
+	public Collection<? extends DBTraceModule> getModulesIntersecting(Lifespan lifespan,
 			AddressRange range) {
 		return Collections.unmodifiableCollection(
 			moduleMapSpace.reduce(TraceAddressSnapRangeQuery.intersecting(range, lifespan))
@@ -153,7 +152,7 @@ public class DBTraceModuleSpace implements TraceModuleSpace, DBTraceSpaceBased {
 	}
 
 	@Override
-	public Collection<? extends DBTraceSection> getSectionsIntersecting(Range<Long> lifespan,
+	public Collection<? extends DBTraceSection> getSectionsIntersecting(Lifespan lifespan,
 			AddressRange range) {
 		return Collections.unmodifiableCollection(
 			sectionMapSpace.reduce(TraceAddressSnapRangeQuery.intersecting(range, lifespan))

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceObjectModule.java

@@ -19,8 +19,6 @@ import java.util.Collection;
 import java.util.List;
 import java.util.stream.Collectors;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.target.*;
 import ghidra.dbg.util.PathMatcher;
 import ghidra.dbg.util.PathPredicates.Align;
@@ -28,6 +26,7 @@ import ghidra.dbg.util.PathUtils;
 import ghidra.program.model.address.*;
 import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.target.*;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.Trace.TraceModuleChangeType;
 import ghidra.trace.model.modules.*;
@@ -51,7 +50,7 @@ public class DBTraceObjectModule implements TraceObjectModule, DBTraceObjectInte
 		}
 
 		@Override
-		protected TraceChangeType<TraceModule, Range<Long>> getLifespanChangedType() {
+		protected TraceChangeType<TraceModule, Lifespan> getLifespanChangedType() {
 			return TraceModuleChangeType.LIFESPAN_CHANGED;
 		}
 
@@ -77,7 +76,7 @@ public class DBTraceObjectModule implements TraceObjectModule, DBTraceObjectInte
 
 	// Keep copies here for when the object gets invalidated
 	private AddressRange range;
-	private Range<Long> lifespan;
+	private Lifespan lifespan;
 
 	public DBTraceObjectModule(DBTraceObject object) {
 		this.object = object;
@@ -110,7 +109,7 @@ public class DBTraceObjectModule implements TraceObjectModule, DBTraceObjectInte
 	}
 
 	@Override
-	public void setName(Range<Long> lifespan, String name) {
+	public void setName(Lifespan lifespan, String name) {
 		object.setValue(lifespan, TargetModule.MODULE_NAME_ATTRIBUTE_NAME, name);
 	}
 
@@ -128,7 +127,7 @@ public class DBTraceObjectModule implements TraceObjectModule, DBTraceObjectInte
 	}
 
 	@Override
-	public void setRange(Range<Long> lifespan, AddressRange range) {
+	public void setRange(Lifespan lifespan, AddressRange range) {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			object.setValue(lifespan, TargetModule.RANGE_ATTRIBUTE_NAME, range);
 			this.range = range;
@@ -192,7 +191,7 @@ public class DBTraceObjectModule implements TraceObjectModule, DBTraceObjectInte
 	}
 
 	@Override
-	public void setLifespan(Range<Long> lifespan) throws DuplicateNameException {
+	public void setLifespan(Lifespan lifespan) throws DuplicateNameException {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			TraceObjectInterfaceUtils.setLifespan(TraceObjectModule.class, object, lifespan);
 			this.lifespan = lifespan;
@@ -204,9 +203,9 @@ public class DBTraceObjectModule implements TraceObjectModule, DBTraceObjectInte
 	}
 
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		try (LockHold hold = object.getTrace().lockRead()) {
-			Range<Long> computed = computeSpan();
+			Lifespan computed = computeSpan();
 			if (computed != null) {
 				lifespan = computed;
 			}
@@ -217,7 +216,7 @@ public class DBTraceObjectModule implements TraceObjectModule, DBTraceObjectInte
 	@Override
 	public void setLoadedSnap(long loadedSnap) throws DuplicateNameException {
 		try (LockHold hold = object.getTrace().lockWrite()) {
-			setLifespan(DBTraceUtils.toRange(loadedSnap, getUnloadedSnap()));
+			setLifespan(Lifespan.span(loadedSnap, getUnloadedSnap()));
 		}
 	}
 
@@ -229,7 +228,7 @@ public class DBTraceObjectModule implements TraceObjectModule, DBTraceObjectInte
 	@Override
 	public void setUnloadedSnap(long unloadedSnap) throws DuplicateNameException {
 		try (LockHold hold = object.getTrace().lockWrite()) {
-			setLifespan(DBTraceUtils.toRange(getLoadedSnap(), unloadedSnap));
+			setLifespan(Lifespan.span(getLoadedSnap(), unloadedSnap));
 		}
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceObjectSection.java

@@ -15,12 +15,11 @@
  */
 package ghidra.trace.database.module;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.target.*;
 import ghidra.program.model.address.AddressRange;
 import ghidra.trace.database.target.DBTraceObject;
 import ghidra.trace.database.target.DBTraceObjectInterface;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.Trace.TraceSectionChangeType;
 import ghidra.trace.model.modules.TraceObjectModule;
@@ -44,7 +43,7 @@ public class DBTraceObjectSection implements TraceObjectSection, DBTraceObjectIn
 		}
 
 		@Override
-		protected TraceChangeType<TraceSection, Range<Long>> getLifespanChangedType() {
+		protected TraceChangeType<TraceSection, Lifespan> getLifespanChangedType() {
 			return null; // it's the module's lifespan that matters.
 		}
 
@@ -97,7 +96,7 @@ public class DBTraceObjectSection implements TraceObjectSection, DBTraceObjectIn
 	}
 
 	@Override
-	public void setName(Range<Long> lifespan, String name) {
+	public void setName(Lifespan lifespan, String name) {
 		object.setValue(lifespan, TargetObject.DISPLAY_ATTRIBUTE_NAME, name);
 	}
 
@@ -115,7 +114,7 @@ public class DBTraceObjectSection implements TraceObjectSection, DBTraceObjectIn
 	}
 
 	@Override
-	public void setRange(Range<Long> lifespan, AddressRange range) {
+	public void setRange(Lifespan lifespan, AddressRange range) {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			object.setValue(lifespan, TargetModule.RANGE_ATTRIBUTE_NAME, range);
 			this.range = range;
@@ -134,8 +133,8 @@ public class DBTraceObjectSection implements TraceObjectSection, DBTraceObjectIn
 	}
 
 	@Override
-	public Range<Long> computeSpan() {
-		Range<Long> span = DBTraceObjectInterface.super.computeSpan();
+	public Lifespan computeSpan() {
+		Lifespan span = DBTraceObjectInterface.super.computeSpan();
 		if (span != null) {
 			return span;
 		}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceSection.java

@@ -18,13 +18,12 @@ package ghidra.trace.database.module;
 import java.io.IOException;
 import java.util.Objects;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.program.model.address.AddressSpace;
 import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.Trace.TraceSectionChangeType;
 import ghidra.trace.model.modules.TraceSection;
@@ -118,8 +117,7 @@ public class DBTraceSection extends AbstractDBTraceAddressSnapRangePropertyMapDa
 	}
 
 	@Override // Expose to this package
-	@SuppressWarnings("hiding")
-	protected void doSetLifespan(Range<Long> lifespan) {
+	protected void doSetLifespan(Lifespan lifespan) {
 		super.doSetLifespan(lifespan);
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceStaticMapping.java

@@ -19,15 +19,13 @@ import java.io.IOException;
 import java.net.URL;
 import java.util.Objects;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.program.model.address.*;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.DBTraceUtils.URLDBFieldCodec;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter.AddressDBFieldCodec;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter.DecodesAddresses;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.modules.TraceStaticMapping;
 import ghidra.util.LockHold;
@@ -106,7 +104,7 @@ public class DBTraceStaticMapping extends DBAnnotatedObject
 
 	private AddressRange traceRange;
 	private long shift;
-	private Range<Long> lifespan;
+	private Lifespan lifespan;
 
 	public DBTraceStaticMapping(DBTraceStaticMappingManager manager, DBCachedObjectStore<?> store,
 			DBRecord record) {
@@ -127,10 +125,10 @@ public class DBTraceStaticMapping extends DBAnnotatedObject
 			throw new AssertionError(e);
 		}
 		this.shift = traceAddress.getOffset() - parseOffset(staticAddress);
-		this.lifespan = DBTraceUtils.toRange(startSnap, endSnap);
+		this.lifespan = Lifespan.span(startSnap, endSnap);
 	}
 
-	void set(AddressRange traceRange, Range<Long> lifespan, URL staticProgramURL,
+	void set(AddressRange traceRange, Lifespan lifespan, URL staticProgramURL,
 			String staticAddress) {
 		if (startSnap == -1) {
 			throw new IllegalArgumentException("endpoint cannot be -1");
@@ -139,8 +137,8 @@ public class DBTraceStaticMapping extends DBAnnotatedObject
 		this.traceAddress = traceRange.getMinAddress();
 		this.length = traceRange.getLength();
 		this.lifespan = lifespan;
-		this.startSnap = DBTraceUtils.lowerEndpoint(lifespan);
-		this.endSnap = DBTraceUtils.upperEndpoint(lifespan);
+		this.startSnap = lifespan.lmin();
+		this.endSnap = lifespan.lmax();
 		this.staticProgramURL = staticProgramURL;
 		this.staticAddress = staticAddress;
 		update(TRACE_ADDRESS_COLUMN, LENGTH_COLUMN, START_SNAP_COLUMN, END_SNAP_COLUMN,
@@ -185,7 +183,7 @@ public class DBTraceStaticMapping extends DBAnnotatedObject
 	}
 
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		return lifespan;
 	}
 
@@ -216,14 +214,14 @@ public class DBTraceStaticMapping extends DBAnnotatedObject
 
 	@Override
 	@SuppressWarnings("hiding")
-	public boolean conflictsWith(AddressRange range, Range<Long> lifespan, URL toProgramURL,
+	public boolean conflictsWith(AddressRange range, Lifespan lifespan, URL toProgramURL,
 			String toAddress) {
 		try (LockHold hold = LockHold.lock(manager.lock.readLock())) {
 			// Must overlap to conflict
 			if (!traceRange.intersects(range)) {
 				return false;
 			}
-			if (!DBTraceUtils.intersect(this.lifespan, lifespan)) {
+			if (!this.lifespan.intersects(lifespan)) {
 				return false;
 			}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceStaticMappingManager.java

@@ -20,14 +20,13 @@ import java.net.URL;
 import java.util.*;
 import java.util.concurrent.locks.ReadWriteLock;
 
-import com.google.common.collect.BoundType;
-import com.google.common.collect.Range;
-
 import db.DBHandle;
 import ghidra.program.model.address.Address;
 import ghidra.program.model.address.AddressRange;
-import ghidra.trace.database.*;
+import ghidra.trace.database.DBTrace;
+import ghidra.trace.database.DBTraceManager;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceStaticMappingChangeType;
 import ghidra.trace.model.modules.TraceConflictedMappingException;
 import ghidra.trace.model.modules.TraceStaticMappingManager;
@@ -78,13 +77,10 @@ public class DBTraceStaticMappingManager implements TraceStaticMappingManager, D
 	}
 
 	@Override
-	public DBTraceStaticMapping add(AddressRange range, Range<Long> lifespan, URL toProgramURL,
+	public DBTraceStaticMapping add(AddressRange range, Lifespan lifespan, URL toProgramURL,
 			String toAddress) throws TraceConflictedMappingException {
 		Objects.requireNonNull(toProgramURL,
 			"Program URL cannot be null. Program must be in a project to have a URL.");
-		if (lifespan.hasLowerBound() && lifespan.lowerBoundType() != BoundType.CLOSED) {
-			throw new IllegalArgumentException("Lower bound must be closed");
-		}
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
 			DBTraceStaticMapping conflict =
 				findAnyConflicting(range, lifespan, toProgramURL, toAddress);
@@ -136,7 +132,7 @@ public class DBTraceStaticMappingManager implements TraceStaticMappingManager, D
 	}
 
 	@Override
-	public DBTraceStaticMapping findAnyConflicting(AddressRange range, Range<Long> lifespan,
+	public DBTraceStaticMapping findAnyConflicting(AddressRange range, Lifespan lifespan,
 			URL toProgramURL,
 			String toAddress) {
 		for (DBTraceStaticMapping mapping : mappingsByAddress.head(range.getMaxAddress(),
@@ -157,11 +153,11 @@ public class DBTraceStaticMappingManager implements TraceStaticMappingManager, D
 
 	@Override
 	public Collection<? extends DBTraceStaticMapping> findAllOverlapping(AddressRange range,
-			Range<Long> lifespan) {
+			Lifespan lifespan) {
 		Set<DBTraceStaticMapping> result = new HashSet<>();
 		for (DBTraceStaticMapping mapping : mappingsByAddress.head(range.getMaxAddress(),
 			true).descending().values()) {
-			if (!DBTraceUtils.intersect(mapping.getLifespan(), lifespan)) {
+			if (!mapping.getLifespan().intersects(lifespan)) {
 				continue;
 			}
 			if (!mapping.getTraceAddressRange().intersects(range)) {

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/TraceObjectSection.java

@@ -15,11 +15,10 @@
  */
 package ghidra.trace.database.module;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.target.TargetObject;
 import ghidra.dbg.target.TargetSection;
 import ghidra.program.model.address.AddressRange;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.modules.TraceSection;
 import ghidra.trace.model.target.TraceObjectInterface;
 import ghidra.trace.model.target.annot.TraceObjectInfo;
@@ -32,7 +31,7 @@ import ghidra.trace.model.target.annot.TraceObjectInfo;
 		TargetSection.RANGE_ATTRIBUTE_NAME
 	})
 public interface TraceObjectSection extends TraceSection, TraceObjectInterface {
-	void setName(Range<Long> lifespan, String name);
+	void setName(Lifespan lifespan, String name);
 
-	void setRange(Range<Long> lifespan, AddressRange range);
+	void setRange(Lifespan lifespan, AddressRange range);
 }

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/AbstractDBTraceProgramViewListing.java

@@ -21,7 +21,6 @@ import java.util.*;
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.RemovalNotification;
 import com.google.common.collect.Iterators;
-import com.google.common.collect.Range;
 
 import generic.NestedIterator;
 import ghidra.program.database.ProgramDB;
@@ -256,7 +255,7 @@ public abstract class AbstractDBTraceProgramViewListing implements TraceProgramV
 	}
 
 	protected boolean isUndefinedRange(long snap, AddressRange range) {
-		if (codeOperations.undefinedData().coversRange(Range.singleton(snap), range)) {
+		if (codeOperations.undefinedData().coversRange(Lifespan.at(snap), range)) {
 			return true;
 		}
 		TraceCodeUnit minUnit =
@@ -368,7 +367,7 @@ public abstract class AbstractDBTraceProgramViewListing implements TraceProgramV
 		}
 		// TODO: The property map doesn't heed forking.
 		return new WrappingCodeUnitIterator(NestedIterator.start(
-			map.getAddressSetView(Range.singleton(program.snap)).iterator(forward),
+			map.getAddressSetView(Lifespan.at(program.snap)).iterator(forward),
 			rng -> getTopCodeIterator(
 				s -> codeOperations.codeUnits().get(s, rng, forward).iterator(),
 				forward)));
@@ -390,7 +389,7 @@ public abstract class AbstractDBTraceProgramViewListing implements TraceProgramV
 		}
 		// TODO: The property map doesn't heed forking.
 		return new WrappingCodeUnitIterator(NestedIterator.start(
-			map.getAddressSetView(Range.singleton(program.snap)).iterator(addr, forward),
+			map.getAddressSetView(Lifespan.at(program.snap)).iterator(addr, forward),
 			rng -> getTopCodeIterator(
 				s -> codeOperations.codeUnits().get(s, rng, forward).iterator(),
 				forward)));
@@ -413,7 +412,7 @@ public abstract class AbstractDBTraceProgramViewListing implements TraceProgramV
 		}
 		// TODO: The property map doesn't heed forking.
 		return new WrappingCodeUnitIterator(NestedIterator.start(
-			new IntersectionAddressSetView(map.getAddressSetView(Range.singleton(program.snap)),
+			new IntersectionAddressSetView(map.getAddressSetView(Lifespan.at(program.snap)),
 				addrSet).iterator(forward),
 			rng -> getTopCodeIterator(
 				s -> codeOperations.codeUnits().get(s, rng, forward).iterator(),
@@ -423,13 +422,13 @@ public abstract class AbstractDBTraceProgramViewListing implements TraceProgramV
 	protected AddressSetView getCommentAddresses(int commentType, AddressSetView addrSet) {
 		return new IntersectionAddressSetView(addrSet, program.viewport.unionedAddresses(
 			s -> program.trace.getCommentAdapter()
-					.getAddressSetView(Range.singleton(s), e -> e.getType() == commentType)));
+					.getAddressSetView(Lifespan.at(s), e -> e.getType() == commentType)));
 	}
 
 	protected AddressSetView getCommentAddresses(AddressSetView addrSet) {
 		return new IntersectionAddressSetView(addrSet, program.viewport.unionedAddresses(
 			s -> program.trace.getCommentAdapter()
-					.getAddressSetView(Range.singleton(s))));
+					.getAddressSetView(Lifespan.at(s))));
 	}
 
 	@Override
@@ -460,7 +459,7 @@ public abstract class AbstractDBTraceProgramViewListing implements TraceProgramV
 	@Override
 	public void setComment(Address address, int commentType, String comment) {
 		program.trace.getCommentAdapter()
-				.setComment(Range.atLeast(program.snap), address,
+				.setComment(Lifespan.nowOn(program.snap), address,
 					commentType, comment);
 	}
 
@@ -720,6 +719,7 @@ public abstract class AbstractDBTraceProgramViewListing implements TraceProgramV
 	}
 
 	@Override
+	@SuppressWarnings("rawtypes")
 	public PropertyMap getPropertyMap(String propertyName) {
 		// TODO Auto-generated method stub
 		return null;
@@ -730,14 +730,14 @@ public abstract class AbstractDBTraceProgramViewListing implements TraceProgramV
 			MemBuffer memBuf, ProcessorContextView context) throws CodeUnitInsertionException {
 		// TODO: Why memBuf? Can it vary from program memory?
 		return codeOperations.instructions()
-				.create(Range.atLeast(program.snap), addr, platform, prototype, context);
+				.create(Lifespan.nowOn(program.snap), addr, platform, prototype, context);
 	}
 
 	@Override
 	public AddressSetView addInstructions(InstructionSet instructionSet, boolean overwrite)
 			throws CodeUnitInsertionException {
 		return codeOperations.instructions()
-				.addInstructionSet(Range.atLeast(program.snap), platform, instructionSet,
+				.addInstructionSet(Lifespan.nowOn(program.snap), platform, instructionSet,
 					overwrite);
 	}
 
@@ -745,12 +745,12 @@ public abstract class AbstractDBTraceProgramViewListing implements TraceProgramV
 	public Data createData(Address addr, DataType dataType, int length)
 			throws CodeUnitInsertionException {
 		return codeOperations.definedData()
-				.create(Range.atLeast(program.snap), addr, dataType, length);
+				.create(Lifespan.nowOn(program.snap), addr, dataType, length);
 	}
 
 	@Override
 	public Data createData(Address addr, DataType dataType) throws CodeUnitInsertionException {
-		return codeOperations.definedData().create(Range.atLeast(program.snap), addr, dataType);
+		return codeOperations.definedData().create(Lifespan.nowOn(program.snap), addr, dataType);
 	}
 
 	@Override
@@ -766,7 +766,7 @@ public abstract class AbstractDBTraceProgramViewListing implements TraceProgramV
 	@Override
 	public void clearComments(Address startAddr, Address endAddr) {
 		program.trace.getCommentAdapter()
-				.clearComments(Range.atLeast(program.snap),
+				.clearComments(Lifespan.nowOn(program.snap),
 					new AddressRangeImpl(startAddr, endAddr), CodeUnit.NO_COMMENT);
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/AbstractDBTraceProgramViewReferenceManager.java

@@ -23,8 +23,6 @@ import java.util.function.Predicate;
 
 import javax.help.UnsupportedOperationException;
 
-import com.google.common.collect.Range;
-
 import generic.NestedIterator;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.Register;
@@ -32,6 +30,7 @@ import ghidra.program.model.listing.Variable;
 import ghidra.program.model.symbol.*;
 import ghidra.trace.database.symbol.DBTraceReference;
 import ghidra.trace.database.symbol.DBTraceReferenceManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.listing.TraceCodeOperations;
 import ghidra.trace.model.listing.TraceCodeUnit;
 import ghidra.trace.model.symbol.TraceReference;
@@ -73,11 +72,11 @@ public abstract class AbstractDBTraceProgramViewReferenceManager implements Refe
 		return code;
 	}
 
-	protected Range<Long> chooseLifespan(Address fromAddr) {
+	protected Lifespan chooseLifespan(Address fromAddr) {
 		TraceCodeUnit unit = code(false) == null
 				? null
 				: code.codeUnits().getAt(program.snap, fromAddr);
-		return unit == null ? Range.atLeast(program.snap) : unit.getLifespan();
+		return unit == null ? Lifespan.nowOn(program.snap) : unit.getLifespan();
 	}
 
 	@Override
@@ -147,7 +146,7 @@ public abstract class AbstractDBTraceProgramViewReferenceManager implements Refe
 		if (refs(false) == null) {
 			return;
 		}
-		refs.clearReferencesFrom(Range.closed(program.snap, program.snap),
+		refs.clearReferencesFrom(Lifespan.at(program.snap),
 			new AddressRangeImpl(beginAddr, endAddr));
 	}
 
@@ -156,7 +155,7 @@ public abstract class AbstractDBTraceProgramViewReferenceManager implements Refe
 		if (refs(false) == null) {
 			return;
 		}
-		refs.clearReferencesFrom(Range.closed(program.snap, program.snap),
+		refs.clearReferencesFrom(Lifespan.at(program.snap),
 			new AddressRangeImpl(fromAddr, fromAddr));
 	}
 
@@ -165,7 +164,7 @@ public abstract class AbstractDBTraceProgramViewReferenceManager implements Refe
 		if (refs(false) == null) {
 			return;
 		}
-		refs.clearReferencesTo(Range.closed(program.snap, program.snap),
+		refs.clearReferencesTo(Lifespan.at(program.snap),
 			new AddressRangeImpl(toAddr, toAddr));
 	}
 
@@ -242,7 +241,7 @@ public abstract class AbstractDBTraceProgramViewReferenceManager implements Refe
 
 	protected Iterator<Reference> getReferenceIteratorForSnap(long snap, Address startAddr) {
 		AddressIterator addresses =
-			refs.getReferenceSources(Range.singleton(snap)).getAddresses(startAddr, true);
+			refs.getReferenceSources(Lifespan.at(snap)).getAddresses(startAddr, true);
 		return NestedIterator.start(addresses, a -> {
 			return refs.getReferencesFrom(snap, a).iterator();
 		});
@@ -303,7 +302,7 @@ public abstract class AbstractDBTraceProgramViewReferenceManager implements Refe
 			return new EmptyAddressIterator();
 		}
 		return program.viewport.unionedAddresses(
-			s -> refs.getReferenceSources(Range.singleton(s))).getAddresses(startAddr, forward);
+			s -> refs.getReferenceSources(Lifespan.at(s))).getAddresses(startAddr, forward);
 	}
 
 	@Override
@@ -312,7 +311,7 @@ public abstract class AbstractDBTraceProgramViewReferenceManager implements Refe
 			return new EmptyAddressIterator();
 		}
 		return new IntersectionAddressSetView(addrSet, program.viewport.unionedAddresses(
-			s -> refs.getReferenceSources(Range.singleton(s)))).getAddresses(forward);
+			s -> refs.getReferenceSources(Lifespan.at(s)))).getAddresses(forward);
 	}
 
 	@Override
@@ -321,7 +320,7 @@ public abstract class AbstractDBTraceProgramViewReferenceManager implements Refe
 			return new EmptyAddressIterator();
 		}
 		return program.viewport.unionedAddresses(
-			s -> refs.getReferenceDestinations(Range.singleton(s)))
+			s -> refs.getReferenceDestinations(Lifespan.at(s)))
 				.getAddresses(startAddr, forward);
 	}
 
@@ -332,7 +331,7 @@ public abstract class AbstractDBTraceProgramViewReferenceManager implements Refe
 			return new EmptyAddressIterator();
 		}
 		return new IntersectionAddressSetView(addrSet, program.viewport.unionedAddresses(
-			s -> refs.getReferenceDestinations(Range.singleton(s)))).getAddresses(forward);
+			s -> refs.getReferenceDestinations(Lifespan.at(s)))).getAddresses(forward);
 	}
 
 	@Override
@@ -365,7 +364,7 @@ public abstract class AbstractDBTraceProgramViewReferenceManager implements Refe
 			return 0;
 		}
 		return (int) program.viewport
-				.unionedAddresses(s -> refs.getReferenceDestinations(Range.singleton(s)))
+				.unionedAddresses(s -> refs.getReferenceDestinations(Lifespan.at(s)))
 				.getNumAddresses();
 	}
 
@@ -377,7 +376,7 @@ public abstract class AbstractDBTraceProgramViewReferenceManager implements Refe
 			return 0;
 		}
 		return (int) program.viewport
-				.unionedAddresses(s -> refs.getReferenceSources(Range.singleton(s)))
+				.unionedAddresses(s -> refs.getReferenceSources(Lifespan.at(s)))
 				.getNumAddresses();
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/DBTraceProgramView.java

@@ -24,8 +24,6 @@ import java.util.function.BiFunction;
 
 import org.apache.commons.lang3.tuple.Pair;
 
-import com.google.common.collect.Range;
-
 import ghidra.framework.data.DomainObjectEventQueues;
 import ghidra.framework.model.*;
 import ghidra.framework.options.Options;
@@ -215,7 +213,7 @@ public class DBTraceProgramView implements TraceProgramView {
 		}
 
 		private void bookmarkLifespanChanged(TraceAddressSpace space, TraceBookmark bm,
-				Range<Long> oldSpan, Range<Long> newSpan) {
+				Lifespan oldSpan, Lifespan newSpan) {
 			DomainObjectEventQueues queues = getEventQueues(space);
 			if (queues == null) {
 				return;
@@ -284,7 +282,7 @@ public class DBTraceProgramView implements TraceProgramView {
 		}
 
 		private void codeLifespanChanged(TraceAddressSpace space, TraceCodeUnit unit,
-				Range<Long> oldSpan, Range<Long> newSpan) {
+				Lifespan oldSpan, Lifespan newSpan) {
 			DomainObjectEventQueues queues = getEventQueues(space);
 			if (queues == null) {
 				return;
@@ -400,7 +398,7 @@ public class DBTraceProgramView implements TraceProgramView {
 		}
 
 		private void compositeLifespanChanged(TraceAddressSpace space, TraceData data,
-				Range<Long> oldSpan, Range<Long> newSpan) {
+				Lifespan oldSpan, Lifespan newSpan) {
 			DomainObjectEventQueues queues = getEventQueues(space);
 			if (queues == null) {
 				return;
@@ -621,7 +619,7 @@ public class DBTraceProgramView implements TraceProgramView {
 		}
 
 		private void memoryRegionLifespanChanged(TraceAddressSpace space, TraceMemoryRegion region,
-				Range<Long> oldSpan, Range<Long> newSpan) {
+				Lifespan oldSpan, Lifespan newSpan) {
 			boolean inOld = isRegionVisible(region, oldSpan);
 			boolean inNew = isRegionVisible(region, newSpan);
 			if (inOld && !inNew) {
@@ -788,7 +786,7 @@ public class DBTraceProgramView implements TraceProgramView {
 		}
 
 		private void symbolLifespanChanged(TraceAddressSpace space, TraceSymbolWithLifespan symbol,
-				Range<Long> oldSpan, Range<Long> newSpan) {
+				Lifespan oldSpan, Lifespan newSpan) {
 			DomainObjectEventQueues queues = getEventQueues(space);
 			if (queues == null) {
 				return;
@@ -1589,7 +1587,7 @@ public class DBTraceProgramView implements TraceProgramView {
 		memory.updateChangeRegionBlockName(region);
 	}
 
-	public void updateMemoryChangeRegionBlockFlags(TraceMemoryRegion region, Range<Long> lifespan) {
+	public void updateMemoryChangeRegionBlockFlags(TraceMemoryRegion region, Lifespan lifespan) {
 		if (!isRegionVisible(region, lifespan)) {
 			return;
 		}
@@ -1605,7 +1603,7 @@ public class DBTraceProgramView implements TraceProgramView {
 	}
 
 	public void updateMemoryChangeRegionBlockLifespan(TraceMemoryRegion region,
-			Range<Long> oldLifespan, Range<Long> newLifespan) {
+			Lifespan oldLifespan, Lifespan newLifespan) {
 		boolean inOld = isRegionVisible(region, oldLifespan);
 		boolean inNew = isRegionVisible(region, newLifespan);
 		if (inOld && !inNew) {
@@ -1660,7 +1658,7 @@ public class DBTraceProgramView implements TraceProgramView {
 		return viewport.containsAnyUpper(range.getLifespan()) ? getEventQueues(space) : null;
 	}
 
-	protected boolean isBookmarkVisible(TraceBookmark bm, Range<Long> lifespan) {
+	protected boolean isBookmarkVisible(TraceBookmark bm, Lifespan lifespan) {
 		return viewport.containsAnyUpper(lifespan);
 	}
 
@@ -1687,7 +1685,7 @@ public class DBTraceProgramView implements TraceProgramView {
 			final DBTraceDefinedUnitsView definedUnits =
 				codeSpace == null ? null : codeSpace.definedUnits();
 
-			public boolean occluded(TraceCodeUnit cu, AddressRange range, Range<Long> span) {
+			public boolean occluded(TraceCodeUnit cu, AddressRange range, Lifespan span) {
 				if (cu == null) {
 					return RangeQueryOcclusion.super.occluded(cu, range, span);
 				}
@@ -1697,7 +1695,7 @@ public class DBTraceProgramView implements TraceProgramView {
 					return RangeQueryOcclusion.super.occluded(cu, range, span);
 				}
 				byte[] memBytes = new byte[cu.getLength()];
-				memSpace.getBytes(span.upperEndpoint(), cu.getMinAddress(),
+				memSpace.getBytes(span.lmax(), cu.getMinAddress(),
 					ByteBuffer.wrap(memBytes));
 				byte[] cuBytes;
 				try {
@@ -1715,10 +1713,10 @@ public class DBTraceProgramView implements TraceProgramView {
 			}
 
 			@Override
-			public Iterable<? extends TraceCodeUnit> query(AddressRange range, Range<Long> span) {
+			public Iterable<? extends TraceCodeUnit> query(AddressRange range, Lifespan span) {
 				return definedUnits == null
 						? Collections.emptyList()
-						: definedUnits.get(span.upperEndpoint(), range, true);
+						: definedUnits.get(span.lmax(), range, true);
 			}
 
 			@Override
@@ -1744,7 +1742,7 @@ public class DBTraceProgramView implements TraceProgramView {
 		});
 	}
 
-	protected boolean isCodeVisible(TraceCodeUnit cu, Range<Long> lifespan) {
+	protected boolean isCodeVisible(TraceCodeUnit cu, Lifespan lifespan) {
 		return viewport.isCompletelyVisible(cu.getRange(), lifespan, cu,
 			getCodeOcclusion(cu.getTraceSpace()));
 	}
@@ -1768,9 +1766,9 @@ public class DBTraceProgramView implements TraceProgramView {
 
 			@Override
 			public Iterable<? extends TraceFunctionSymbol> query(AddressRange range,
-					Range<Long> span) {
+					Lifespan span) {
 				// NB. No functions in register space!
-				return functions.getIntersecting(Range.singleton(span.upperEndpoint()), null, range,
+				return functions.getIntersecting(Lifespan.at(span.lmax()), null, range,
 					false);
 			}
 
@@ -1785,7 +1783,7 @@ public class DBTraceProgramView implements TraceProgramView {
 		};
 	}
 
-	protected boolean isFunctionVisible(TraceFunctionSymbol function, Range<Long> lifespan) {
+	protected boolean isFunctionVisible(TraceFunctionSymbol function, Lifespan lifespan) {
 		AddressSetView body = function.getBody();
 		AddressRange bodySpan =
 			new AddressRangeImpl(body.getMinAddress(), body.getMaxAddress());
@@ -1803,7 +1801,7 @@ public class DBTraceProgramView implements TraceProgramView {
 	}
 
 	protected boolean isSymbolWithLifespanVisible(TraceSymbolWithLifespan symbol,
-			Range<Long> lifespan) {
+			Lifespan lifespan) {
 		if (symbol instanceof TraceFunctionSymbol) {
 			TraceFunctionSymbol func = (TraceFunctionSymbol) symbol;
 			return isFunctionVisible(func, lifespan);
@@ -1851,9 +1849,9 @@ public class DBTraceProgramView implements TraceProgramView {
 
 	protected Occlusion<TraceMemoryRegion> regionOcclusion = new RangeQueryOcclusion<>() {
 		@Override
-		public Iterable<? extends TraceMemoryRegion> query(AddressRange range, Range<Long> span) {
+		public Iterable<? extends TraceMemoryRegion> query(AddressRange range, Lifespan span) {
 			return trace.getMemoryManager()
-					.getRegionsIntersecting(Range.singleton(span.upperEndpoint()), range);
+					.getRegionsIntersecting(Lifespan.at(span.lmax()), range);
 		}
 
 		@Override
@@ -1866,7 +1864,7 @@ public class DBTraceProgramView implements TraceProgramView {
 		return isRegionVisible(reg, reg.getLifespan());
 	}
 
-	protected boolean isRegionVisible(TraceMemoryRegion reg, Range<Long> lifespan) {
+	protected boolean isRegionVisible(TraceMemoryRegion reg, Lifespan lifespan) {
 		return viewport.isCompletelyVisible(reg.getRange(), lifespan, reg,
 			regionOcclusion);
 	}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/DBTraceProgramViewBookmarkManager.java

@@ -24,14 +24,13 @@ import javax.swing.ImageIcon;
 import org.apache.commons.collections4.IteratorUtils;
 
 import com.google.common.collect.Iterators;
-import com.google.common.collect.Range;
 
 import generic.NestedIterator;
 import ghidra.program.model.address.*;
 import ghidra.program.model.listing.Bookmark;
 import ghidra.program.model.listing.BookmarkType;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.bookmark.*;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.bookmark.*;
 import ghidra.trace.model.program.TraceProgramView;
@@ -85,7 +84,7 @@ public class DBTraceProgramViewBookmarkManager implements TraceProgramViewBookma
 			TraceBookmarkSpace space =
 				bookmarkManager.getBookmarkSpace(addr.getAddressSpace(), true);
 			// TODO: How to let user modify time? I think by deletion at a later snap....
-			return space.addBookmark(Range.atLeast(program.snap), addr, bmt, category, comment);
+			return space.addBookmark(Lifespan.nowOn(program.snap), addr, bmt, category, comment);
 		}
 	}
 
@@ -113,15 +112,15 @@ public class DBTraceProgramViewBookmarkManager implements TraceProgramViewBookma
 	}
 
 	protected void doDeleteOrTruncateLifespan(TraceBookmark bm) {
-		Range<Long> lifespan = bm.getLifespan();
+		Lifespan lifespan = bm.getLifespan();
 		if (!lifespan.contains(program.snap)) {
 			throw new IllegalArgumentException("Given bookmark is not present at this view's snap");
 		}
-		if (DBTraceUtils.lowerEndpoint(lifespan) == program.snap) {
+		if (lifespan.lmin() == program.snap) {
 			bm.delete();
 		}
 		else {
-			bm.setLifespan(lifespan.intersection(Range.lessThan(program.snap)));
+			bm.setLifespan(lifespan.intersect(Lifespan.before(program.snap)));
 		}
 	}
 
@@ -181,8 +180,8 @@ public class DBTraceProgramViewBookmarkManager implements TraceProgramViewBookma
 				if (space == null) {
 					continue;
 				}
-				for (TraceBookmark bm : space.getBookmarksIntersecting(
-					Range.closed(program.snap, program.snap), rng)) {
+				for (TraceBookmark bm : space.getBookmarksIntersecting(Lifespan.at(program.snap),
+					rng)) {
 					monitor.checkCanceled();
 					if (!bm.getLifespan().contains(program.snap)) {
 						continue;
@@ -336,7 +335,7 @@ public class DBTraceProgramViewBookmarkManager implements TraceProgramViewBookma
 				return Collections.emptyIterator();
 			}
 			return program.viewport.mergedIterator(
-				s -> space.getBookmarksIntersecting(Range.closed(s, s), rng).iterator(),
+				s -> space.getBookmarksIntersecting(Lifespan.at(s), rng).iterator(),
 				getBookmarkComparator(forward));
 		});
 	}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/DBTraceProgramViewEquate.java

@@ -18,13 +18,12 @@ package ghidra.trace.database.program;
 import java.util.Collection;
 import java.util.List;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.Address;
 import ghidra.program.model.data.Enum;
 import ghidra.program.model.symbol.Equate;
 import ghidra.program.model.symbol.EquateReference;
 import ghidra.trace.database.symbol.DBTraceEquate;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.symbol.TraceEquateReference;
 import ghidra.util.UniversalID;
 import ghidra.util.exception.DuplicateNameException;
@@ -66,7 +65,7 @@ public class DBTraceProgramViewEquate implements Equate {
 
 	@Override
 	public void addReference(Address refAddr, int opndPosition) {
-		equate.addReference(Range.atLeast(program.snap), null, refAddr, opndPosition);
+		equate.addReference(Lifespan.nowOn(program.snap), null, refAddr, opndPosition);
 	}
 
 	@Override

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/DBTraceProgramViewEquateTable.java

@@ -20,13 +20,13 @@ import java.util.*;
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.RemovalNotification;
 import com.google.common.collect.Iterators;
-import com.google.common.collect.Range;
 
 import ghidra.program.model.address.*;
 import ghidra.program.model.symbol.Equate;
 import ghidra.program.model.symbol.EquateTable;
 import ghidra.trace.database.symbol.DBTraceEquate;
 import ghidra.trace.database.symbol.DBTraceEquateManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.listing.TraceCodeUnit;
 import ghidra.util.IntersectionAddressSetView;
 import ghidra.util.LockHold;
@@ -77,7 +77,7 @@ public class DBTraceProgramViewEquateTable implements EquateTable {
 	@Override
 	public void deleteAddressRange(Address start, Address end, TaskMonitor monitor)
 			throws CancelledException {
-		equateManager.clearReferences(Range.atLeast(program.snap), new AddressRangeImpl(start, end),
+		equateManager.clearReferences(Lifespan.nowOn(program.snap), new AddressRangeImpl(start, end),
 			monitor);
 	}
 
@@ -144,7 +144,7 @@ public class DBTraceProgramViewEquateTable implements EquateTable {
 	@Override
 	public AddressIterator getEquateAddresses() {
 		return program.viewport
-				.unionedAddresses(s -> equateManager.getReferringAddresses(Range.singleton(s)))
+				.unionedAddresses(s -> equateManager.getReferringAddresses(Lifespan.at(s)))
 				.getAddresses(true);
 	}
 
@@ -167,14 +167,14 @@ public class DBTraceProgramViewEquateTable implements EquateTable {
 	@Override
 	public AddressIterator getEquateAddresses(Address start) {
 		return program.viewport
-				.unionedAddresses(s -> equateManager.getReferringAddresses(Range.singleton(s)))
+				.unionedAddresses(s -> equateManager.getReferringAddresses(Lifespan.at(s)))
 				.getAddresses(start, true);
 	}
 
 	@Override
 	public AddressIterator getEquateAddresses(AddressSetView asv) {
 		return new IntersectionAddressSetView(asv, program.viewport
-				.unionedAddresses(s -> equateManager.getReferringAddresses(Range.singleton(s))))
+				.unionedAddresses(s -> equateManager.getReferringAddresses(Lifespan.at(s))))
 						.getAddresses(true);
 	}
 }

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/DBTraceProgramViewFunctionManager.java

@@ -21,8 +21,6 @@ import java.io.IOException;
 import java.util.Iterator;
 import java.util.List;
 
-import com.google.common.collect.Range;
-
 import generic.NestedIterator;
 import ghidra.program.database.ProgramDB;
 import ghidra.program.database.function.OverlappingFunctionException;
@@ -33,6 +31,7 @@ import ghidra.program.model.symbol.Namespace;
 import ghidra.program.model.symbol.SourceType;
 import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.symbol.*;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.listing.TraceData;
 import ghidra.trace.model.symbol.TraceFunctionSymbol;
 import ghidra.trace.util.EmptyFunctionIterator;
@@ -193,7 +192,7 @@ public class DBTraceProgramViewFunctionManager implements FunctionManager {
 
 	protected Iterator<? extends DBTraceFunctionSymbol> getFunctionsInRange(AddressRange range,
 			boolean forward) {
-		return functions.getIntersecting(Range.singleton(program.snap), null, range, false,
+		return functions.getIntersecting(Lifespan.at(program.snap), null, range, false,
 			forward).iterator();
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/DBTraceProgramViewListing.java

@@ -15,9 +15,8 @@
  */
 package ghidra.trace.database.program;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.*;
+import ghidra.trace.model.Lifespan;
 import ghidra.util.LockHold;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;
@@ -53,8 +52,7 @@ public class DBTraceProgramViewListing extends AbstractDBTraceProgramViewListing
 						endAddr)) {
 				monitor.checkCanceled();
 				codeOperations.definedUnits()
-						.clear(Range.closed(program.snap, program.snap), range,
-							clearContext, monitor);
+						.clear(Lifespan.at(program.snap), range, clearContext, monitor);
 			}
 		}
 	}
@@ -65,8 +63,7 @@ public class DBTraceProgramViewListing extends AbstractDBTraceProgramViewListing
 		try (LockHold hold = program.trace.lockRead()) {
 			for (AddressRange range : allMemory) {
 				codeOperations.definedUnits()
-						.clear(Range.closed(program.snap, program.snap), range,
-							clearContext, monitor);
+						.clear(Lifespan.at(program.snap), range, clearContext, monitor);
 			}
 		}
 		catch (CancelledException e) {

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/DBTraceProgramViewProgramContext.java

@@ -20,8 +20,6 @@ import java.util.*;
 import java.util.Map.Entry;
 import java.util.function.Function;
 
-import com.google.common.collect.Range;
-
 import generic.NestedIterator;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.*;
@@ -29,6 +27,7 @@ import ghidra.program.model.listing.ContextChangeException;
 import ghidra.program.model.listing.ProgramContext;
 import ghidra.program.util.AbstractProgramContext;
 import ghidra.trace.database.context.DBTraceRegisterContextManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.util.LockHold;
 
@@ -95,7 +94,7 @@ public class DBTraceProgramViewProgramContext extends AbstractProgramContext {
 	@Override
 	public void setRegisterValue(Address start, Address end, RegisterValue value)
 			throws ContextChangeException {
-		registerContextManager.setValue(language, value, Range.atLeast(program.snap),
+		registerContextManager.setValue(language, value, Lifespan.nowOn(program.snap),
 			new AddressRangeImpl(start, end));
 	}
 
@@ -177,7 +176,7 @@ public class DBTraceProgramViewProgramContext extends AbstractProgramContext {
 	public void remove(Address start, Address end, Register register)
 			throws ContextChangeException {
 		try (LockHold hold = program.trace.lockWrite()) {
-			Range<Long> span = Range.closed(program.snap, program.snap);
+			Lifespan span = Lifespan.at(program.snap);
 			for (AddressRange range : language.getAddressFactory().getAddressSet(start, end)) {
 				registerContextManager.removeValue(language, register, span, range);
 			}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/DBTraceProgramViewPropertyMapManager.java

@@ -17,11 +17,9 @@ package ghidra.trace.database.program;
 
 import java.util.Iterator;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.*;
 import ghidra.program.model.util.*;
-import ghidra.trace.database.DBTraceUtils;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.property.TracePropertyMap;
 import ghidra.util.LockHold;
 import ghidra.util.Saveable;
@@ -47,7 +45,7 @@ public class DBTraceProgramViewPropertyMapManager implements PropertyMapManager
 		}
 
 		protected AddressSetView getAddressSetView() {
-			return map.getAddressSetView(Range.singleton(program.snap));
+			return map.getAddressSetView(Lifespan.at(program.snap));
 		}
 
 		@Override
@@ -62,9 +60,9 @@ public class DBTraceProgramViewPropertyMapManager implements PropertyMapManager
 
 		@Override
 		public boolean removeRange(Address start, Address end) {
-			return map.clear(Range.singleton(program.snap), new AddressRangeImpl(start, end));
+			return map.clear(Lifespan.at(program.snap), new AddressRangeImpl(start, end));
 		}
-
+	
 		@Override
 		public boolean remove(Address addr) {
 			return removeRange(addr, addr);
@@ -174,7 +172,7 @@ public class DBTraceProgramViewPropertyMapManager implements PropertyMapManager
 
 		@Override
 		public void add(Address addr, int value) {
-			map.set(DBTraceUtils.atLeastMaybeScratch(program.snap), addr, value);
+			map.set(Lifespan.nowOnMaybeScratch(program.snap), addr, value);
 		}
 
 		@Override
@@ -196,7 +194,7 @@ public class DBTraceProgramViewPropertyMapManager implements PropertyMapManager
 
 		@Override
 		public void add(Address addr, long value) {
-			map.set(DBTraceUtils.atLeastMaybeScratch(program.snap), addr, value);
+			map.set(Lifespan.nowOnMaybeScratch(program.snap), addr, value);
 		}
 
 		@Override
@@ -218,7 +216,7 @@ public class DBTraceProgramViewPropertyMapManager implements PropertyMapManager
 
 		@Override
 		public void add(Address addr, String value) {
-			map.set(DBTraceUtils.atLeastMaybeScratch(program.snap), addr, value);
+			map.set(Lifespan.nowOnMaybeScratch(program.snap), addr, value);
 		}
 
 		@Override
@@ -238,7 +236,7 @@ public class DBTraceProgramViewPropertyMapManager implements PropertyMapManager
 
 		@Override
 		public void add(Address addr, Saveable value) {
-			map.set(DBTraceUtils.atLeastMaybeScratch(program.snap), addr,
+			map.set(Lifespan.nowOnMaybeScratch(program.snap), addr,
 				map.getValueClass().cast(value));
 		}
 
@@ -257,7 +255,7 @@ public class DBTraceProgramViewPropertyMapManager implements PropertyMapManager
 
 		@Override
 		public void add(Address addr) {
-			map.set(DBTraceUtils.atLeastMaybeScratch(program.snap), addr, true);
+			map.set(Lifespan.nowOnMaybeScratch(program.snap), addr, true);
 		}
 	}
 
@@ -391,7 +389,7 @@ public class DBTraceProgramViewPropertyMapManager implements PropertyMapManager
 		return program.trace.getAddressPropertyManager().getAllProperties().keySet().iterator();
 	}
 
-	protected void removeAll(Range<Long> span, AddressRange range) {
+	protected void removeAll(Lifespan span, AddressRange range) {
 		try (LockHold hold = program.trace.lockWrite()) {
 			for (TracePropertyMap<?> map : program.trace.getAddressPropertyManager()
 					.getAllProperties()
@@ -403,13 +401,13 @@ public class DBTraceProgramViewPropertyMapManager implements PropertyMapManager
 
 	@Override
 	public void removeAll(Address addr) {
-		removeAll(DBTraceUtils.atLeastMaybeScratch(program.snap), new AddressRangeImpl(addr, addr));
+		removeAll(Lifespan.nowOnMaybeScratch(program.snap), new AddressRangeImpl(addr, addr));
 	}
 
 	@Override
 	public void removeAll(Address startAddr, Address endAddr, TaskMonitor monitor)
 			throws CancelledException {
-		removeAll(DBTraceUtils.atLeastMaybeScratch(program.snap),
+		removeAll(Lifespan.nowOnMaybeScratch(program.snap),
 			new AddressRangeImpl(startAddr, endAddr));
 	}
 }

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/DBTraceProgramViewRegisterListing.java

@@ -15,11 +15,10 @@
  */
 package ghidra.trace.database.program;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.*;
 import ghidra.trace.database.listing.DBTraceCodeSpace;
 import ghidra.trace.database.listing.UndefinedDBTraceData;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.program.TraceProgramViewRegisterListing;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.util.exception.CancelledException;
@@ -54,16 +53,15 @@ public class DBTraceProgramViewRegisterListing extends AbstractDBTraceProgramVie
 	@Override
 	public boolean isUndefined(Address start, Address end) {
 		return codeOperations.undefinedData()
-				.coversRange(Range.closed(program.snap, program.snap),
-					new AddressRangeImpl(start, end));
+				.coversRange(Lifespan.at(program.snap), new AddressRangeImpl(start, end));
 	}
 
 	@Override
 	public void clearCodeUnits(Address startAddr, Address endAddr, boolean clearContext,
 			TaskMonitor monitor) throws CancelledException {
 		codeOperations.definedUnits()
-				.clear(Range.closed(program.snap, program.snap),
-					new AddressRangeImpl(startAddr, endAddr), clearContext, monitor);
+				.clear(Lifespan.at(program.snap), new AddressRangeImpl(startAddr, endAddr),
+					clearContext, monitor);
 	}
 
 	@Override
@@ -71,8 +69,8 @@ public class DBTraceProgramViewRegisterListing extends AbstractDBTraceProgramVie
 	public void clearAll(boolean clearContext, TaskMonitor monitor) {
 		try {
 			codeOperations.definedUnits()
-					.clear(Range.closed(program.snap, program.snap),
-						new AddressRangeImpl(minAddr, maxAddr), clearContext, monitor);
+					.clear(Lifespan.at(program.snap), new AddressRangeImpl(minAddr, maxAddr),
+						clearContext, monitor);
 		}
 		catch (CancelledException e) {
 			// This whole method is supposed to go away, anyway

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/DBTraceProgramViewSymbolTable.java

@@ -18,7 +18,6 @@ package ghidra.trace.database.program;
 import java.util.*;
 
 import com.google.common.collect.Iterators;
-import com.google.common.collect.Range;
 
 import generic.NestedIterator;
 import generic.util.PeekableIterator;
@@ -27,6 +26,7 @@ import ghidra.program.model.listing.*;
 import ghidra.program.model.symbol.*;
 import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.symbol.*;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.symbol.*;
 import ghidra.util.*;
 import ghidra.util.exception.*;
@@ -355,14 +355,12 @@ public class DBTraceProgramViewSymbolTable implements SymbolTable {
 			if (range.getAddressSpace().isMemorySpace()) {
 				if (type == SymbolType.LABEL) {
 					return symbolManager.labels()
-							.getIntersecting(Range.singleton(program.snap),
-								null, range, true, forward)
+							.getIntersecting(Lifespan.at(program.snap), null, range, true, forward)
 							.iterator();
 				}
 				if (type == SymbolType.FUNCTION) {
 					return symbolManager.functions()
-							.getIntersecting(Range.singleton(program.snap),
-								null, range, true, forward)
+							.getIntersecting(Lifespan.at(program.snap), null, range, true, forward)
 							.iterator();
 				}
 			}
@@ -392,7 +390,7 @@ public class DBTraceProgramViewSymbolTable implements SymbolTable {
 			boolean includeDynamicSymbols, boolean forward) {
 		Iterator<AddressRange> rit = asv.iterator(forward);
 		Iterator<Iterator<? extends Symbol>> iit = Iterators.transform(rit, range -> {
-			return view.getIntersecting(Range.singleton(program.snap), null, range,
+			return view.getIntersecting(Lifespan.at(program.snap), null, range,
 				includeDynamicSymbols, forward).iterator();
 		});
 		return Iterators.concat(iit);
@@ -452,8 +450,7 @@ public class DBTraceProgramViewSymbolTable implements SymbolTable {
 	public SymbolIterator getPrimarySymbolIterator(AddressSetView asv, boolean forward) {
 		return new PrimarySymbolIterator(NestedIterator.start(asv.iterator(forward),
 			range -> symbolManager.labelsAndFunctions()
-					.getIntersecting(
-						Range.singleton(program.snap), null, range, true, forward)
+					.getIntersecting(Lifespan.at(program.snap), null, range, true, forward)
 					.iterator()));
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/stack/DBTraceObjectStack.java

@@ -19,13 +19,12 @@ import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.target.TargetStackFrame;
 import ghidra.dbg.target.schema.TargetObjectSchema;
 import ghidra.dbg.util.*;
 import ghidra.trace.database.target.DBTraceObject;
 import ghidra.trace.database.target.DBTraceObjectInterface;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceStackChangeType;
 import ghidra.trace.model.stack.*;
 import ghidra.trace.model.target.TraceObject;
@@ -48,7 +47,7 @@ public class DBTraceObjectStack implements TraceObjectStack, DBTraceObjectInterf
 		}
 
 		@Override
-		protected TraceChangeType<TraceStack, Range<Long>> getLifespanChangedType() {
+		protected TraceChangeType<TraceStack, Lifespan> getLifespanChangedType() {
 			return null;
 		}
 
@@ -183,7 +182,7 @@ public class DBTraceObjectStack implements TraceObjectStack, DBTraceObjectInterf
 		PathPredicates matcher = schema.searchFor(TargetStackFrame.class, true);
 		PathPredicates decMatcher = matcher.applyKeys(PathUtils.makeIndex(level));
 		PathPredicates hexMatcher = matcher.applyKeys("0x" + Integer.toHexString(level));
-		Range<Long> span = computeSpan();
+		Lifespan span = computeSpan();
 		return object.getSuccessors(span, decMatcher)
 				.findAny()
 				.map(p -> p.getDestination(object).queryInterface(TraceObjectStackFrame.class))
@@ -212,7 +211,7 @@ public class DBTraceObjectStack implements TraceObjectStack, DBTraceObjectInterf
 
 	protected Stream<TraceObjectStackFrame> doGetFrames(long snap) {
 		return object
-				.querySuccessorsInterface(Range.singleton(snap), TraceObjectStackFrame.class)
+				.querySuccessorsInterface(Lifespan.at(snap), TraceObjectStackFrame.class)
 				.sorted(Comparator.comparing(f -> f.getLevel()));
 	}
 

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/stack/DBTraceObjectStackFrame.java

@@ -17,15 +17,15 @@ package ghidra.trace.database.stack;
 
 import java.util.List;
 
-import com.google.common.collect.*;
-
 import ghidra.dbg.target.TargetStackFrame;
 import ghidra.dbg.util.PathUtils;
 import ghidra.program.model.address.Address;
 import ghidra.program.model.listing.CodeUnit;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.target.DBTraceObject;
 import ghidra.trace.database.target.DBTraceObjectInterface;
+import ghidra.trace.model.Lifespan;
+import ghidra.trace.model.Lifespan.DefaultLifeSet;
+import ghidra.trace.model.Lifespan.LifeSet;
 import ghidra.trace.model.Trace.TraceObjectChangeType;
 import ghidra.trace.model.Trace.TraceStackChangeType;
 import ghidra.trace.model.stack.TraceObjectStack;
@@ -40,7 +40,7 @@ public class DBTraceObjectStackFrame implements TraceObjectStackFrame, DBTraceOb
 	private final DBTraceObject object;
 	// TODO: Memorizing life is not optimal.
 	// GP-1887 means to expose multiple lifespans in, e.g., TraceThread
-	private RangeSet<Long> life = TreeRangeSet.create();
+	private LifeSet life = new DefaultLifeSet();
 
 	public DBTraceObjectStackFrame(DBTraceObject object) {
 		this.object = object;
@@ -82,7 +82,7 @@ public class DBTraceObjectStackFrame implements TraceObjectStackFrame, DBTraceOb
 	}
 
 	@Override
-	public void setProgramCounter(Range<Long> span, Address pc) {
+	public void setProgramCounter(Lifespan span, Address pc) {
 		try (LockHold hold = object.getTrace().lockWrite()) {
 			if (pc == Address.NO_ADDRESS) {
 				pc = null;
@@ -146,8 +146,8 @@ public class DBTraceObjectStackFrame implements TraceObjectStackFrame, DBTraceOb
 	}
 
 	@Override
-	public Range<Long> computeSpan() {
-		Range<Long> span = DBTraceObjectInterface.super.computeSpan();
+	public Lifespan computeSpan() {
+		Lifespan span = DBTraceObjectInterface.super.computeSpan();
 		if (span != null) {
 			return span;
 		}
@@ -163,14 +163,14 @@ public class DBTraceObjectStackFrame implements TraceObjectStackFrame, DBTraceOb
 
 	protected TraceChangeRecord<?, ?> createChangeRecord() {
 		return new TraceChangeRecord<>(TraceStackChangeType.CHANGED, null, getStack(), 0L,
-			DBTraceUtils.lowerEndpoint(life.span()));
+			life.bound().lmin());
 	}
 
 	@Override
 	public TraceChangeRecord<?, ?> translateEvent(TraceChangeRecord<?, ?> rec) {
 		int type = rec.getEventType();
 		if (type == TraceObjectChangeType.LIFE_CHANGED.getType()) {
-			RangeSet<Long> newLife = object.getLife();
+			LifeSet newLife = object.getLife();
 			if (!newLife.isEmpty()) {
 				life = newLife;
 			}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/stack/DBTraceStackFrame.java

@@ -18,14 +18,13 @@ package ghidra.trace.database.stack;
 import java.io.IOException;
 import java.util.Objects;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.lifecycle.Internal;
 import ghidra.program.model.address.Address;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter.AddressDBFieldCodec;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter.DecodesAddresses;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceStackChangeType;
 import ghidra.trace.model.stack.TraceStackFrame;
 import ghidra.trace.util.TraceChangeRecord;
@@ -119,7 +118,7 @@ public class DBTraceStackFrame extends DBAnnotatedObject
 	}
 
 	@Override
-	public void setProgramCounter(Range<Long> span, Address pc) {
+	public void setProgramCounter(Lifespan span, Address pc) {
 		//System.err.println("setPC(threadKey=" + stack.getThread().getKey() + ",snap=" +
 		//	stack.getSnap() + ",level=" + level + ",pc=" + pc + ");");
 		manager.trace.assertValidAddress(pc);

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/stack/DBTraceStackManager.java

@@ -19,8 +19,6 @@ import java.io.IOException;
 import java.util.List;
 import java.util.concurrent.locks.ReadWriteLock;
 
-import com.google.common.collect.Range;
-
 import db.DBHandle;
 import generic.NestedIterator;
 import ghidra.dbg.target.*;
@@ -32,6 +30,7 @@ import ghidra.trace.database.DBTraceManager;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter;
 import ghidra.trace.database.stack.DBTraceStack.ThreadSnap;
 import ghidra.trace.database.thread.DBTraceThreadManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceStackChangeType;
 import ghidra.trace.model.stack.*;
 import ghidra.trace.model.target.TraceObject;
@@ -189,7 +188,7 @@ public class DBTraceStackManager implements TraceStackManager, DBTraceManager {
 	public Iterable<TraceStackFrame> getFramesIn(AddressSetView set) {
 		if (trace.getObjectManager().hasSchema()) {
 			return () -> NestedIterator.start(set.iterator(), rng -> trace.getObjectManager()
-					.getObjectsIntersecting(Range.all(), rng, TargetStackFrame.PC_ATTRIBUTE_NAME,
+					.getObjectsIntersecting(Lifespan.ALL, rng, TargetStackFrame.PC_ATTRIBUTE_NAME,
 						TraceObjectStackFrame.class)
 					.iterator());
 		}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/AbstractDBTraceSymbol.java

@@ -23,7 +23,6 @@ import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
 
 import com.google.common.collect.Collections2;
-import com.google.common.collect.Range;
 
 import db.DBRecord;
 import generic.CatenatedCollection;
@@ -33,12 +32,12 @@ import ghidra.program.model.listing.Program;
 import ghidra.program.model.symbol.*;
 import ghidra.program.util.ProgramLocation;
 import ghidra.trace.database.DBTrace;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter.DecodesAddresses;
 import ghidra.trace.database.program.DBTraceProgramView;
 import ghidra.trace.database.symbol.DBTraceSymbolManager.DBTraceSymbolIDEntry;
 import ghidra.trace.database.symbol.DBTraceSymbolManager.MySymbolTypes;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceSymbolChangeType;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.symbol.TraceSymbol;
@@ -206,18 +205,18 @@ public abstract class AbstractDBTraceSymbol extends DBAnnotatedObject
 	}
 
 	// Internal
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		// TODO: Cache this computation and/or keep it as transient fields?
 		long min = Long.MAX_VALUE;
 		long max = Long.MIN_VALUE;
 		for (TraceAddressSnapRange range : getRanges()) {
-			min = Math.min(min, DBTraceUtils.lowerEndpoint(range.getLifespan()));
-			max = Math.min(max, DBTraceUtils.upperEndpoint(range.getLifespan()));
+			min = Math.min(min, range.getLifespan().lmin());
+			max = Math.min(max, range.getLifespan().lmax());
 		}
 		if (min > max) {
 			return null;
 		}
-		return DBTraceUtils.toRange(min, max);
+		return Lifespan.span(min, max);
 	}
 
 	protected void doCollectAddressSet(AddressSet set) {

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/AbstractDBTraceSymbolSingleTypeWithLocationView.java

@@ -21,7 +21,6 @@ import java.util.Map.Entry;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 
 import com.google.common.collect.Collections2;
-import com.google.common.collect.Range;
 
 import ghidra.program.model.address.*;
 import ghidra.program.model.symbol.Namespace;
@@ -31,6 +30,7 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapSpace;
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
 import ghidra.trace.database.space.DBTraceSpaceKey;
 import ghidra.trace.database.symbol.DBTraceSymbolManager.DBTraceSymbolIDEntry;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.symbol.TraceNamespaceSymbol;
 import ghidra.trace.model.symbol.TraceSymbolManager;
@@ -121,7 +121,7 @@ public abstract class AbstractDBTraceSymbolSingleTypeWithLocationView<T extends
 		protected Collection<? extends T> doGetContaining(GetSymbolsKey key) {
 			if (key.thread != null) {
 				List<T> result =
-					new ArrayList<>(getIntersecting(Range.singleton(key.snap), key.thread,
+					new ArrayList<>(getIntersecting(Lifespan.at(key.snap), key.thread,
 						new AddressRangeImpl(key.addr, key.addr), key.includeDynamic, true));
 				result.sort(TraceSymbolManager.PRIMALITY_COMPARATOR);
 				return result;
@@ -144,7 +144,7 @@ public abstract class AbstractDBTraceSymbolSingleTypeWithLocationView<T extends
 		try (LockHold hold = LockHold.lock(manager.lock.readLock())) {
 			DBTraceNamespaceSymbol dbnsParent = manager.assertIsMine((Namespace) parent);
 			// TODO: Does this include dynamic symbols?
-			for (T symbol : getIntersecting(Range.closed(snap, snap), thread,
+			for (T symbol : getIntersecting(Lifespan.at(snap), thread,
 				new AddressRangeImpl(address, address), false, true)) {
 				if (symbol.parentID != dbnsParent.getID()) {
 					continue;
@@ -189,7 +189,7 @@ public abstract class AbstractDBTraceSymbolSingleTypeWithLocationView<T extends
 	 * @param includeDynamicSymbols
 	 * @return
 	 */
-	public Collection<? extends T> getIntersecting(Range<Long> span, TraceThread thread,
+	public Collection<? extends T> getIntersecting(Lifespan span, TraceThread thread,
 			AddressRange range, boolean includeDynamicSymbols) {
 		try (LockHold hold = LockHold.lock(manager.lock.readLock())) {
 			manager.trace.getThreadManager().assertIsMine(thread);
@@ -209,7 +209,7 @@ public abstract class AbstractDBTraceSymbolSingleTypeWithLocationView<T extends
 		}
 	}
 
-	public Collection<? extends T> getIntersecting(Range<Long> span, TraceThread thread,
+	public Collection<? extends T> getIntersecting(Lifespan span, TraceThread thread,
 			AddressRange range, boolean includeDynamicSymbols, boolean forward) {
 		try (LockHold hold = LockHold.lock(manager.lock.readLock())) {
 			manager.trace.getThreadManager().assertIsMine(thread);

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceEquate.java

@@ -18,13 +18,12 @@ package ghidra.trace.database.symbol;
 import java.util.Collection;
 import java.util.List;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.program.model.address.Address;
 import ghidra.program.model.data.Enum;
 import ghidra.program.model.pcode.Varnode;
 import ghidra.program.model.symbol.EquateReference;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.symbol.TraceEquate;
 import ghidra.trace.model.symbol.TraceEquateReference;
 import ghidra.trace.model.thread.TraceThread;
@@ -91,14 +90,14 @@ public class DBTraceEquate extends DBAnnotatedObject implements TraceEquate {
 	}
 
 	@Override
-	public TraceEquateReference addReference(Range<Long> lifespan, TraceThread thread,
+	public TraceEquateReference addReference(Lifespan lifespan, TraceThread thread,
 			Address address, int operandIndex) {
 		// TODO Auto-generated method stub
 		return null;
 	}
 
 	@Override
-	public TraceEquateReference addReference(Range<Long> lifespan, TraceThread thread,
+	public TraceEquateReference addReference(Lifespan lifespan, TraceThread thread,
 			Address address, Varnode varnode) {
 		// TODO Auto-generated method stub
 		return null;

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceEquateManager.java

@@ -22,7 +22,6 @@ import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReadWriteLock;
 
 import com.google.common.collect.Collections2;
-import com.google.common.collect.Range;
 
 import db.DBHandle;
 import ghidra.program.model.address.*;
@@ -31,6 +30,7 @@ import ghidra.trace.database.DBTrace;
 import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager;
 import ghidra.trace.database.space.DBTraceDelegatingManager;
 import ghidra.trace.database.thread.DBTraceThreadManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.stack.TraceStackFrame;
 import ghidra.trace.model.symbol.TraceEquateManager;
 import ghidra.trace.model.thread.TraceThread;
@@ -163,13 +163,13 @@ public class DBTraceEquateManager extends AbstractDBTraceSpaceBasedManager<DBTra
 	}
 
 	@Override
-	public AddressSetView getReferringAddresses(Range<Long> span) {
+	public AddressSetView getReferringAddresses(Lifespan span) {
 		return new UnionAddressSetView(
 			Collections2.transform(memSpacesView, m -> m.getReferringAddresses(span)));
 	}
 
 	@Override
-	public void clearReferences(Range<Long> span, AddressSetView asv, TaskMonitor monitor)
+	public void clearReferences(Lifespan span, AddressSetView asv, TaskMonitor monitor)
 			throws CancelledException {
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
 			for (AddressRange range : asv) {
@@ -179,7 +179,7 @@ public class DBTraceEquateManager extends AbstractDBTraceSpaceBasedManager<DBTra
 	}
 
 	@Override
-	public void clearReferences(Range<Long> span, AddressRange range, TaskMonitor monitor)
+	public void clearReferences(Lifespan span, AddressRange range, TaskMonitor monitor)
 			throws CancelledException {
 		delegateDeleteV(range.getAddressSpace(), m -> m.clearReferences(span, range, monitor));
 	}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceEquateSpace.java

@@ -20,7 +20,6 @@ import java.util.Collection;
 import java.util.concurrent.locks.ReadWriteLock;
 
 import com.google.common.collect.Collections2;
-import com.google.common.collect.Range;
 
 import db.DBHandle;
 import db.DBRecord;
@@ -33,6 +32,7 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.Abstract
 import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
 import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager.DBTraceSpaceEntry;
 import ghidra.trace.database.space.DBTraceSpaceBased;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.symbol.TraceEquateSpace;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.util.LockHold;
@@ -93,7 +93,7 @@ public class DBTraceEquateSpace implements DBTraceSpaceBased, TraceEquateSpace {
 			return this;
 		}
 
-		protected void setLifespan(Range<Long> lifespan) {
+		protected void setLifespan(Lifespan lifespan) {
 			doSetLifespan(lifespan);
 		}
 	}
@@ -150,14 +150,14 @@ public class DBTraceEquateSpace implements DBTraceSpaceBased, TraceEquateSpace {
 	}
 
 	@Override
-	public AddressSetView getReferringAddresses(Range<Long> span) {
+	public AddressSetView getReferringAddresses(Lifespan span) {
 		return new DBTraceAddressSnapRangePropertyMapAddressSetView<>(space, lock,
 			equateMapSpace.reduce(TraceAddressSnapRangeQuery.intersecting(fullSpace, span)),
 			e -> true);
 	}
 
 	@Override
-	public void clearReferences(Range<Long> span, AddressSetView asv, TaskMonitor monitor)
+	public void clearReferences(Lifespan span, AddressSetView asv, TaskMonitor monitor)
 			throws CancelledException {
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
 			for (AddressRange range : asv) {
@@ -167,7 +167,7 @@ public class DBTraceEquateSpace implements DBTraceSpaceBased, TraceEquateSpace {
 	}
 
 	@Override
-	public void clearReferences(Range<Long> span, AddressRange range, TaskMonitor monitor)
+	public void clearReferences(Lifespan span, AddressRange range, TaskMonitor monitor)
 			throws CancelledException {
 		try (LockHold hold = LockHold.lock(lock.writeLock())) {
 			for (DBTraceEquateReference eref : equateMapSpace.reduce(

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceFunctionSymbol.java

@@ -22,7 +22,6 @@ import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
 
 import com.google.common.collect.Collections2;
-import com.google.common.collect.Range;
 
 import db.DBRecord;
 import ghidra.program.database.function.OverlappingFunctionException;
@@ -33,7 +32,6 @@ import ghidra.program.model.lang.PrototypeModel;
 import ghidra.program.model.listing.*;
 import ghidra.program.model.listing.VariableUtilities.VariableConflictHandler;
 import ghidra.program.model.symbol.*;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter.AddressDBFieldCodec;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter.DecodesAddresses;
 import ghidra.trace.database.bookmark.DBTraceBookmarkType;
@@ -42,6 +40,7 @@ import ghidra.trace.database.listing.DBTraceData;
 import ghidra.trace.database.program.DBTraceProgramView;
 import ghidra.trace.database.symbol.DBTraceSymbolManager.DBTraceFunctionTag;
 import ghidra.trace.database.symbol.DBTraceSymbolManager.DBTraceFunctionTagMapping;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.*;
 import ghidra.trace.model.symbol.TraceFunctionSymbol;
 import ghidra.trace.model.symbol.TraceLocalVariableSymbol;
@@ -134,7 +133,7 @@ public class DBTraceFunctionSymbol extends DBTraceNamespaceSymbol
 	@DBAnnotatedField(column = STACK_RETURN_OFFSET_COLUMN_NAME)
 	protected int stackReturnOffset;
 
-	protected Range<Long> lifespan;
+	protected Lifespan lifespan;
 	protected DBTraceFunctionSymbol thunked;
 
 	protected List<DBTraceLocalVariableSymbol> locals;
@@ -159,19 +158,19 @@ public class DBTraceFunctionSymbol extends DBTraceNamespaceSymbol
 			return;
 		}
 
-		lifespan = DBTraceUtils.toRange(startSnap, endSnap);
+		lifespan = Lifespan.span(startSnap, endSnap);
 		thunked = thunkedKey == -1 ? null : manager.functionStore.getObjectAt(thunkedKey);
 	}
 
-	protected void set(Range<Long> lifespan, Address entryPoint, String name,
+	protected void set(Lifespan lifespan, Address entryPoint, String name,
 			DBTraceFunctionSymbol thunked, DBTraceNamespaceSymbol parent, SourceType source) {
 		// Recall: Signature source and symbol source are different fields
 		this.name = name;
 		this.parentID = parent.getID();
 		doSetSource(source);
 		this.entryPoint = entryPoint;
-		this.startSnap = DBTraceUtils.lowerEndpoint(lifespan);
-		this.endSnap = DBTraceUtils.upperEndpoint(lifespan);
+		this.startSnap = lifespan.lmin();
+		this.endSnap = lifespan.lmax();
 		this.thunkedKey = thunked == null ? -1 : thunked.getKey();
 
 		update(NAME_COLUMN, PARENT_COLUMN, START_SNAP_COLUMN, END_SNAP_COLUMN, FLAGS_COLUMN,
@@ -284,7 +283,7 @@ public class DBTraceFunctionSymbol extends DBTraceNamespaceSymbol
 	}
 
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		return lifespan;
 	}
 
@@ -299,11 +298,11 @@ public class DBTraceFunctionSymbol extends DBTraceNamespaceSymbol
 			return;
 		}
 		try (LockHold hold = LockHold.lock(manager.lock.writeLock())) {
-			Range<Long> newLifespan = DBTraceUtils.toRange(startSnap, endSnap);
+			Lifespan newLifespan = Lifespan.span(startSnap, endSnap);
 			this.endSnap = endSnap;
 			update(END_SNAP_COLUMN);
 
-			Range<Long> oldLifespan = lifespan;
+			Lifespan oldLifespan = lifespan;
 			this.lifespan = newLifespan;
 
 			manager.trace.setChanged(new TraceChangeRecord<>(TraceSymbolChangeType.LIFESPAN_CHANGED,
@@ -1923,7 +1922,7 @@ public class DBTraceFunctionSymbol extends DBTraceNamespaceSymbol
 					break;
 				}
 				Address fromAddr = ref.getFromAddress();
-				Range<Long> span = lifespan.intersection(ref.getLifespan());
+				Lifespan span = lifespan.intersect(ref.getLifespan());
 				/**
 				 * NOTE: Could be zero, one, or more (because lifespans may be staggered).
 				 * Logically, at the actual call time of any given call at most one function is
@@ -1949,7 +1948,7 @@ public class DBTraceFunctionSymbol extends DBTraceNamespaceSymbol
 						return result;
 					}
 					Address toAddr = ref.getToAddress();
-					Range<Long> span = lifespan.intersection(ref.getLifespan());
+					Lifespan span = lifespan.intersect(ref.getLifespan());
 					/**
 					 * NOTE: Could be zero, one, or more (because lifespans may be staggered).
 					 * Logically, at the actual call time of any given call at most one function is

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceFunctionSymbolView.java

@@ -18,16 +18,14 @@ package ghidra.trace.database.symbol;
 import java.util.ArrayList;
 import java.util.List;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.database.function.OverlappingFunctionException;
 import ghidra.program.database.symbol.OverlappingNamespaceException;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.*;
 import ghidra.program.model.listing.*;
 import ghidra.program.model.symbol.*;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.program.DBTraceProgramView;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceSymbolChangeType;
 import ghidra.trace.model.symbol.*;
 import ghidra.trace.util.TraceChangeRecord;
@@ -89,7 +87,7 @@ public class DBTraceFunctionSymbolView
 	}
 
 	protected void assertNotOverlapping(DBTraceFunctionSymbol exclude, Address entryPoint,
-			Range<Long> span, AddressSetView proposedBody) throws OverlappingFunctionException {
+			Lifespan span, AddressSetView proposedBody) throws OverlappingFunctionException {
 		for (AddressRange rng : proposedBody) {
 			for (DBTraceFunctionSymbol overlap : manager.functions.getIntersecting(span, null, rng,
 				false, true)) {
@@ -103,7 +101,7 @@ public class DBTraceFunctionSymbolView
 	}
 
 	@Override
-	public DBTraceFunctionSymbol add(Range<Long> lifespan, Address entryPoint, AddressSetView body,
+	public DBTraceFunctionSymbol add(Lifespan lifespan, Address entryPoint, AddressSetView body,
 			String name, TraceFunctionSymbol thunked, TraceNamespaceSymbol parent,
 			SourceType source) throws InvalidInputException, OverlappingFunctionException {
 		if (name == null || name.length() == 0 || SymbolUtilities.isReservedDynamicLabelName(name,
@@ -131,8 +129,7 @@ public class DBTraceFunctionSymbolView
 
 			if (manager.trace.getCodeManager()
 					.definedData()
-					.getAt(
-						DBTraceUtils.lowerEndpoint(lifespan), entryPoint) != null) {
+					.getAt(lifespan.lmin(), entryPoint) != null) {
 				throw new IllegalArgumentException(
 					"Function entry point cannot be at defined data");
 			}
@@ -148,7 +145,7 @@ public class DBTraceFunctionSymbolView
 			name = doValidateName(name, entryPoint, source);
 
 			DBTraceLabelSymbol toPromote = manager.labels.getChildWithNameAt(name,
-				DBTraceUtils.lowerEndpoint(lifespan), null, entryPoint, dbnsParent);
+				lifespan.lmin(), null, entryPoint, dbnsParent);
 			if (toPromote != null && toPromote.getLifespan().equals(lifespan)) {
 				toPromote.delete();
 			}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceLabelSymbol.java

@@ -17,17 +17,15 @@ package ghidra.trace.database.symbol;
 
 import java.io.IOException;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.program.model.address.*;
 import ghidra.program.model.symbol.SourceType;
 import ghidra.program.model.symbol.SymbolType;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter.AddressDBFieldCodec;
 import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter.DecodesAddresses;
 import ghidra.trace.database.listing.*;
 import ghidra.trace.database.space.DBTraceSpaceKey;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceSymbolChangeType;
 import ghidra.trace.model.symbol.TraceLabelSymbol;
 import ghidra.trace.model.thread.TraceThread;
@@ -82,7 +80,7 @@ public class DBTraceLabelSymbol extends AbstractDBTraceSymbol
 	protected long endSnap;
 
 	protected TraceThread thread;
-	protected Range<Long> lifespan;
+	protected Lifespan lifespan;
 
 	public DBTraceLabelSymbol(DBTraceSymbolManager manager, DBCachedObjectStore<?> store,
 			DBRecord record) {
@@ -97,18 +95,18 @@ public class DBTraceLabelSymbol extends AbstractDBTraceSymbol
 		}
 
 		thread = manager.threadManager.getThread(threadKey);
-		lifespan = DBTraceUtils.toRange(startSnap, endSnap);
+		lifespan = Lifespan.span(startSnap, endSnap);
 	}
 
-	protected void set(Range<Long> lifespan, TraceThread thread, Address address, String name,
+	protected void set(Lifespan lifespan, TraceThread thread, Address address, String name,
 			DBTraceNamespaceSymbol parent, SourceType source) {
 		this.name = name;
 		this.parentID = parent.getID();
 		doSetSource(source);
 		this.address = address;
 		this.threadKey = thread == null ? -1 : thread.getKey();
-		this.startSnap = DBTraceUtils.lowerEndpoint(lifespan);
-		this.endSnap = DBTraceUtils.upperEndpoint(lifespan);
+		this.startSnap = lifespan.lmin();
+		this.endSnap = lifespan.lmax();
 
 		update(NAME_COLUMN, PARENT_COLUMN, START_SNAP_COLUMN, END_SNAP_COLUMN, FLAGS_COLUMN,
 			ADDRESS_COLUMN, THREAD_COLUMN);
@@ -119,7 +117,7 @@ public class DBTraceLabelSymbol extends AbstractDBTraceSymbol
 	}
 
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		return lifespan;
 	}
 
@@ -134,11 +132,11 @@ public class DBTraceLabelSymbol extends AbstractDBTraceSymbol
 			return;
 		}
 		try (LockHold hold = LockHold.lock(manager.lock.writeLock())) {
-			Range<Long> newLifespan = DBTraceUtils.toRange(startSnap, endSnap);
+			Lifespan newLifespan = Lifespan.span(startSnap, endSnap);
 			this.endSnap = endSnap;
 			update(END_SNAP_COLUMN);
 
-			Range<Long> oldLifespan = lifespan;
+			Lifespan oldLifespan = lifespan;
 			this.lifespan = newLifespan;
 
 			manager.trace.setChanged(new TraceChangeRecord<>(TraceSymbolChangeType.LIFESPAN_CHANGED,

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceLabelSymbolView.java

@@ -15,10 +15,9 @@
  */
 package ghidra.trace.database.symbol;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.Address;
 import ghidra.program.model.symbol.*;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceSymbolChangeType;
 import ghidra.trace.model.symbol.TraceLabelSymbolView;
 import ghidra.trace.model.symbol.TraceNamespaceSymbol;
@@ -36,7 +35,7 @@ public class DBTraceLabelSymbolView
 	}
 
 	@Override
-	public DBTraceLabelSymbol add(Range<Long> lifespan, TraceThread thread, Address address,
+	public DBTraceLabelSymbol add(Lifespan lifespan, TraceThread thread, Address address,
 			String name, TraceNamespaceSymbol parent, SourceType source)
 			throws InvalidInputException, IllegalArgumentException {
 		// TODO: Allow frames other than 0? Don't allow threads at all?

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceNamespaceSymbol.java

@@ -18,15 +18,13 @@ package ghidra.trace.database.symbol;
 import java.util.ArrayList;
 import java.util.Collection;
 
-import com.google.common.collect.Range;
-
 import db.DBRecord;
 import ghidra.program.model.address.AddressSet;
 import ghidra.program.model.address.AddressSetView;
 import ghidra.program.model.listing.CircularDependencyException;
 import ghidra.program.model.symbol.Namespace;
 import ghidra.program.model.symbol.SymbolType;
-import ghidra.trace.database.DBTraceUtils;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.symbol.TraceNamespaceSymbol;
 import ghidra.util.database.DBCachedObjectStore;
 import ghidra.util.database.annot.DBAnnotatedObjectInfo;
@@ -59,26 +57,26 @@ public class DBTraceNamespaceSymbol extends AbstractDBTraceSymbol implements Tra
 
 	// Internal
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		// TODO: Cache this computation and/or keep it as transient fields?
 		long min = Long.MAX_VALUE;
 		long max = Long.MIN_VALUE;
-		Range<Long> range = super.getLifespan();
+		Lifespan range = super.getLifespan();
 		if (range != null) {
-			min = DBTraceUtils.lowerEndpoint(range);
-			max = DBTraceUtils.upperEndpoint(range);
+			min = range.lmin();
+			max = range.lmax();
 		}
 		for (AbstractDBTraceSymbol child : getChildren()) {
 			range = child.getLifespan();
 			if (range != null) {
-				min = Math.min(min, DBTraceUtils.lowerEndpoint(range));
-				max = Math.min(max, DBTraceUtils.upperEndpoint(range));
+				min = Math.min(min, range.lmin());
+				max = Math.min(max, range.lmax());
 			}
 		}
 		if (min > max) {
 			return null;
 		}
-		return DBTraceUtils.toRange(min, max);
+		return Lifespan.span(min, max);
 	}
 
 	@Override

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceReference.java

@@ -18,13 +18,11 @@ package ghidra.trace.database.symbol;
 import java.util.Collection;
 import java.util.Objects;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.Address;
 import ghidra.program.model.symbol.*;
 import ghidra.trace.database.DBTrace;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.database.symbol.DBTraceReferenceSpace.DBTraceReferenceEntry;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace.TraceReferenceChangeType;
 import ghidra.trace.model.Trace.TraceSymbolChangeType;
 import ghidra.trace.model.symbol.*;
@@ -69,13 +67,13 @@ public class DBTraceReference implements TraceReference {
 	}
 
 	@Override
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		return ent.getLifespan();
 	}
 
 	@Override
 	public long getStartSnap() {
-		return DBTraceUtils.lowerEndpoint(getLifespan());
+		return getLifespan().lmin();
 	}
 
 	@Override
@@ -160,7 +158,7 @@ public class DBTraceReference implements TraceReference {
 				DBTraceNamespaceSymbol parent = varSym.getParentNamespace();
 				if (parent instanceof TraceSymbolWithLifespan) {
 					TraceSymbolWithLifespan symWl = (TraceSymbolWithLifespan) parent;
-					if (!symWl.getLifespan().isConnected(getLifespan())) {
+					if (!symWl.getLifespan().intersects(getLifespan())) {
 						throw new IllegalArgumentException(
 							"Associated symbol and reference must have connected lifespans");
 					}
@@ -178,7 +176,7 @@ public class DBTraceReference implements TraceReference {
 			}
 			if (symbol instanceof TraceSymbolWithLifespan) {
 				TraceSymbolWithLifespan symWl = (TraceSymbolWithLifespan) symbol;
-				if (!symWl.getLifespan().isConnected(getLifespan())) {
+				if (!symWl.getLifespan().intersects(getLifespan())) {
 					throw new IllegalArgumentException(
 						"Associated symbol and reference must have connected lifespans");
 				}

Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceReferenceManager.java

@@ -22,7 +22,6 @@ import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReadWriteLock;
 
 import com.google.common.collect.Collections2;
-import com.google.common.collect.Range;
 
 import db.DBHandle;
 import ghidra.program.model.address.*;
@@ -35,6 +34,7 @@ import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager;
 import ghidra.trace.database.space.DBTraceDelegatingManager;
 import ghidra.trace.database.symbol.DBTraceReferenceSpace.DBTraceReferenceEntry;
 import ghidra.trace.database.thread.DBTraceThreadManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.stack.TraceStackFrame;
 import ghidra.trace.model.symbol.TraceReference;
 import ghidra.trace.model.symbol.TraceReferenceManager;
@@ -164,20 +164,20 @@ public class DBTraceReferenceManager extends AbstractDBTraceSpaceBasedManager<DB
 	}
 
 	@Override
-	public DBTraceReference addReference(Range<Long> lifespan, Reference reference) {
+	public DBTraceReference addReference(Lifespan lifespan, Reference reference) {
 		return delegateWrite(reference.getFromAddress().getAddressSpace(),
 			s -> s.addReference(lifespan, reference));
 	}
 
 	@Override
-	public DBTraceReference addMemoryReference(Range<Long> lifespan, Address fromAddress,
+	public DBTraceReference addMemoryReference(Lifespan lifespan, Address fromAddress,
 			Address toAddress, RefType refType, SourceType source, int operandIndex) {
 		return delegateWrite(fromAddress.getAddressSpace(), s -> s.addMemoryReference(lifespan,
 			fromAddress, toAddress, refType, source, operandIndex));
 	}
 
 	@Override
-	public DBTraceOffsetReference addOffsetReference(Range<Long> lifespan, Address fromAddress,
+	public DBTraceOffsetReference addOffsetReference(Lifespan lifespan, Address fromAddress,
 			Address toAddress, boolean toAddrIsBase, long offset, RefType refType,
 			SourceType source, int operandIndex) {
 		return delegateWrite(fromAddress.getAddressSpace(), s -> s.addOffsetReference(lifespan,
@@ -185,21 +185,21 @@ public class DBTraceReferenceManager extends AbstractDBTraceSpaceBasedManager<DB
 	}
 
 	@Override
-	public DBTraceShiftedReference addShiftedReference(Range<Long> lifespan, Address fromAddress,
+	public DBTraceShiftedReference addShiftedReference(Lifespan lifespan, Address fromAddress,
 			Address toAddress, int shift, RefType refType, SourceType source, int operandIndex) {
 		return delegateWrite(fromAddress.getAddressSpace(), s -> s.addShiftedReference(lifespan,
 			fromAddress, toAddress, shift, refType, source, operandIndex));
 	}
 
 	@Override
-	public DBTraceReference addRegisterReference(Range<Long> lifespan, Address fromAddress,
+	public DBTraceReference addRegisterReference(Lifespan lifespan, Address fromAddress,
 			Register toRegister, RefType refType, SourceType source, int operandIndex) {
 		return delegateWrite(fromAddress.getAddressSpace(), s -> s.addRegisterReference(lifespan,
 			fromAddress, toRegister, refType, source, operandIndex));
 	}
 
 	@Override
-	public DBTraceReference addStackReference(Range<Long> lifespan, Address fromAddress,
+	public DBTraceReference addStackReference(Lifespan lifespan, Address fromAddress,
 			int toStackOffset, RefType refType, SourceType source, int operandIndex) {
 		return delegateWrite(fromAddress.getAddressSpace(), s -> s.addStackReference(lifespan,
 			fromAddress, toStackOffset, refType, source, operandIndex));
@@ -227,7 +227,7 @@ public class DBTraceReferenceManager extends AbstractDBTraceSpaceBasedManager<DB
 	}
 
 	@Override
-	public Collection<? extends DBTraceReference> getReferencesFromRange(Range<Long> span,
+	public Collection<? extends DBTraceReference> getReferencesFromRange(Lifespan span,
 			AddressRange range) {
 		return delegateRead(range.getAddressSpace(), s -> s.getReferencesFromRange(span, range),
 			Collections.emptyList());
@@ -248,7 +248,7 @@ public class DBTraceReferenceManager extends AbstractDBTraceSpaceBasedManager<DB
 	}
 
 	@Override
-	public void clearReferencesFrom(Range<Long> span, AddressRange range) {
+	public void clearReferencesFrom(Lifespan span, AddressRange range) {
 		delegateDeleteV(range.getAddressSpace(), s -> s.clearReferencesFrom(span, range));
 	}
 
@@ -259,25 +259,25 @@ public class DBTraceReferenceManager extends AbstractDBTraceSpaceBasedManager<DB
 	}
 
 	@Override
-	public Collection<? extends DBTraceReference> getReferencesToRange(Range<Long> span,
+	public Collection<? extends DBTraceReference> getReferencesToRange(Lifespan span,
 			AddressRange range) {
 		return delegateRead(range.getAddressSpace(), s -> s.getReferencesToRange(span, range),
 			Collections.emptyList());
 	}
 
 	@Override
-	public void clearReferencesTo(Range<Long> span, AddressRange range) {
+	public void clearReferencesTo(Lifespan span, AddressRange range) {
 		delegateDeleteV(range.getAddressSpace(), s -> s.clearReferencesTo(span, range));
 	}
 
 	@Override
-	public AddressSetView getReferenceSources(Range<Long> span) {
+	public AddressSetView getReferenceSources(Lifespan span) {
 		return new UnionAddressSetView(
 			Collections2.transform(memSpacesView, s -> s.getReferenceSources(span)));
 	}
 
 	@Override
-	public AddressSetView getReferenceDestinations(Range<Long> span) {
+	public AddressSetView getReferenceDestinations(Lifespan span) {
 		return new UnionAddressSetView(
 			Collections2.transform(memSpacesView, s -> s.getReferenceDestinations(span)));
 	}