Package ghidra.trace.model

# Enum Class Lifespan.Domain

java.lang.Object
java.lang.Enum<Lifespan.Domain>
ghidra.trace.model.Lifespan.Domain

All Implemented Interfaces:
  `Span.Domain<Long,Lifespan>`, `Serializable`, `Comparable<Lifespan.Domain>`, `Constable`

Enclosing interface:
  `Lifespan`

public static enum Lifespan.Domain extends Enum<Lifespan.Domain> implements Span.Domain<Long,Lifespan>
The domain of snapshot keys

- ## Nested Class Summary

  ## Nested classes/interfaces inherited from class java.lang.Enum

  `Enum.EnumDesc<E extends Enum<E>>`

- ## Enum Constant Summary

  Enum Constants
  Enum Constant
  Description
  `INSTANCE`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `Lifespan`
  `all()`
  Get the span containing all values in the domain
  `Lifespan`
  `atLeast(long min)`
  `Lifespan`
  `atLeast(Long min)`
  Construct a new span with the given lower endpoint, inclusive.
  `Lifespan`
  `atMost(long max)`
  `Lifespan`
  `atMost(Long max)`
  Construct a new span with the given upper endpoint, inclusive.
  `Lifespan`
  `bound(Lifespan s1, Lifespan s2)`
  Compute the smallest span which contains two spans
  `Lifespan`
  `closed(long min, long max)`
  `Lifespan`
  `closed(Long min, Long max)`
  Create a new span with the given endpoints, inclusive.
  `int`
  `compare(long n1, long n2)`
  `int`
  `compare(Long n1, Long n2)`
  Compare two values
  `long`
  `dec(long n)`
  `Long`
  `dec(Long n)`
  Get a given value, decremented by 1
  `Lifespan`
  `empty()`
  Get the span that contains no value, nor has any endpoints
  `boolean`
  `encloses(Lifespan s1, Lifespan s2)`
  Check if one span encloses another
  `long`
  `inc(long n)`
  `Long`
  `inc(Long n)`
  Get a given value, incremented by 1
  `Lifespan`
  `intersect(Lifespan s1, Lifespan s2)`
  Compute the intersection of two spans
  `boolean`
  `intersects(Lifespan s1, Lifespan s2)`
  Check if two spans intersect
  `long`
  `lmax()`
  `long`
  `lmin()`
  `Long`
  `max()`
  Get the maximum value in the domain
  `long`
  `max(long n1, long n2)`
  `Long`
  `min()`
  Get the minimum value in the domain
  `long`
  `min(long n1, long n2)`
  `Lifespan`
  `newSpan(Long min, Long max)`
  Factory method for a new span after arguments are validated
  `Lifespan`
  `value(long n)`
  `static Lifespan.Domain`
  `valueOf(String name)`
  Returns the enum constant of this class with the specified name.
  `static Lifespan.Domain[]`
  `values()`
  Returns an array containing the constants of this enum class, in the order they are declared.

  ### Methods inherited from class java.lang.Enum

  `clone, compareTo, describeConstable, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf`

  ### Methods inherited from class java.lang.Object

  `getClass, notify, notifyAll, wait, wait, wait`

  ### Methods inherited from interface generic.Span.Domain

  `max, min, subtract, toMaxString, toMinString, toString, toString, toString, value`

- ## Enum Constant Details

  - ### INSTANCE

    public static final Lifespan.Domain INSTANCE

