Source: resolvers/StorageResolver.js

import { Utils } from '../common/Utils';
import { BaseResolver } from './BaseResolver';

const __ = {
	private: Symbol('private'),
}
function _initPrivateMembers(that, param) {
	that[__.private] = {};
	const _private = that[__.private];

	_private.getIndexByValue = (val) => {
		let key = JSON.stringify(val);
		let index = _private.cache.get(key);
		if (index >= 0) {
			index = _private.storage.length;
			_private.storage.push(val);
			_private.cache.set(key, index);
		}
		return index;
	}
	_private.getValueByIndex = (index) => {
		if (_private.storage.length > index) {
			return _private.storage[index];
		}
		return null;
	}

	_private.init = (param) => {
		if (!param || !param.data) {
			Utils.error("the param is invalid");
			return;
		}
		_private.storage = param.data;
		_private.cache = new Map();
		_private.storage.forEach((item, index) => {
			_private.cache.set(JSON.stringify(item), index);
		});
	}
	_private.init(param);
}

/**
 * @class StorageResolver
 * The storage resolver
 * @memberof THING.EXTEND
 * @extends THING.EXTEND.BaseResolver
 */
class StorageResolver extends BaseResolver {

	constructor(param = {}) {
		super();
		_initPrivateMembers(this, param);
	}

	getIndexByValue(val) {
		let _private = this[__.private];
		return _private.getIndexByValue(val);
	}
	getValueByIndex(index) {
		let _private = this[__.private];
		return _private.getValueByIndex(index);
	}
	getData() {
		let _private = this[__.private];
		return _private.storage;
	}

}

export { StorageResolver }