1 /***********************************************************************
2  * Copyright (c) 2013-2025 General Atomics Integrated Intelligence, Inc.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Apache License, Version 2.0
5  * which accompanies this distribution and is available at
6  * https://www.apache.org/licenses/LICENSE-2.0
7  ***********************************************************************/
8 
9 package org.locationtech.geomesa.utils.collection
10 
11 /**
12   * Growable byte queue that holds values in a circular array to minimize allocations
13   *
14   * @param initialSize initial buffer size
15   */
16 class CircularByteQueue(initialSize: Int = 16) {
17 
18   private var array = Array.ofDim[Byte](initialSize)
19   private var start = 0
20   private var length = 0
21 
22   /**
23     * Number of bytes stored in this buffer
24     *
25     * @return
26     */
27   def size: Int = length
28 
29   /**
30     * Current remaining capacity. In general this is not relevant, as the queue will grow as needed,
31     * but it can be useful for debugging
32     *
33     * @return current capacity of the buffer
34     */
35   def capacity: Int = array.length - length
36 
37   /**
38     * Enqueue a single byte
39     *
40     * @param byte byte
41     */
42   def += (byte: Byte): Unit = enqueue(byte)
43 
44   /**
45     * Enqueue multiple bytes
46     *
47     * @param bytes bytes
48     */
49   def ++= (bytes: Array[Byte]): Unit = enqueue(bytes, 0, bytes.length)
50 
51   /**
52     * Enqueue a single byte
53     *
54     * @param byte byte
55     */
56   def enqueue(byte: Byte): Unit = {
57     ensure(1)
58     var last = start + length
59     if (last >= array.length) {
60       last -= array.length
61     }
62     array(last) = byte
63     length += 1
64   }
65 
66   /**
67     * Enqueue multiple bytes
68     *
69     * @param bytes bytes
70     * @param offset offset into the array to start reading, must be valid for the bytes passed in
71     * @param count number of bytes to enqueue, must be valid for the size of the bytes and offset passed in
72     */
73   def enqueue(bytes: Array[Byte], offset: Int, count: Int): Unit = {
74     ensure(count)
75     var first = start + length
76     if (first >= array.length) {
77       first -= array.length
78     }
79     if (first + count < array.length) {
80       System.arraycopy(bytes, offset, array, first, count)
81     } else {
82       val tail = array.length - first
83       System.arraycopy(bytes, offset, array, first, tail)
84       System.arraycopy(bytes, offset + tail, array, 0, count - tail)
85     }
86     length += count
87   }
88 
89   /**
90     * Dequeue bytes
91     *
92     * @param count number of bytes to remove
93     * @return
94     */
95   def dequeue(count: Int): Array[Byte] = {
96     val total = math.min(length, count)
97     val result = Array.ofDim[Byte](total)
98     if (start + total <= array.length) {
99       System.arraycopy(array, start, result, 0, total)
100     } else {
101       val tail = array.length - start
102       System.arraycopy(array, start, result, 0, tail)
103       System.arraycopy(array, 0, result, tail, total - tail)
104     }
105     start += total
106     if (start >= array.length) {
107       start -= array.length
108     }
109     length -= total
110     result
111   }
112 
113   /**
114     * Drop bytes
115     *
116     * @param count number of bytes to drop
117     */
118   def drop(count: Int): Unit = {
119     val total = math.min(length, count)
120     start += total
121     if (start >= array.length) {
122       start -= array.length
123     }
124     length -= total
125   }
126 
127   /**
128     * Grow the array as needed to fit an additional number of bytes
129     *
130     * @param count bytes to fit
131     */
132   private def ensure(count: Int): Unit = {
133     if (length + count > array.length) {
134       var newSize = array.length * 2
135       while (newSize < length + count) {
136         newSize = newSize * 2
137       }
138       val tmp = Array.ofDim[Byte](newSize)
139       if (start + length <= array.length) {
140         System.arraycopy(array, start, tmp, 0, length)
141       } else {
142         val tailBytes = array.length - start
143         System.arraycopy(array, start, tmp, 0, tailBytes)
144         System.arraycopy(array, 0, tmp, tailBytes, length - tailBytes)
145       }
146       array = tmp
147       start = 0
148     }
149   }
150 }