- ## Method Details

  - ### values

    public static Lifespan.Domain[] values()
    Returns an array containing the constants of this enum class, in the order they are declared.
    Returns:
      an array containing the constants of this enum class, in the order they are declared

  - ### valueOf

    public static Lifespan.Domain valueOf(String name)
    Returns the enum constant of this class with the specified name. The string must match exactly an identifier used to declare an enum constant in this class. (Extraneous whitespace characters are not permitted.)
    Parameters:
      `name` - the name of the enum constant to be returned.
    Returns:
      the enum constant with the specified name
    Throws:
      `IllegalArgumentException` - if this enum class has no constant with the specified name
      `NullPointerException` - if the argument is null

  - ### closed

    public Lifespan closed(Long min, Long max)
    Description copied from interface: `Span.Domain`
    Create a new span with the given endpoints, inclusive.
    Specified by:
      `closed` in interface `Span.Domain<Long,Lifespan>`
    Parameters:
      `min` - the lower endpoint
      `max` - the upper endpoint
    Returns:
      the span

  - ### closed

    public Lifespan closed(long min, long max)

  - ### newSpan

    public Lifespan newSpan(Long min, Long max)
    Description copied from interface: `Span.Domain`
    Factory method for a new span after arguments are validated
    Specified by:
      `newSpan` in interface `Span.Domain<Long,Lifespan>`
    Parameters:
      `min` - the lower endpoint
      `max` - the upper endpoint
    Returns:
      the span

  - ### value

    public Lifespan value(long n)

  - ### atMost

    public Lifespan atMost(Long max)
    Description copied from interface: `Span.Domain`
    Construct a new span with the given upper endpoint, inclusive.

    The lower endpoint becomes the minimum value in the domain

    Specified by:
      `atMost` in interface `Span.Domain<Long,Lifespan>`
    Parameters:
      `max` - the upper endpoint
    Returns:
      the span

  - ### atMost

    public Lifespan atMost(long max)

  - ### atLeast

    public Lifespan atLeast(Long min)
    Description copied from interface: `Span.Domain`
    Construct a new span with the given lower endpoint, inclusive.

    The upper endpoint becomes the maximum value in the domain

    Specified by:
      `atLeast` in interface `Span.Domain<Long,Lifespan>`
    Parameters:
      `min` - the lower endpoint
    Returns:
      the span

  - ### atLeast

    public Lifespan atLeast(long min)

  - ### all

    public Lifespan all()
    Description copied from interface: `Span.Domain`
    Get the span containing all values in the domain
    Specified by:
      `all` in interface `Span.Domain<Long,Lifespan>`
    Returns:
      the span

  - ### empty

    public Lifespan empty()
    Description copied from interface: `Span.Domain`
    Get the span that contains no value, nor has any endpoints

    This span is returned when the result doesn't exist, e.g., when finding the intersection of spans which do not intersect.

    Specified by:
      `empty` in interface `Span.Domain<Long,Lifespan>`
    Returns:
      the empty span

  - ### compare

    public int compare(Long n1, Long n2)
    Description copied from interface: `Span.Domain`
    Compare two values
    Specified by:
      `compare` in interface `Span.Domain<Long,Lifespan>`
    Parameters:
      `n1` - a value
      `n2` - another value
    Returns:
      the result, as in `Comparator.compare(Object, Object)`

  - ### compare

    public int compare(long n1, long n2)

  - ### min

    public Long min()
    Description copied from interface: `Span.Domain`
    Get the minimum value in the domain

    This value can also represent negative infinity.

    Specified by:
      `min` in interface `Span.Domain<Long,Lifespan>`
    Returns:
      the minimum value

  - ### lmin

    public long lmin()

  - ### max

    public Long max()
    Description copied from interface: `Span.Domain`
    Get the maximum value in the domain

    This value can also represent positive infinity.

    Specified by:
      `max` in interface `Span.Domain<Long,Lifespan>`
    Returns:
      the maximum value

  - ### lmax

    public long lmax()

  - ### inc

    public Long inc(Long n)
    Description copied from interface: `Span.Domain`
    Get a given value, incremented by 1

    If the resulting value would exceed `Span.Domain.max()`, this should wrap to `Span.Domain.min()`.

    Specified by:
      `inc` in interface `Span.Domain<Long,Lifespan>`
    Parameters:
      `n` - the value
    Returns:
      the value incremented

  - ### inc

    public long inc(long n)

  - ### dec

    public Long dec(Long n)
    Description copied from interface: `Span.Domain`
    Get a given value, decremented by 1

    If the resulting value would exceed `Span.Domain.min()`, this should wrap to `Span.Domain.max()`.

    Specified by:
      `dec` in interface `Span.Domain<Long,Lifespan>`
    Parameters:
      `n` - the value
    Returns:
      the value decremented

  - ### dec

    public long dec(long n)

  - ### min

    public long min(long n1, long n2)

  - ### max

    public long max(long n1, long n2)

  - ### intersect

    public Lifespan intersect(Lifespan s1, Lifespan s2)
    Description copied from interface: `Span.Domain`
    Compute the intersection of two spans
    Specified by:
      `intersect` in interface `Span.Domain<Long,Lifespan>`
    Parameters:
      `s1` - a span
      `s2` - another span
    Returns:
      the intersection, possibly empty

  - ### intersects

    public boolean intersects(Lifespan s1, Lifespan s2)
    Description copied from interface: `Span.Domain`
    Check if two spans intersect
    Specified by:
      `intersects` in interface `Span.Domain<Long,Lifespan>`
    Parameters:
      `s1` - a span
      `s2` - another span
    Returns:
      true if they intersect

  - ### encloses

    public boolean encloses(Lifespan s1, Lifespan s2)
    Description copied from interface: `Span.Domain`
    Check if one span encloses another
    Specified by:
      `encloses` in interface `Span.Domain<Long,Lifespan>`
    Parameters:
      `s1` - a span
      `s2` - another span
    Returns:
      true if s1 encloses s2

  - ### bound

    public Lifespan bound(Lifespan s1, Lifespan s2)
    Description copied from interface: `Span.Domain`
    Compute the smallest span which contains two spans
    Specified by:
      `bound` in interface `Span.Domain<Long,Lifespan>`
    Parameters:
      `s1` - a span
      `s2` - another span
    Returns:
      the bounding span