/**
 * @requires Cobalt.Core
 * @requires Cobalt.Core.Application 
 *
 * @param {Cobalt.Core.Application} application
 * @constructor
 * @private
 */
Cobalt.Core.Sandbox = function(application)
{
    this._application = application;
    this._domItem = null;
};

/**
 *
 * @param {Cobalt.Core.Application} application
 * 
 * @returns {Cobalt.Core.Sandbox}
 */
Cobalt.Core.Sandbox.getInstance = function(application)
{
    return new Cobalt.Core.Sandbox(application);
};

/**
 *
 * @param {String} name of module
 * @return {Object} "namespace" that holds the data for module
 */
Cobalt.Core.Sandbox.prototype.getDataScope = function(moduleName)
{
    this._verifyDependencyMethod(this._application, "getDataScope");
    return this._application.getDataScope(moduleName);
};

/**
 *
 * @param {String} id
 * @return {DomElement}
 */
Cobalt.Core.Sandbox.prototype.getElementById = function(id)
{
    this._verifyDependencyMethod(this._application, "getElementById");
    return this._application.getElementById(id);
};

/**
 * Attach a handler for the given anchor on the event
 * example:
 *    sandbox.listen(newCategoryElement, "click", onNewCategorySeleced, this);
 *
 * @param {Object} anchor anchor nullable, if null, then listening for broadcast events
 * @param {String} eventName
 * @param {Function} handler
 * @param {Object} eventData
 *
 * @return {Cobalt.Core.Sandbox}
 */
Cobalt.Core.Sandbox.prototype.listen = function(anchor, eventName, handler, eventData)
{
    this._verifyDependencyMethod(this._application, "listen");
    this._application.listen(anchor, eventName, handler, eventData);
    return this;
};
Cobalt.Core.Sandbox.prototype.removeListeners = function(anchor, eventName)
{
    this._verifyDependencyMethod(this._application, "removeListeners");
    this._application.removeListeners(anchor, eventName);
    return this;
};

/**
 * perform an ajax post request
 *
 * options : {
 *  requestData : "data",
 *  success: function(response) { },
 *  failure: function(response) { }
 * }
 * @param {Object} options
 *
 * @return {Cobalt.Core.Sandbox}
 */
Cobalt.Core.Sandbox.prototype.request = function(options)
{
    this._verifyDependencyMethod(this._application, "request");
    this._application.request(options);
    return this;
};

/**
 * Triggers an event on the anchor object
 * example:
 *    app.raise(anyAnchor, eventName, anyData);
 *
 * @param {Object} anchor nullable, if null, then broadcast an event
 * @param {String} eventName
 * @param {Object} eventData
 *
 * @return {Cobalt.Core.Sandbox}
 */
Cobalt.Core.Sandbox.prototype.raise = function(anchor, eventName, eventData)
{
    this._verifyDependencyMethod(this._application, "raise");
    this._application.raise(anchor, eventName, eventData);
    return this;
};

/**
 * Works with xml and Html element
 * @param {String} attributeName
 * @param {String} attributeValue
 * @return {String} if attributeValue not set
 */
Cobalt.Core.Sandbox.prototype.attr = function(attributeName, attributeValue)
{
    this._verifyDependencyMethod(this._application, "attr");
    return this._application.attr(this._domItem, attributeName, attributeValue);
};

/**
 * Maybe html or xml dom element
 * @param {DomElement} domItem
 * @return {Cobalt.Core.Sandbox}
 */
Cobalt.Core.Sandbox.prototype.dom = function(domItem)
{
    this._domItem = domItem;
    return this;
};

/**
 * Like the dom method, but with a usable return value (the jQuery object)
 * @param {generic} domItem
 * @return {function that returns selected elements based on domItem}
 */
Cobalt.Core.Sandbox.prototype.elems = function(domItem) {
    this._verifyDependencyMethod(this._application,'getDomElements');
    return this._application.getDomElements(domItem);
}

Cobalt.Core.Sandbox.prototype.domCache = function(domItem) {
    this._domItem = domItem;
    this._application.addDomCache(this._domItem);
    return this;
};

