Class ilib.Loader

Example:

 {
     "/usr/share/javascript/ilib/locale": [
         "dateformats.json",
         "aa/dateformats.json",
         "af/dateformats.json",
         "agq/dateformats.json",
         "ak/dateformats.json",
         ...
         "zxx/dateformats.json"
     ]
 }
 

This is the main function define a callback function for loading missing locale data or resources. If this copy of ilib is assembled without including the required locale data or resources, then that data can be lazy loaded dynamically when it is needed by calling this method. Each ilib class will first check for the existence of data under ilib.data, and if it is not there, it will attempt to load it by calling this method of the laoder, and then place it there.

Suggested implementations of this method might load files directly from disk under nodejs or rhino, or within web pages, to load files from the server with XHR calls.

The first parameter to this method, paths, is an array of relative paths within the ilib dir structure for the requested data. These paths will already have the locale spec integrated into them, so no further tweaking needs to happen to load the data. Simply load the named files. The second parameter tells the loader whether to load the files synchronously or asynchronously. If the sync parameters is false, then the onLoad function must also be specified. The third parameter gives extra parameters to the loader passed from the calling code. This may contain any property/value pairs. The last parameter, callback, is a callback function to call when all of the data is finishing loading. Make sure to call the callback with the context of "this" so that the caller has their context back again.

The loader function must be able to operate either synchronously or asychronously. If the loader function is called with an undefined callback function, it is expected to load the data synchronously, convert it to javascript objects, and return the array of json objects as the return value of the function. If the loader function is called with a callback function, it may load the data synchronously or asynchronously (doesn't matter which) as long as it calls the callback function with the data converted to a javascript objects when it becomes available. If a particular file could not be loaded, the loader function should put undefined into the corresponding entry in the results array. Note that it is important that all the data is loaded before the callback is called.

An example implementation for nodejs might be:

var fs = require("fs");

var myLoader = function() {};
myLoader.prototype = new ilib.Loader();
myLoader.prototype.constructor = myLoader;
myLoader.prototype.loadFiles = function(paths, sync, params, callback) {
   if (sync) {
       var ret = [];
       // synchronous load -- just return the result
       paths.forEach(function (path) {
           var json = fs.readFileSync(path, "utf-8");
           ret.push(json ? JSON.parse(json) : undefined);
       });
       
       return ret;
   }
   this.callback = callback;

   // asynchronous
   this.results = [];
   this._loadFilesAsync(paths);
}
myLoader.prototype._loadFilesAsync = function (paths) {
   if (paths.length > 0) {
       var file = paths.shift();
       fs.readFile(file, "utf-8", function(err, json) {
           this.results.push(err ? undefined : JSON.parse(json));
           // call self recursively so that the callback is only called at the end
           // when all the files are loaded sequentially
           if (paths.length > 0) {
               this._loadFilesAsync(paths);
           } else {
               this.callback(this.results);
           }
       });
    }
}

// bind to "this" so that "this" is relative to your own instance
ilib.setLoaderCallback(new myLoader());