mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/VisualEditor
synced 2024-11-15 18:39:52 +00:00
6562b32aa7
A document slice is a document built from a data slice of an existing document. It's completely separate from the original document and has its own store and internalList. The new document's data also contains the entirety of the original document's internal list. It's possible to create a document slice of data located inside the internal list, in which case the resulting document will contain that data twice (one mutable copy at the top level, and one immutable copy in the internal list). ve.dm.Document.js: * Optionally take an internalList in the constructor. This allows us to create a document with a clone of an existing internalList rather than an empty one. * Add edgeMetadata flag to getFullData() ve.dm.IndexValueStore.js, ve.dm.InternalList.js: * Make these classes cloneable Change-Id: I93e06f764ace16aee9df941b07f8c2bff1a28e2b
126 lines
3.3 KiB
JavaScript
126 lines
3.3 KiB
JavaScript
/*!
|
|
* VisualEditor IndexValueStore class.
|
|
*
|
|
* @copyright 2011-2013 VisualEditor Team and others; see AUTHORS.txt
|
|
* @license The MIT License (MIT); see LICENSE.txt
|
|
*/
|
|
|
|
/**
|
|
* Index-value store
|
|
*
|
|
* @class
|
|
* @constructor
|
|
*/
|
|
ve.dm.IndexValueStore = function VeDmIndexValueStore() {
|
|
// maps hashes to indexes
|
|
this.hashStore = {};
|
|
// maps indexes to values
|
|
this.valueStore = [];
|
|
};
|
|
|
|
/* Methods */
|
|
|
|
/**
|
|
* Get the index of a value in the store.
|
|
*
|
|
* If the hash is not found the value is added to the store.
|
|
*
|
|
* @method
|
|
* @param {Object|string|Array} value Value to lookup or store
|
|
* @param {string} [hash] Value hash. Uses ve.getHash( value ) if not provided.
|
|
* @returns {number} The index of the value in the store
|
|
*/
|
|
ve.dm.IndexValueStore.prototype.index = function ( value, hash ) {
|
|
var index;
|
|
if ( typeof hash !== 'string' ) {
|
|
hash = ve.getHash( value );
|
|
}
|
|
index = this.indexOfHash( hash );
|
|
if ( index === null ) {
|
|
if ( ve.isArray( value ) ) {
|
|
index = this.valueStore.push( ve.copyArray( value ) ) - 1;
|
|
} else if ( typeof value === 'object' ) {
|
|
index = this.valueStore.push( ve.cloneObject( value ) ) - 1;
|
|
} else {
|
|
index = this.valueStore.push( value ) - 1;
|
|
}
|
|
this.hashStore[hash] = index;
|
|
}
|
|
return index;
|
|
};
|
|
|
|
/**
|
|
* Get the index of a hash in the store.
|
|
*
|
|
* Returns null if the hash is not found.
|
|
*
|
|
* @method
|
|
* @param {Object|string|Array} hash Value hash.
|
|
* @returns {number|null} The index of the value in the store, or undefined if it is not found
|
|
*/
|
|
ve.dm.IndexValueStore.prototype.indexOfHash = function ( hash ) {
|
|
return hash in this.hashStore ? this.hashStore[hash] : null;
|
|
};
|
|
|
|
/**
|
|
* Get the indexes of values in the store
|
|
*
|
|
* Sames as index but with arrays.
|
|
*
|
|
* @method
|
|
* @param {Object[]} values Values to lookup or store
|
|
* @returns {Array} The indexes of the values in the store
|
|
*/
|
|
ve.dm.IndexValueStore.prototype.indexes = function ( values ) {
|
|
var i, length, indexes = [];
|
|
for ( i = 0, length = values.length; i < length; i++ ) {
|
|
indexes.push( this.index( values[i] ) );
|
|
}
|
|
return indexes;
|
|
};
|
|
|
|
/**
|
|
* Get the value at a particular index
|
|
*
|
|
* @method
|
|
* @param {number} index Index to lookup
|
|
* @returns {Object|undefined} Value at this index, or undefined if out of bounds
|
|
*/
|
|
ve.dm.IndexValueStore.prototype.value = function ( index ) {
|
|
return this.valueStore[index];
|
|
};
|
|
|
|
/**
|
|
* Get the values at a set of indexes
|
|
*
|
|
* Same as value but with arrays.
|
|
*
|
|
* @method
|
|
* @param {number[]} index Index to lookup
|
|
* @returns {Array} Values at these indexes, or undefined if out of bounds
|
|
*/
|
|
ve.dm.IndexValueStore.prototype.values = function ( indexes ) {
|
|
var i, length, values = [];
|
|
for ( i = 0, length = indexes.length; i < length; i++ ) {
|
|
values.push( this.value( indexes[i] ) );
|
|
}
|
|
return values;
|
|
};
|
|
|
|
/**
|
|
* Clone a store.
|
|
*
|
|
* The returned clone is shallow: the valueStore array and the hashStore array are cloned, but
|
|
* the values inside them are copied by reference. These values are supposed to be immutable,
|
|
* though.
|
|
*
|
|
* @returns {ve.dm.IndexValueStore} New store with the same contents as this one
|
|
*/
|
|
ve.dm.IndexValueStore.prototype.clone = function () {
|
|
var key, clone = new this.constructor();
|
|
clone.valueStore = this.valueStore.slice();
|
|
for ( key in this.hashStore ) {
|
|
clone.hashStore[key] = this.hashStore[key];
|
|
}
|
|
return clone;
|
|
}; |