/**
 *
 * @param {String} replaceString
 *
 */
Cobalt.Core.Sandbox.prototype.html = function(replaceString)
{
    this._verifyDependencyMethod(this._application, "html");
    if (typeof replaceString !== "undefined" || replaceString !== null)
    {
        this._application.html(this._domItem, replaceString);
        return this;
    }
};

/**
 *
 * @param {String} replaceString
 *
 */
Cobalt.Core.Sandbox.prototype.replaceWith = function(replaceString)
{
    this._verifyDependencyMethod(this._application, "replaceWith");
    if (typeof replaceString !== "undefined" || replaceString !== null)
    {
        this._application.replaceWith(this._domItem, replaceString);
        return this;
    }
};

/**
 *
 * @return {String} elementment text
 *
 */
Cobalt.Core.Sandbox.prototype.text = function(param)
{
    this._verifyDependencyMethod(this._application, "text");
    return this._application.text(this._domItem, param);
};

/**
 *
 * @param {Function} funcPtr the function to be evaulated per iteration
 * @return {Cobalt.Core.Sandbox}
 */
Cobalt.Core.Sandbox.prototype.each = function(funcPtr)
{
    this._verifyDependencyMethod(this._application, "each");
    this._application.each(this._domItem,  funcPtr);
    return this;
};

Cobalt.Core.Sandbox.prototype.load = function(funcPtr)
{
    this._verifyDependencyMethod(this._application, "load");
    this._application.load(this._domItem,  funcPtr);
    return this;
};

Cobalt.Core.Sandbox.prototype.error = function(funcPtr)
{
    this._verifyDependencyMethod(this._application, "error");
    this._application.error(this._domItem,  funcPtr);
    return this;
};

/**
 *
 * @param {Function} funcPtr the function to be evaulated per iteration
 * @return {Cobalt.Core.Sandbox}
 */
Cobalt.Core.Sandbox.prototype.listenLive = function(event, handler, context)
{
    this._verifyDependencyMethod(this._application, "listenLive");
    this._application.listenLive(this._domItem, event, handler, context);
    return this;
};

/**
 *
 * @param {String} attributeName
 * @param {String} attributeValue if this is null or undefined, all elements having attributeName will be returned
 * @return {Array<DomElements>} array of DomElements
 */
Cobalt.Core.Sandbox.prototype.getElementsByAttribute = function(attributeName, attributeValue)
{
    this._verifyDependencyMethod(this._application, "getElementsByAttribute");
    return this._application.getElementsByAttribute(attributeName, attributeValue);
};

/**
 *
 * @param {Object} Raw XML data
 * @return Serialised XML data
 */
Cobalt.Core.Sandbox.prototype.getXmlElementTextValue = function(xmlElement)
{
    this._verifyDependencyMethod(this._application, "getXmlElementTextValue");
    return this._application.getXmlElementTextValue(xmlElement);
};

/**
 *
 * @param {DomElement} element
 * @param {String} parameter
 * @return boolean
 */
Cobalt.Core.Sandbox.prototype.is = function(param)
{
    this._verifyDependencyMethod(this._application, "is");
    return this._application.is(this._domItem, param);
};

/**
 *
 * @param {DomElement} element
 * @param {String} or {Number} parameter
 */
Cobalt.Core.Sandbox.prototype.show = function(param)
{
    this._verifyDependencyMethod(this._application, "show");
    return this._application.show(this._domItem, param);
};

/**
 *
 * @param {String} or {Number} parameter
 */
