Introduce size operations

Introduce an operation to check the amount of dead-letters in the queue.
Introduce an operation to check the amount of dead-letters in a sequence
Introduce an operation to check the amount of unique sequences in the
 queue.

#2021

messaging/src/main/java/org/axonframework/messaging/deadletter/InMemorySequencedDeadLetterQueue.java

@@ -208,12 +208,6 @@ public boolean isFull(@Nonnull Object sequenceIdentifier) {
         return maximumNumberOfSequencesReached(identifier) || maximumSequenceSizeReached(identifier);
     }
 
-    private static String toIdentifier(Object sequenceIdentifier) {
-        return sequenceIdentifier instanceof String
-                ? (String) sequenceIdentifier
-                : Integer.toString(sequenceIdentifier.hashCode());
-    }
-
     private boolean maximumNumberOfSequencesReached(String identifier) {
         return !deadLetters.containsKey(identifier) && deadLetters.keySet().size() >= maxSequences;
     }
@@ -222,6 +216,31 @@ private boolean maximumSequenceSizeReached(String identifier) {
         return deadLetters.containsKey(identifier) && deadLetters.get(identifier).size() >= maxSequenceSize;
     }
 
+    @Override
+    public long size() {
+        return deadLetters.values()
+                          .stream()
+                          .mapToLong(Deque::size)
+                          .sum();
+    }
+
+    @Override
+    public long sequenceSize(@Nonnull Object sequenceIdentifier) {
+        String identifier = toIdentifier(sequenceIdentifier);
+        return contains(identifier) ? deadLetters.get(identifier).size() : 0L;
+    }
+
+    private static String toIdentifier(Object sequenceIdentifier) {
+        return sequenceIdentifier instanceof String
+                ? (String) sequenceIdentifier
+                : Integer.toString(sequenceIdentifier.hashCode());
+    }
+
+    @Override
+    public long amountOfSequences() {
+        return deadLetters.size();
+    }
+
     @Override
     public long maxSequences() {
         return maxSequences;

messaging/src/main/java/org/axonframework/messaging/deadletter/SequencedDeadLetterQueue.java

@@ -142,6 +142,29 @@ void requeue(@Nonnull DeadLetter<? extends M> letter,
      */
     boolean isFull(@Nonnull Object sequenceIdentifier);
 
+    /**
+     * Returns the number of dead-letters contained in this queue.
+     *
+     * @return The number of dead-letters contained in this queue.
+     */
+    long size();
+
+    /**
+     * Returns the number of dead-letters for the sequence matching the given {@code sequenceIdentifier} contained in
+     * this queue.
+     *
+     * @param sequenceIdentifier The identifier of the sequence to retrieve the size from.
+     * @return The number of dead-letters for the sequence matching the given {@code sequenceIdentifier}.
+     */
+    long sequenceSize(@Nonnull Object sequenceIdentifier);
+
+    /**
+     * Returns the number of unique sequences contained in this queue.
+     *
+     * @return The number of unique sequences contained in this queue.
+     */
+    long amountOfSequences();
+
     /**
      * The maximum number of distinct sequences this dead letter queue can hold. This comes down to the maximum number
      * of unique "sequence identifiers" stored.

messaging/src/test/java/org/axonframework/messaging/deadletter/SequencedDeadLetterQueueTest.java

@@ -365,6 +365,55 @@ void isFullReturnsTrueAfterMaximumSequenceSizeIsReached() {
         assertTrue(testSubject.isFull(testId));
     }
 
+    @Test
+    void sizeReturnsOverallNumberOfContainedDeadLetters() {
+        assertEquals(0, testSubject.size());
+
+        Object testId = generateId();
+        testSubject.enqueue(testId, generateInitialLetter());
+        assertEquals(1, testSubject.size());
+        testSubject.enqueue(testId, generateInitialLetter());
+        assertEquals(2, testSubject.size());
+
+        // This generates a new sequence, increasing the size.
+        testSubject.enqueue(generateId(), generateInitialLetter());
+        assertEquals(3, testSubject.size());
+    }
+
+    @Test
+    void sequenceSizeForSequenceIdentifierReturnsTheNumberOfContainedLettersForGivenSequenceIdentifier() {
+        assertEquals(0, testSubject.sequenceSize("some-id"));
+
+        Object testId = generateId();
+        testSubject.enqueue(testId, generateInitialLetter());
+        assertEquals(0, testSubject.sequenceSize("some-id"));
+        assertEquals(1, testSubject.sequenceSize(testId));
+        testSubject.enqueue(testId, generateInitialLetter());
+        assertEquals(2, testSubject.sequenceSize(testId));
+
+        // This generates a new sequence, so shouldn't increase the sequence size.
+        testSubject.enqueue(generateId(), generateInitialLetter());
+        assertEquals(0, testSubject.sequenceSize("some-id"));
+        assertEquals(2, testSubject.sequenceSize(testId));
+    }
+
+    @Test
+    void amountOfSequencesReturnsTheNumberOfUniqueSequences() {
+        assertEquals(0, testSubject.amountOfSequences());
+
+        testSubject.enqueue(generateId(), generateInitialLetter());
+        assertEquals(1, testSubject.amountOfSequences());
+
+        testSubject.enqueue(generateId(), generateInitialLetter());
+        assertEquals(2, testSubject.amountOfSequences());
+
+        Object testId = generateId();
+        testSubject.enqueue(testId, generateInitialLetter());
+        testSubject.enqueue(testId, generateInitialLetter());
+        testSubject.enqueue(testId, generateInitialLetter());
+        assertEquals(3, testSubject.amountOfSequences());
+    }
+
     @Test
     void processInvocationReturnsFalseIfThereAreNoLetters() {
         AtomicBoolean taskInvoked = new AtomicBoolean(false);