Cached Closures And User Defined Functions (UDFs) In ColdFusion

component
	output = false
	hint = "I create the logger using both closures and component methods."
	{

	/**
	* I create a logger factory.
	*
	* @output false
	*/
	public any function init() {

		return( this );

	}


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


	/**
	* I create the logger object, which is just a struct with closure-based methods.
	*
	* @output false
	*/
	public struct function createLogger() {

		var messages = [];

		var logger = {
			log: function( required string message ) {

				// *** CAUTION: Here, we are referencing a UDF from within the closure.
				arrayAppend( messages, formatLogMessage( message ) );

			},
			getMessages: function() {

				return( messages );

			}
		};

		return( logger );

	}


	/**
	* I am here to generically test if a closure can call a user defined function.
	*
	* @message I am the message being formatted.
	* @output false
	*/
	public string function testFormatter( required string message ) {

		var myClosure = function() {

			return( formatLogMessage( message ) );

		};

		return( myClosure( message ) );


	}


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


	/**
	* I provide trivial formatting on the given log message. Really, I am here to test
	* whether or not the cached closure can reference this UDF at a future point in time.
	*
	* @message I am the message being formatted.
	* @output false
	*/

	private string function formatLogMessage( required string message ) {

		return( "[#dateFormat( now(), 'yyyy-mm-dd' )#] #message#" );

	}

}

component
	output = false
	hint = "I define the application settings and event handlers."
	{

	// I am the application settings.
	this.name = hash( getCurrentTemplatePath() );
	this.applicationTimeout = createTimeSpan( 0, 0, 5, 0 );


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


	/**
	* I initialize the application, setting up persisted objects.
	*
	* @output false
	*/
	public boolean function onApplicationStart() {

		// NOTE: We are going to create and cache the log factory itself in order
		// to ensure that the CFC isn't garbage collected (just eliminating possible
		// referential integrity errors).
		var logFactory = application.logFactory = new LogFactory();

		// Create an instance of our closure-based logger and cache it in the
		// application scope. This way, it will be accessible to future requests
		// contexts beyond the initial application request.
		application.logger = logFactory.createLogger();

		return( true );

	}

}

<cfscript>

	// Check for an application re-initialization script.
	if ( structKeyExists( url, "init" ) ) {

		applicationStop();
		location( cgi.script_name );

	}


	// Let's spawn an asynchronous thread that will invoke the logger beyond the
	// life-span of the current request object.
	thread name = "async-logging" {

		// Ensure parent request finishes before we try to log anything.
		sleep( 2 * 1000 );

		application.logger.log( "Hello from THREAD." );

	}


	// Use the logger from within the current request.
	application.logger.log( "Hello from MAIN request." );

	// Test to see if a cache component method can be invoked by a UDF as long as the
	// UDF was created as part of the current page request.
	// --
	// writeDump( application.logFactory.testFormatter( "hello world" ) );

	// Output all of the messages. While the current Thread message won't be
	// available at this time, we should be able to see messages logged in previous
	// request threads.
	writeDump(
		label = "Messages",
		var = application.logger.getMessages()
	);

</cfscript>