Is there a common term for a fixed-length, fifo, "push through" array or list?

Question

Here's a ubiquitous data structure in, say, game and UX programming:

• there're a fixed number of items (say, "5")
• they're all "zero" to begin with
• you can put one in on the "left" (FWIW I usually call it something like shove to distinguish from the usual meaning of push)
• once there are 5, each time you put a new one in on the left, the one on the "right" falls out and is gone
• in fact, it's not possible to / there's no need to access any individual item, ever
• you can get the total at any time

Here's a trivial naturalistic example. (Obviously, there're several ways to do it.)

I've always wondered if there's a common term for this.

I sometimes call it a "piece of pipe" (imagine a short piece of pipe that you can push tennis balls through from one end).

///A "pipe" ongoing sum. First in is first thrown-away.
class Pipe {
    private var r: [Whatever] = []
    private var i: Int = 0
    private var k: Int = 0
    
    ///Start fresh, with a given fixed length.
    public func begin(with: Int) {
        k = with
        r = Array(repeating: .zero, count: k)
        i = 0
    }
    
    ///Add one on the left
    public func shove(p: CGPoint) {
        r[i] = p
        i = (i + 1) % k
    }
    
    ///Supply the current value at this moment.
    public var sum: CGPoint {
        return r.reduce(.zero, +) / CGFloat(k)
    }
    
    ///Debugging string.
    public var say: String {
        return r.reduce("pipe: "){ a,b in "\(a) .. \(b.say)"} + "   t   " + sum.say
    }
}

Answer 1

This sounds a lot like a circular buffer or ring buffer. It meets most of the criteria:

• It has a fixed size of items.
• They don't have to be a specific value at the start, but they could be initialized to a reasonable default, empty, or null value depending on your implementation.
• You insert values at the end and read from the marker.
• If you are writing faster than you are reading, items will fall out of the buffer before they can be read.

You could have some specialized implementations of a ring buffer that address other concerns. I suspect that it would be close enough to a ring buffer that the name would still apply and be meaningful.

Answer 2

Like the other answer suggests, a fixed-length fifo queue is a ring buffer, although usually writing past the capacity will be prevented, instead of overwriting the next element.

• in fact, it's not possible to / there's no need to access any individual item, ever
• you can get the total at any time

With this feature, it is known as a sliding window. I would be implemented as follows:

class SlidingWindow<Whatever extends Numeric> {
    private var r: [Whatever] = []
    private var i: Int = 0
    private var k: Int = 0
    ///Running sum over the contents of the sliding window
    public var sum: Whatever = .zero
    
    ///Start fresh, with a given fixed length.
    public func begin(with: Int) {
        k = with
        r = Array(repeating: .zero, count: k)
        i = 0
        sum = .zero
    }
    
    ///Add a new value, remove the oldest value, update the sum
    public func advance(p: Whatever) {
        sum = sum - r[i] + p
        r[i] = p
        i = (i + 1) % k
    }
}