Using An Ordered Struct As A Fixed-Size Cache In ColdFusion

component
	output = false
	hint = "I provide a very simple, fixed-size key-value cache."
	{

	/**
	* I initialize the fixed-lock of the given size.
	*/
	public void function init( required numeric maxSize ) {

		variables.maxSize = arguments.maxSize;
		// Note: Using an ORDERED struct to represent the internal cache. This is
		// important since we will leverage the predictability of the .keyArray() method
		// to manage the FIFO (First In, First Out) characteristics of the pruning.
		variables.store = [:];

		// Since the internal cache has size constraints, we need to apply locking around
		// access so that we can apply those size constraints across threads.
		variables.lockName = "FixedCacheLock:#createUuid()#";
		// Since this is all in-memory manipulation, a timeout of (1) should be sufficient
		// for both type of locks.
		variables.readLockSettings = {
			name: lockName,
			type: "readonly",
			timeout: 1
		};
		variables.writeLockSettings = {
			name: lockName,
			type: "exclusive",
			timeout: 1
		}

	}

	// ---
	// PUBLIC METHODS.
	// ---

	/**
	* I get the value cached at the given key; or null if the value isn't cached. 
	*/
	public any function get( required string key ) {

		lock attributeCollection = readLockSettings {

			if ( store.keyExists( key ) ) {

				return store[ key ];

			}

		}

	}

	/**
	* I get a SHALLOW copy of the internal store.
	*/
	public struct function getAll() {

		lock attributeCollection = readLockSettings {

			return store.copy();

		}

	}

	/**
	* I cache the given value at the given key. The value is returned.
	*/
	public any function set(
		required string key,
		required any value
		) {

		lock attributeCollection = writeLockSettings {

			store[ key ] = value;
			// Note: Since we're using an exclusive lock around the mutation of the store,
			// we know that AT MOST we're only ever 1-entry over the size limit.
			pruneKeys();

		}

		return value;

	}

	// ---
	// PRIVATE METHODS.
	// ---

	/**
	* I ensure that the cache is kept within the size constraints.
	*/
	private void function pruneKeys() {

		if ( store.size() > maxSize ) {

			// Since we're using an ORDERED STRUCT to manage the internal store, we know
			// that the array of keys will be returned in the order in which values were
			// added to the cache. As such, the FIRST key in the array will represent the
			// oldest entry in the cache. And, since we're single-threading the SETTING of
			// new keys, we know that we only have to remove first key in order to keep
			// the cache at the right size.
			store.delete( store.keyArray().first() );

		}

	}

}

<cfscript>

	// Only the last 10-keys will be kept in the cache.
	fixedCache = new FixedCache( 10 );

	for ( i = 1 ; i <= 100 ; i++ ) {

		fixedCache.set( "Key-#i#", "Value-#i#" );

	}

	// We should only see 10 entries in the shallow-copy.
	dump( fixedCache.getAll() );

</cfscript>