Source: styles/interval.js

let ol = require('openlayers');
let AbstractStyle = require('./abstract');
let UniformStyle = require('./uniform');
let SymbolFabric = require('./../symbols/symbolFabric');
let LegendItem = require('./legendItem');
let IntervalUtils = require('./../math/intervalUtils');

/**
 * Класс IntervalStyle создает стиль, основанный на диапазонных значениях
 * @extends AbstractStyle
 */
class IntervalStyle extends AbstractStyle {
    /**
     * Создает экземпляр стиля типа IntervalStyle
     * @param {object} params - опции создания стиля
     * @param params.geometry {string} - тип геометрии
     * @param params.field {string} - поле классификации
     */
    constructor(params) {
        super(params);
        this.type = "interval";
        this.geometryType = params.geometryType;
        this.params = params;
        this.field = params.field;
        this.styles = this.create(params);
        this.styleDefault = this.createDefault(params);
        this.memoize = {};
    }

   /**
    * Возвращает функцию стиля
    * @return {styleFunction} - функция стиля, определяющая символ объекта
    */
    getStyle() {
        let field = this.field;
        let styles = this.styles;
        let styleDefault = this.styleDefault;
        let params = this.params;
        let memoize = this.memoize;

        const styleFunction = function (feature, resolution) {
            let style = undefined;
            let classify = feature.get(field);
            if (memoize[classify]) return memoize[classify];

            if (classify) {
                try {
                    for (let key in styles) {
                        let intervalExpression = IntervalUtils.parseInterval(key);
                        intervalExpression.value = classify;
                        if (IntervalUtils.inInterval(intervalExpression)) {
                            style = styles[key].style;
                            break;
                        }
                    }
                    style.setText(SymbolFabric().text(params, feature));
                }
                catch (e) {
                    style = styleDefault.style;
                    style.setText(SymbolFabric().text(params, feature));
                }
            }
            memoize[classify] = style;
            return style;
        };
        return styleFunction;
    }

   /**
    * Присвоение стиля
    * @param style
    */
    setStyle(style) {
        this.styles = style;
        this.memoize = {};
    }

   /**
    * Вспомогательный метод, возвращающий массив стилей
    * @return {Array}
    */
    styleArray() {
        let self = this;
        let params = self.params;
        let geometryType = self.geometryType || super.testGeometry(params);
        let styles = [];
        let field = self.field;

        let index = 0;
        let defaultLegendItem = new LegendItem({
            index: index,
            field: field,
            value: undefined,
            style: params.default,
            geometryType: geometryType
        });

        styles.push(defaultLegendItem);

        for (let value in params.values) {
            let properties = {};
            properties[field] = IntervalUtils.parseInterval(value).min;
            let label = field + " в диапазоне " + value;

            let valueLegendItem = new LegendItem({
                index: ++index,
                properties: properties,
                label: label,
                style: params.values[value],
                geometryType: geometryType
            });
            styles.push(valueLegendItem);

        }
        return styles;
    }

   /**
    * Возврат легенды слоя
    * @return {Array}
    */
    legend() {
        return this.styleArray();
    }

   /**
    * Создание (переинициализация) стиля
    * @param params
    * @return {{}}
    */
    create(params) {
        let styleContainer = {};
        let styleParameters = params.values;
        for (let key in styleParameters) {
            styleContainer[key] = new UniformStyle(styleParameters[key])
        }
        return styleContainer;
    }

   /**
    * Значение стиля по умолчанию
    * @param params
    * @return {UniformStyle}
    */
    createDefault(params) {
        let styleParameters = params.default;
        return new UniformStyle(styleParameters);
    }
}


module.exports = IntervalStyle;