JuKu / JuKuCMS

	 */

	function _fnSetObjectDataFn( mSource )

	{

		if ( $.isPlainObject( mSource ) )

		{

			/* Unlike get, only the underscore (global) option is used for for

			 * setting data since we don't know the type here. This is why an object

			 * option is not documented for `mData` (which is read/write), but it is

			 * for `mRender` which is read only.

			 */

			return _fnSetObjectDataFn( mSource._ );

		}

		else if ( mSource === null )

		{

			/* Nothing to do when the data source is null */

			return function () {};

		}

		else if ( typeof mSource === 'function' )

		{

			return function (data, val, meta) {

				mSource( data, 'set', val, meta );

			};

		}

		else if ( typeof mSource === 'string' && (mSource.indexOf('.') !== -1 ||

			      mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1) )

		{

			/* Like the get, we need to get data from a nested object */

			var setData = function (data, val, src) {

				var a = _fnSplitObjNotation( src ), b;

				var aLast = a[a.length-1];

				var arrayNotation, funcNotation, o, innerSrc;

				for ( var i=0, iLen=a.length-1 ; i<iLen ; i++ )

				{

					// Check if we are dealing with an array notation request

					arrayNotation = a[i].match(__reArray);

					funcNotation = a[i].match(__reFn);

					if ( arrayNotation )

					{

						a[i] = a[i].replace(__reArray, '');

						data[ a[i] ] = [];

						// Get the remainder of the nested object to set so we can recurse

						b = a.slice();

						b.splice( 0, i+1 );

						innerSrc = b.join('.');

						// Traverse each entry in the array setting the properties requested

						if ( $.isArray( val ) )

						{

							for ( var j=0, jLen=val.length ; j<jLen ; j++ )

							{

								o = {};

								setData( o, val[j], innerSrc );

								data[ a[i] ].push( o );

							}

						}

						else

						{

							// We've been asked to save data to an array, but it

							// isn't array data to be saved. Best that can be done

							// is to just save the value.

							data[ a[i] ] = val;

						}

						// The inner call to setData has already traversed through the remainder

						// of the source and has set the data, thus we can exit here

						return;

					}

					else if ( funcNotation )

					{

						// Function call

						a[i] = a[i].replace(__reFn, '');

						data = data[ a[i] ]( val );

					}

					// If the nested object doesn't currently exist - since we are

					// trying to set the value - create it

					if ( data[ a[i] ] === null || data[ a[i] ] === undefined )

					{

						data[ a[i] ] = {};

					}

					data = data[ a[i] ];

				}

				// Last item in the input - i.e, the actual set

				if ( aLast.match(__reFn ) )

				{

					// Function call

					data = data[ aLast.replace(__reFn, '') ]( val );

				}

				else

				{

					// If array notation is used, we just want to strip it and use the property name

					// and assign the value. If it isn't used, then we get the result we want anyway

					data[ aLast.replace(__reArray, '') ] = val;

				}

			};

			return function (data, val) { // meta is also passed in, but not used

				return setData( data, val, mSource );

			};

		}

		else

		{

			/* Array or flat object mapping */

			return function (data, val) { // meta is also passed in, but not used

				data[mSource] = val;

			};

		}

	}

					data;

			};

		}

		else if ( mSource === null )

		{

			/* Give an empty string for rendering / sorting etc */

			return function (data) { // type, row and meta also passed, but not used

				return data;

			};

		}

		else if ( typeof mSource === 'function' )

		{

			return function (data, type, row, meta) {

				return mSource( data, type, row, meta );

			};

		}

		else if ( typeof mSource === 'string' && (mSource.indexOf('.') !== -1 ||

			      mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1) )

		{

			/* If there is a . in the source string then the data source is in a

			 * nested object so we loop over the data for each level to get the next

			 * level down. On each loop we test for undefined, and if found immediately

			 * return. This allows entire objects to be missing and sDefaultContent to

			 * be used if defined, rather than throwing an error

			 */

			var fetchData = function (data, type, src) {

				var arrayNotation, funcNotation, out, innerSrc;

				if ( src !== "" )

				{

					var a = _fnSplitObjNotation( src );

					for ( var i=0, iLen=a.length ; i<iLen ; i++ )

					{

						// Check if we are dealing with special notation

						arrayNotation = a[i].match(__reArray);

						funcNotation = a[i].match(__reFn);

						if ( arrayNotation )

						{

							// Array notation

							a[i] = a[i].replace(__reArray, '');

							// Condition allows simply [] to be passed in

							if ( a[i] !== "" ) {

								data = data[ a[i] ];

							}

							out = [];

							// Get the remainder of the nested object to get

							a.splice( 0, i+1 );

							innerSrc = a.join('.');

							// Traverse each entry in the array getting the properties requested

							if ( $.isArray( data ) ) {

								for ( var j=0, jLen=data.length ; j<jLen ; j++ ) {

									out.push( fetchData( data[j], type, innerSrc ) );

								}

							}

							// If a string is given in between the array notation indicators, that

							// is used to join the strings together, otherwise an array is returned

							var join = arrayNotation[0].substring(1, arrayNotation[0].length-1);

							data = (join==="") ? out : out.join(join);

							// The inner call to fetchData has already traversed through the remainder

							// of the source requested, so we exit from the loop

							break;

						}

						else if ( funcNotation )

						{

							// Function call

							a[i] = a[i].replace(__reFn, '');

							data = data[ a[i] ]();

							continue;

						}

						if ( data === null || data[ a[i] ] === undefined )

						{

							return undefined;

						}

						data = data[ a[i] ];

					}

				}

				return data;

			};

			return function (data, type) { // row and meta also passed, but not used

				return fetchData( data, type, mSource );

			};

		}

		else

		{

			/* Array or flat object mapping */

			return function (data, type) { // row and meta also passed, but not used

				return data[mSource];

			};

		}

	}