Cobalt.Core.Sandbox.prototype.hide = function(param)
{
    this._verifyDependencyMethod(this._application, "hide");
    return this._application.hide(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.animate = function(properties, duration, effect, callback)
{
    this._verifyDependencyMethod(this._application, "animate");
    return this._application.animate(this._domItem, properties, duration, effect, callback);
};

Cobalt.Core.Sandbox.prototype.slideUp = function(callback, options)
{
    this._verifyDependencyMethod(this._application, "slideUp");
    return this._application.slideUp(this._domItem, callback, options);
};

Cobalt.Core.Sandbox.prototype.slideDown = function(callback, options)
{
    this._verifyDependencyMethod(this._application, "slideDown");
    return this._application.slideDown(this._domItem, callback, options);
};

Cobalt.Core.Sandbox.prototype.slideToggle = function(callback, options)
{
    this._verifyDependencyMethod(this._application, "slideToggle");
    return this._application.slideToggle(this._domItem, callback, options);
};

Cobalt.Core.Sandbox.prototype.fadeIn = function(duration, callback)
{
    this._verifyDependencyMethod(this._application, "fadeIn");
    return this._application.fadeIn(this._domItem, duration, callback);
};

Cobalt.Core.Sandbox.prototype.fadeOut = function(duration, callback)
{
    this._verifyDependencyMethod(this._application, "fadeOut");
    return this._application.fadeOut(this._domItem, duration, callback);
};

/**
 *
 * @param {String} param
 */
Cobalt.Core.Sandbox.prototype.find = function(param)
{
    this._verifyDependencyMethod(this._application, "find");
    return this._application.find(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.children = function(param)
{
    this._verifyDependencyMethod(this._application, "children");
    return this._application.children(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.parents = function(param)
{
    this._verifyDependencyMethod(this._application, "parents");
    return this._application.parents(this._domItem, param);
};
Cobalt.Core.Sandbox.prototype.closest = function(param)
{
    this._verifyDependencyMethod(this._application, "closest");
    return this._application.closest(this._domItem, param);
};
Cobalt.Core.Sandbox.prototype.prependTo = function(param)
{
    this._verifyDependencyMethod(this._application, "prependTo");
    return this._application.prependTo(this._domItem, param);
};
/*ADDED*/
Cobalt.Core.Sandbox.prototype.length = function()
{
    this._verifyDependencyMethod(this._application, "length");
    return this._application.length(this._domItem);
};

Cobalt.Core.Sandbox.prototype.size = function()
{
    this._verifyDependencyMethod(this._application, "size");
    return this._application.size(this._domItem);
};

Cobalt.Core.Sandbox.prototype.get = function(param)
{
    this._verifyDependencyMethod(this._application, "get");
    return this._application.get(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.height = function(param)
{
    this._verifyDependencyMethod(this._application, "height");
    return this._application.height(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.width = function(param)
{
    this._verifyDependencyMethod(this._application, "width");
    return this._application.width(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.outerHeight = function(param)
{
    this._verifyDependencyMethod(this._application, "outerHeight");
    return this._application.outerHeight(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.outerWidth = function(param)
{
    this._verifyDependencyMethod(this._application, "outerWidth");
    return this._application.outerWidth(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.scroll = function(param) {
//    this._verifyDependencyMethod((this._application,"scroll"));
    return this._application.scroll(this._domItem, param)
};

Cobalt.Core.Sandbox.prototype.scrollEnd = function(param) {
    return this._application.scrollEnd(this._domItem, param);

};

Cobalt.Core.Sandbox.prototype.scrollTop = function(param)
{
    this._verifyDependencyMethod(this._application, "scrollTop");
    return this._application.scrollTop(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.scrollLeft = function(param)
{
    this._verifyDependencyMethod(this._application, "scrollLeft");
    return this._application.scrollLeft(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.scrollTo = function(x, y)
{
    this._verifyDependencyMethod(this._application, "scrollTo");
    return this._application.scrollTo(x, y);
};
Cobalt.Core.Sandbox.prototype.openLocation = function(uri)
{
    this._verifyDependencyMethod(this._application, "openLocation");
    return this._application.openLocation(uri);
};

Cobalt.Core.Sandbox.prototype.next = function(param)
{
    this._verifyDependencyMethod(this._application, "next");
    return this._application.next(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.prev = function(param)
{
    this._verifyDependencyMethod(this._application, "prev");
    return this._application.prev(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.removeClass = function(param)
{
    this._verifyDependencyMethod(this._application, "removeClass");
    return this._application.removeClass(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.removeAttr = function(param)
{
    this._verifyDependencyMethod(this._application, "removeAttr");
    return this._application.removeAttr(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.not = function(param)
{
    this._verifyDependencyMethod(this._application, "not");
    return this._application.not(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.addClass = function(param)
{
    this._verifyDependencyMethod(this._application, "addClass");
    return this._application.addClass(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.hasClass = function(param)
{
    this._verifyDependencyMethod(this._application, "hasClass");
    return this._application.hasClass(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.index = function(param)
{
    this._verifyDependencyMethod(this._application, "index");
    return this._application.index(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.getDomElements = function()
{
    if (!this._domItem) return null;
    
    this._verifyDependencyMethod(this._application, "getDomElements");
    return this._application.getDomElements(this._domItem);
};
Cobalt.Core.Sandbox.prototype.createDomElement = function(element)
{
    this._verifyDependencyMethod(this._application, "createDomElement");
    return this._application.createDomElement(element);
};
Cobalt.Core.Sandbox.prototype.append = function(param)
{
    this._verifyDependencyMethod(this._application, "append");
    return this._application.append(this._domItem, param);
};
Cobalt.Core.Sandbox.prototype.wrapAll = function(param)
{
    this._verifyDependencyMethod(this._application, "wrapAll");
    return this._application.wrapAll(this._domItem, param);
};
Cobalt.Core.Sandbox.prototype.parseJSON = function(json)
{
    this._verifyDependencyMethod(this._application, "parseJSON");
    return this._application.parseJSON(json);
};
Cobalt.Core.Sandbox.prototype.parent = function(param)
{
    this._verifyDependencyMethod(this._application, "parent");
    return this._application.parent(this._domItem, param);
};
Cobalt.Core.Sandbox.prototype.parents = function(param)
{
    this._verifyDependencyMethod(this._application, "parents");
    return this._application.parents(this._domItem, param);
};
Cobalt.Core.Sandbox.prototype.position = function()
{
    this._verifyDependencyMethod(this._application, "position");
    return this._application.position(this._domItem);
};
Cobalt.Core.Sandbox.prototype.offset = function()
{
    this._verifyDependencyMethod(this._application, "offset");
    return this._application.offset(this._domItem);
};
Cobalt.Core.Sandbox.prototype.addStyle = function(param)
{
    this._verifyDependencyMethod(this._application, "addStyle");
    return this._application.addStyle(this._domItem, param);
};
Cobalt.Core.Sandbox.prototype.css = function(prop, val)
{
    this._verifyDependencyMethod(this._application, "css");
    return this._application.css(this._domItem, prop, val);
};
Cobalt.Core.Sandbox.prototype.remove = function(param)
{
    this._verifyDependencyMethod(this._application, "remove");
    return this._application.remove(this._domItem, param);
};
Cobalt.Core.Sandbox.prototype.empty = function(param)
{
    this._verifyDependencyMethod(this._application, "empty");
    return this._application.empty(this._domItem, param);
};
Cobalt.Core.Sandbox.prototype.detach = function(param)
{
    this._verifyDependencyMethod(this._application, "detach");
    return this._application.detach(this._domItem, param);
};
Cobalt.Core.Sandbox.prototype.before = function(param)
{
    this._verifyDependencyMethod(this._application, "before");
    return this._application.before(this._domItem, param);
};
Cobalt.Core.Sandbox.prototype.innerHTML = function(param)
{
    this._verifyDependencyMethod(this._application, "innerHTML");
    return this._application.innerHTML(this._domItem, param);
};
Cobalt.Core.Sandbox.prototype.val = function(param)
{
    this._verifyDependencyMethod(this._application, "val");
    return this._application.val(this._domItem, param);
};


Cobalt.Core.Sandbox.prototype.embedFlash = function(options)
{
    this._verifyDependencyMethod(this._application, "embedFlash");
    return this._application.embedFlash(options);
};

Cobalt.Core.Sandbox.prototype.firePixelTag = function(data)
{
    this._verifyDependencyMethod(this._application, "firePixelTag");
    return this._application.firePixelTag(data);
};

Cobalt.Core.Sandbox.prototype.trackExternalLinkout = function(linkData, pixelTagData)
{
    this._verifyDependencyMethod(this._application, "trackExternalLinkout");
    return this._application.trackExternalLinkout(linkData, pixelTagData);
};

Cobalt.Core.Sandbox.prototype.tabs = function(param, options)
{
    this._verifyDependencyMethod(this._application, "tabs");
    return this._application.tabs(this._domItem, param, options);
};

Cobalt.Core.Sandbox.prototype.datepicker = function(param, options, val)
{
    this._verifyDependencyMethod(this._application, "datepicker");
    return this._application.datepicker(this._domItem, param, options, val);
};

Cobalt.Core.Sandbox.prototype.dialog = function(param, options)
{
    this._verifyDependencyMethod(this._application, "dialog");
    return this._application.dialog(this._domItem, param, options);
};

Cobalt.Core.Sandbox.prototype.tablesorter = function(options)
{
    this._verifyDependencyMethod(this._application, "tablesorter");
    return this._application.tablesorter(this._domItem, options);
};

Cobalt.Core.Sandbox.prototype.carousel = function(func)
{
    this._verifyDependencyMethod(this._application, "carousel");
    return this._application.carousel(this._domItem, func);
};

Cobalt.Core.Sandbox.prototype.bind = function(eventType, func)
{
    this._verifyDependencyMethod(this._application, "bind");
    return this._application.bind(this._domItem, eventType, func);
};

Cobalt.Core.Sandbox.prototype.click = function(func)
{
    this._verifyDependencyMethod(this._application, "click");
    return this._application.click(this._domItem, func);
};

Cobalt.Core.Sandbox.prototype.focus = function(func)
{
    this._verifyDependencyMethod(this._application, "focus");
    return this._application.focus(this._domItem, func);
};

Cobalt.Core.Sandbox.prototype.blur = function(func)
{
    this._verifyDependencyMethod(this._application, "blur");
    return this._application.blur(this._domItem, func);
};

Cobalt.Core.Sandbox.prototype.serialize = function()
{
    this._verifyDependencyMethod(this._application, "serialize");
    return this._application.serialize(this._domItem);
};

Cobalt.Core.Sandbox.prototype.cbltslider = function(options)
{
    this._verifyDependencyMethod(this._application, "cbltslider");
    return this._application.cbltslider(this._domItem, options);
};

Cobalt.Core.Sandbox.prototype.clone = function()
{
    this._verifyDependencyMethod(this._application, "clone");
    return this._application.clone(this._domItem);
};

Cobalt.Core.Sandbox.prototype.extend = function(obj1, obj2)
{
    this._verifyDependencyMethod(this._application, "extend");
    return this._application.extend(obj1, obj2);
};

Cobalt.Core.Sandbox.prototype.extendNew = function(obj1, obj2, obj3)
{
    this._verifyDependencyMethod(this._application, "extendNew");
    return this._application.extendNew(obj1, obj2, obj3);
};

Cobalt.Core.Sandbox.prototype.globalMethod = function(name, callback)
{
    this._verifyDependencyMethod(this._application, "globalMethod");
    return this._application.globalMethod(name, callback);
};

Cobalt.Core.Sandbox.prototype.appendTo = function(target)
{
    this._verifyDependencyMethod(this._application, "appendTo");
    return this._application.appendTo(this._domItem, target);
};

Cobalt.Core.Sandbox.prototype.data = function(element, key, value)
{
    this._verifyDependencyMethod(this._application, "data");
    return this._application.data(this._domItem, element, key, value);
};

Cobalt.Core.Sandbox.prototype.submit = function(callback)
{
    this._verifyDependencyMethod(this._application, "submit");
    return this._application.submit(this._domItem, callback);
};

Cobalt.Core.Sandbox.prototype.browser = function()
{
	this._verifyDependencyMethod(this._application, "browser");
    return this._application.browser();
};

Cobalt.Core.Sandbox.prototype.autocomplete = function(options)
{
    this._verifyDependencyMethod(this._application, "autocomplete");
    return this._application.autocomplete(this._domItem, options);
};

Cobalt.Core.Sandbox.prototype.iPhoneStyleToggle = function(options)
{
    this._verifyDependencyMethod(this._application, "iPhoneStyleToggle");
    return this._application.iPhoneStyleToggle(this._domItem, options);
};

Cobalt.Core.Sandbox.prototype.getJSON = function(url, data, callback)
{
    this._verifyDependencyMethod(this._application, "getJSON");
    return this._application.getJSON(url, data, callback);  
};

Cobalt.Core.Sandbox.prototype.placeholder = function(options)
{
    this._verifyDependencyMethod(this._application, "placeholder");
    return this._application.placeholder(this._domItem, options);
};

Cobalt.Core.Sandbox.prototype.support = function()
{
    this._verifyDependencyMethod(this._application, "support");
    return this._application.support();
};
Cobalt.Core.Sandbox.prototype.throttle = function(method, scope)
{
    this._verifyDependencyMethod(this._application, "throttle");
    return this._application.throttle(method, scope);
};

Cobalt.Core.Sandbox.prototype.toggle = function(param)
{
    this._verifyDependencyMethod(this._application, "toggle");
    return this._application.toggle(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.die = function(param)
{
    this._verifyDependencyMethod(this._application, "die");
    return this._application.die(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.getFrameWindowByName = function(frameName) {
    this._verifyDependencyMethod(this._application, "getFrameWindowByName");
    return this._application.getFrameWindowByName(frameName);
};

Cobalt.Core.Sandbox.prototype.setInterval = function(func, time) {
    this._verifyDependencyMethod(this._application, "setInterval");
    return this._application.setInterval(func, time);
};

Cobalt.Core.Sandbox.prototype.getGlobalVariable = function(name) {
    this._verifyDependencyMethod(this._application, "getGlobalVariable");
    return this._application.getGlobalVariable(name);
};

Cobalt.Core.Sandbox.prototype.setGlobalVariable = function(name, value) {
    this._verifyDependencyMethod(this._application, "setGlobalVariable");
    this._application.getGlobalVariable(name, value);
    return this;
};

Cobalt.Core.Sandbox.prototype.delay = function(param) {
    this._verifyDependencyMethod(this._application, "delay");
    return this._application.delay(this._domItem, param);
};

Cobalt.Core.Sandbox.prototype.trim = function(param) {
    this._verifyDependencyMethod(this._application, "trim");
    return this._application.trim(param);
};

Cobalt.Core.Sandbox.prototype.sortelements = function(comparator, options)
{
    this._verifyDependencyMethod(this._application, "sortelements");
    return this._application.sortelements(this._domItem, comparator, options);
};

Cobalt.Core.Sandbox.prototype.safetynetfn = function(options)
{
    this._verifyDependencyMethod(this._application, "safetynetfn");
    return this._application.safetynetfn(this._domItem, options);
};

Cobalt.Core.Sandbox.prototype.getSafetynetObj = function()
{
    return this._application.getSafetynetObj();
};

Cobalt.Core.Sandbox.prototype.jScrollPane = function(options)
{
	this._verifyDependencyMethod(this._application, "jScrollPane");
    return this._application.jScrollPane(this._domItem, options);
};

Cobalt.Core.Sandbox.prototype.copyToClipboard = function(options)
{
	this._verifyDependencyMethod(this._application, "copyToClipboard");
    return this._application.copyToClipboard(this._domItem, options);
};

Cobalt.Core.Sandbox.prototype.zAccordion = function(options)
{
	this._verifyDependencyMethod(this._application, "zAccordion");
    return this._application.zAccordion(this._domItem, options);
};

Cobalt.Core.Sandbox.prototype.getDomQueryInstance = function() {
	this._verifyDependencyMethod(this._application, "getDomQueryInstance");
    return this._application.getDomQueryInstance();
};
Cobalt.Core.Sandbox.prototype.insertAfter = function(selector) {
	this._verifyDependencyMethod(this._application, "insertAfter");
    return this._application.insertAfter(this._domItem, selector);
};

Cobalt.Core.Sandbox.prototype._verifyDependencyMethod = function(obj, propertyName)
{
    if (typeof obj[propertyName] !== "function") {
        throw new Error("Sandbox => dependency method '" +  propertyName + "' does not exist");
    }
};