/**
* ModelPath and Model instance method
* Inserts items to the beginning of the array. Returns new length.
*
* @param {List} arguments items to be inserted in the beginning of array
* @return {Integer}
*/
function ModelPath$unshift() { // arguments
var length = this.len();
length += arguments.length;
_.splice(arguments, 0, 0, 0, 0);
this.splice.apply(this, arguments);
return length;
}
/**
* ModelPath and Model instance method
* Adds items to the end of array (or pseudo-array). Returns new length.
*
* @param {List} arguments list of items that will be added to array (pseudo array)
* @return {Integer}
*/
function ModelPath$push() { // arguments
var length = this.len();
var newLength = length + arguments.length;
_.splice(arguments, 0, 0, length, 0);
this.splice.apply(this, arguments);
return newLength;
}
/**
* Model instance method.
* Returns ModelPath object that implements the same API as model but allows access to any point inside model as defined by `accessPath`.
* See [ModelPath](./m_path.js.html) class for more information.
*
* @param {String} accessPath string that defines path to access model.
* Path string consists of parts to define either property access (`".name"` to access property name) or array item access (`"[1]"` to access item with index 1).
* Access path can contain as many parts as necessary (e.g. `".list[0].name"` to access property `name` in the first element of array stored in property `list`.
* @param {List} arguments additional arguments of this method can be used to create interpolated paths.
* E.g. `m.path("[$1].$2", id, prop)` returns ModelPath to access property with name `prop` in array item with index `id`. Although this ModelPath object will work exactly as `m("[" + id + "]." + prop)`, the interpolated is much more efficient as ModelPath with interpolation will not synthesize new getters and setters, while ModelPath with computed access path will synthesize new getters and setters for each pair of values of `id` and `prop`.
* @return {ModelPath}
*/
function Model$path(accessPath) { // , ... arguments that will be interpolated
if (! accessPath) return this;
// "null" is context to pass to ModelPath, first parameter of bind
// "this" (model) is added in front of all arguments
_.splice(arguments, 0, 0, null, this);
// calling ModelPath constructor with new and the list of arguments: this (model), accessPath, ...
return new (Function.prototype.bind.apply(ModelPath, arguments));
}