Implementing a cache

[Jack Stouffer via Digitalmars-d-learn]

On Sunday, 3 July 2016 at 17:15:32 UTC, Lodovico Giaretta wrote:
> To avoid the ~= operator and reallocations of the cache array, 
> you could impose a max number of cache entries, preallocate the 
> array and use it as a circular buffer.

Here's a simple ring buffer I use, feel free to take it

struct RingBuffer (T, uint buffer_length = 10) {
     private T[buffer_length] buffer;
     private int lastIndex;

     @safe @nogc nothrow pure {
         this(const T initial_value) {
             this.lastIndex = 0;
             reset(initial_value);
         }

         void reset(const T value) {
             for (int i = 0; i < this.buffer.length; ++i) {
                 this.buffer[i] = value;
             }
         }

         void put(const T value) {
             this.buffer[this.lastIndex] = value; // store the new 
sample

             // advance the index and wrap it around
             this.lastIndex += 1;
             if (this.lastIndex >= buffer_length) {
                 this.lastIndex = 0;
             }
         }

         auto ref opIndex(size_t n) { return buffer[n]; }
         auto opSlice() { return buffer[]; }
         auto opAssign(T[] rhs)
         in
         {
             assert(rhs.length <= buffer.length);
         }
         body
         {
             reset();
             foreach (e; rhs)
             {
                 put(e);
             }
             return this;
          }
     }
}