docs: function (logicalPath, cb, args) {
              // get the file item in the cache
              this.$assert(34, this._cache);
              this.$assert(35, cb.scope);
              this.$assert(36, cb.fn);
  
              var cache = this._cache, itm = cache.getItem("files", logicalPath, true), status = itm.status;
  
              // if file already loaded, directly call callback
              if (status == cache.STATUS_AVAILABLE || status == cache.STATUS_ERROR) {
                  var evt = {
                      name : "fileReady",
                      src : this,
                      logicalPaths : [logicalPath],
                      url : null
                  };
                  return this._callback(cb, evt);
              }
  
              // file is not loaded: create a file loader if not already done
              var loader = itm.loader;
              if (!loader) {
                  var ariaCoreFileLoader = require("./FileLoader");
                  this.$assert(63, ariaCoreFileLoader);
  
                  var url;
                  if (args && args.fullLogicalPath) {
                      url = args.fullLogicalPath;
                  } else {
                      url = this.resolveURL(logicalPath);
                  }
  
                  // register the loader in a Cache 'urls' category
                  // we do so as multiple logical path can be associated to the same url
                  // (packaged files served as multipart responses)
                  var urlItm = cache.getItem("urls", url, true);
  
                  if (urlItm.status == this._cache.STATUS_AVAILABLE) {
                      // this url has already been fetch, but file was not retrieved in it
                      var evt = {
                          name : "fileReady",
                          src : this,
                          logicalPaths : [logicalPath],
                          url : url,
                          downloadFailed : true
                      };
                      return this._callback(cb, evt);
                  }
  
                  if (urlItm.loader) {
                      // this loader should be processing as 'files' entry in cache is empty
                      this.$assert(72, urlItm.status == cache.STATUS_LOADING);
                  } else {
                      urlItm.loader = new ariaCoreFileLoader(url);
                      urlItm.status = cache.STATUS_LOADING;
  
                      // register on complete to delete the object when not necessary anymore
                      urlItm.loader.$on({
                          'complete' : this._onFileLoaderComplete,
                          scope : this
                      });
                  }
                  loader = urlItm.loader;
                  // double-reference loader in the 'files' category
                  itm.loader = loader;
                  url = urlItm = null;
              }
  
              // add caller as listener to the FileLoader
              loader.addLogicalPath(logicalPath);
              loader.$on({
                  'fileReady' : {
                      fn : cb.fn,
                      args : cb.args || null,
                      scope : cb.scope
                  }
              });
              loader.loadFile();
          }