com.fr.design.fun.TableDataDefineProvider

/**
 *
 */
package com.fr.base;

import com.fr.config.utils.UniqueKey;
import com.fr.data.TableDataSource;
import com.fr.data.impl.DataCacheKey;
import com.fr.data.impl.ParameterCacheKey;
import com.fr.general.data.DataModel;
import com.fr.script.Calculator;
import com.fr.stable.ParameterProvider;

import java.util.ArrayList;


/**
 * @date: 2014-11-24-上午11:30:22
 */
public abstract class AbstractTableData extends UniqueKey implements TableData {

    /**
     * 克隆
     *
     * @return 克隆的数据集
     * @throws CloneNotSupportedException
     * @date 2014-11-24-上午11:56:19
     */
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    /**
     * 获取当前tabledata所有的列名
     *
     * @param datasource 当前数据源
     * @return 所有列名的数组
     * @date 2014-11-24-上午11:49:07
     */
    public String[] getColumnNames(TableDataSource datasource) {
        return new String[0];
    }

    /**
     * 获取没有权限访问的数据集列表
     *
     * @param toBeRemoveList   没有权限的列表
     * @param nameWillBeRemove 需要移除的对象
     * @param name             当前数据集名
     * @date 2014-11-24-下午3:58:29
     */
    public void registerNoPrivilege(ArrayList<String> toBeRemoveList, String nameWillBeRemove, String name) {

    }


    /**
     * @param calculator     连接上下文计算的算子
     * @param timeoutSeconds 超时单位：秒
     * @return
     */
    public DataModel createDataModelWithTimeout(Calculator calculator, int timeoutSeconds) {
        return createDataModel(calculator);
    }

    public void setParameters(ParameterProvider[] paras) {

    }

    public void filterDataType(Class<?> type) {
    }

    @Override
    public DataCacheKey getDataCacheKey(Calculator calculator) {
        return new ParameterCacheKey(Calculator.processParameters(calculator, getParameters(calculator)));
    }
}

/*
 * Copyright(c) 2001-2010, FineReport Inc, All Rights Reserved.
 */
package com.fr.data;

import com.fr.base.AbstractTableData;
import com.fr.config.holder.factory.XmlHolders;
import com.fr.config.holder.impl.xml.XmlColConf;
import com.fr.general.ComparatorUtils;
import com.fr.general.data.DataModel;
import com.fr.script.Calculator;
import com.fr.stable.ArrayUtils;
import com.fr.stable.ParameterProvider;
import com.fr.stable.script.CalculatorKey;
import com.fr.stable.xml.StableXMLUtils;
import com.fr.stable.xml.XMLPrintWriter;
import com.fr.stable.xml.XMLReadable;
import com.fr.stable.xml.XMLableReader;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * 带参数的数据集的抽象实现，如果需要设计一个带参数的数据集，可以继承此类以简化代码
 */
public abstract class AbstractParameterTableData extends AbstractTableData {

    private static final long serialVersionUID = 7017455818551821178L;
    public static final CalculatorKey ROW_COUNT = CalculatorKey.createKey("rowCount");
    //动态Parameter.
    //参数数组.
    protected XmlColConf<Collection<ParameterProvider>> parameters = XmlHolders.collection(new ArrayList<ParameterProvider>(),ParameterProvider.class);

    /**
     * 获取数据集所使用的参数
     *
     * @param c 算子
     * @return 参数数组
     */
    public ParameterProvider[] getParameters(Calculator c) {
        Collection<ParameterProvider> value = this.parameters.get();
        return value.size() == 0 ? processParameters(c) :  value.toArray(new ParameterProvider[value.size()]);
    }

    @Override
    public void setParameters(ParameterProvider[] parameters) {
        this.parameters.set(ArrayUtils.toList(parameters));
    }

    /**
     * 设置参数
     *
     * @param providers 参数
     */
    protected void setDefaultParameters(ParameterProvider[] providers) {
        this.parameters.set(ArrayUtils.toList(providers));
    }


    /**
     * 将数据集中的${p1}形式的参数解析成运行时的参数值
     *
     * @param calculator 连接上下文运算的算子
     * @return 解析后的参数数组，可以通过获取公式的结果获取解析后的值
     */
    protected ParameterProvider[] processParameters(Calculator calculator) {
        Collection<ParameterProvider> parameterProviders = this.parameters.get();
        return Calculator.processParameters(calculator, parameterProviders.toArray(new ParameterProvider[parameterProviders.size()]));
    }

    public void readXML(XMLableReader reader) {
        if (reader.isChildNode()) {
            String tmpName = reader.getTagName();
            if (ParameterProvider.ARRAY_XML_TAG.equals(tmpName)) {//读取Parameters.
                final List tmpParameterList = new ArrayList();

                reader.readXMLObject(new XMLReadable() {
                    public void readXML(XMLableReader reader) {
                        if (ParameterProvider.XML_TAG.equals(reader.getTagName())) {
                            tmpParameterList.add(StableXMLUtils.readParameter(reader));
                        }
                    }
                });

                //转换数组.
                if (!tmpParameterList.isEmpty()) {
                    this.parameters.set(tmpParameterList);
                }
            }
        }
    }


    public void writeXML(XMLPrintWriter writer) {
        //保存parameters.
        Collection<ParameterProvider> providers = this.parameters.get();
        StableXMLUtils.writeParameters(writer, providers.toArray(new ParameterProvider[providers.size()]));
    }

    public boolean equals(Object obj) {
        return obj instanceof AbstractParameterTableData
                && ComparatorUtils.equals(this.parameters, ((AbstractParameterTableData) obj).parameters);
    }


    /**
     * 克隆
     *
     * @return 克隆的数据集
     * @throws CloneNotSupportedException
     */
    @SuppressWarnings("unchecked")
    public Object clone() throws CloneNotSupportedException {
        AbstractParameterTableData cloned = (AbstractParameterTableData) super.clone();
        cloned.parameters = (XmlColConf<Collection<ParameterProvider>>) this.parameters.clone();
        return cloned;
    }


    /**
     * 创建数据集
     *
     * @param calculator 连接上下文计算的算子
     * @param name       数据集的名字
     * @return 返回数据集
     */
    public DataModel createDataModel(Calculator calculator, String name) {
        return createDataModel(calculator);
    }

    /**
     * 创建数据集
     *
     * @param calculator 连接上下文计算的算子
     * @param rowCount   要获取数据的行数
     * @return 返回数据集
     */
    public DataModel createDataModel(Calculator calculator, int rowCount) {
        calculator.setAttribute(AbstractParameterTableData.ROW_COUNT, rowCount);
        return createDataModel(calculator);
    }
}