logplus/Workflow/WFEngine/Module/include/ParameterItem.h

/**
 * @file   ParameterItem.h
 * @brief  文件定义了与参数项相关的类与接口
 * @author dev
 * @date   2011-8-29
 */

#ifndef PAI_FRAME_MODULEAPI_PARAMETERITEM_H
#define PAI_FRAME_MODULEAPI_PARAMETERITEM_H

#include <string>
#include <sstream>
#include <map>
#include <vector>
#include "Turtle.h"
#include<iostream>
#include <QString>
namespace pai {
namespace module {

const std::string PARAMETER_CATEGORY_INPUT_TRACEFILTER = "TraceFilter";
const std::string PARAMETER_CATEGORY_INPUT_OUTPUT = "Output";
const std::string PARAMETER_CATEGORY_INPUT_FILES = "Files";
const std::string PARAMETER_CATEGORY_INPUT_ADDTIONAL = "Addtional";
const std::string PARAMETER_CATEGORY_INPUT_TIME = "Time";

/**
 * @brief 参数类型
 */
enum ParameterType
{
    ParmType_INT,       /**< Int类型参数 */
    ParmType_FLOAT,     /**< Float类型参数 */
    ParmType_DOUBLE,    /**< Double类型参数 */
    ParmType_STRING,    /**< String类型参数 */
    ParmType_BOOL,      /**< Bool类型参数 */
    ParmType_LONG,      /**< Long类型参数 */
    ParmType_ARRAY,     /**< Array类型参数 */
    ParmType_CUSTOM     /**< Custom类型参数 */
};
/**
 * @brief 参数输入控件类型
 */
enum ParameterInputType
{
	TEXTEDIT,           /**< 文本输入控件 */
	FILESAVEBROWER,     /**< 文件保存控件*/
	COMBOX,             /**< 带输入的下拉控件*/
	RADIOBOX,           /**< 单选框*/
	CHECKBOX,           /**< 复选框*/
	RADIOBUTTON,        /**< 单选按钮*/
	FILEBROWSER,        /**< 文件浏览*/
	HDFSFILEBROWSER,    /**< HDFS文件浏览*/
	HDFSFILEEDITOR,     /**< HDFS文件编辑*/
	EDITABLEDGRID,      /**< 编辑表格*/
	SPINBOX,            /**< */
	DOUBLESPINBOX,      /**< */
	SPLIT,              /**< 分隔*/
	NONEINPUT,          /**< 无输入*/

};
/**
 * @brief 这个枚举描述了一个参数项的输入控件中允许拖拽进哪些类型的数据
 */
enum AcceptDropType
{
	None = 0,
	SEISMIC = 1,  	  ///<该输入控件允许拖拽进地震数据
	SPS = 2,		  ///<该输入控件允许拖拽进SPS数据
	VELOCITYPAIR = 4, ///<该输入控件允许拖拽进速度对数据
	VELOCITYMODEL = 8, ///<该输入控件允许拖拽进速度模型数据
	GRID = 16,		   ///<该输入控件允许拖拽进网格数据
	MUTE = 32,			///<该输入控件允许拖拽进切除数据
	TRACEEDIT = 64,		///<该输入控件允许拖拽进道编辑数据
	FIRSTBREAK = 128,	///<该输入控件允许拖拽进初至拾取数据
	STATICS = 256,		///<该输入控件允许拖拽进静校正数据
	HORIZON = 512,		///<该输入控件允许拖拽进层位面数据
	SPECTRUMDATA = 1024, ///<该输入控件允许拖拽速度普数据
	SPATIALATTRIBUTE = 2048, ///<该输入控件允许拖拽属性数据

};
/**
 * @brief ParameterCompleteIndex这个枚举用来刻画一个参数集合的填写完备程度
 */
enum ParameterCompleteIndex
{
	ParamPerfect,///<参数全部可用
	ParamWarning,///<存在空的必填项，在该必填项之后的参数项均未设置值
	ParamError ///<存在空的必填项，该空的必填项之后的参数项却被设置了值
};
/**
 * @class CParameterItem
 * @brief 模块参数项，表述了模块的一个参数所拥有的类型，名字，值以及约束等等
 */
class PAI_MODULE_EXPORT CParameterItem {

public:
	/**
	 * @brief 重载=运算符
	 */
	CParameterItem& operator=(const CParameterItem& otherItem);
    /**
     * @brief 构造函数
     */
	CParameterItem();
	/**
	 * @brief 拷贝构造函数
	 * @param[in] srcItem 拷贝来源
	 */
	CParameterItem(const CParameterItem& srcItem);
	virtual ~CParameterItem();

    /**
     * @brief 从srcItem copy对象
     * @param[in] srcItem copy来源
     */
    void Copy(const CParameterItem& srcItem);

    /**
    * @brief 重载相等符号==,判断两个参数项是否相等
    * @param[in] otherItem 对比对象
    */
    bool operator==(const CParameterItem& otherItem) const;

    /**
     * @brief 获取参数项的值
     * @param[in/out] bOK 是否返回取的值是否正确的结果
     * @return 参数项的值
     */
	template <typename T>
	T GetValue(T defaultValue =0 ,bool* bOK=0) const
	{
		T value = defaultValue;
        std::stringstream ss(m_strValue);
        ss >> value;
        if(bOK)
        {
            *bOK = !(ss.fail());
        }
		return value;
	};

	template <typename T>
	T* GetPointerValue() const
	{
		T* pointer;
		long pointeraddress;
		std::stringstream ss(m_strValue);
		ss >> pointeraddress;
		pointer=reinterpret_cast<T*>(pointeraddress);
		return pointer;
	};

    template <typename T>
    T ValueToT(ParameterType eType,T defaultValue,bool* bOK) const
    {
        if(m_eType==eType)
        {
            return GetValue<T>(defaultValue,bOK);
        }
        if(bOK!=NULL)
        {
            *bOK=false;
        }
        return defaultValue;
    };
    /**
     * @brief 将值转换为布尔型
     * @param[in/out] bOK 转换成功与否的标志
     * @return 布尔类型的值
     */
    bool ValueToBool(bool* bOK=0) const;
	/**
	 * @brief 将值转换为整型
	 * @param[in/out] bOK 转换成功与否的标志
	 * @return 整型值
	 */
	int ValueToInt(bool* bOK=0) const;
    /**
     * @brief 将值转换为长整型
     * @param[in/out] bOK 转换成功与否的标志
     * @return 长整型值
     */
    long ValueToLong(bool* bOK=0) const;
	/**
	 * @brief 将值转换为单精度浮点型
	 * @param[in/out] bOK 转换成功与否的标志
	 * return 单精度浮点类型的值
	 */
	float ValueToFloat(bool* bOK=0) const;
	/**
	 * @brief 将值转换为双精度浮点型
	 * @param[in/out] bOK 转换成功与否的标志
	 * @return 双精度浮点值
	 */
	double ValueToDouble(bool* bOK=0) const;
	/**
	 * @brief 将值转换为字符串
	 * @return 值的字符串形式
	 */
	virtual std::string ValueToString() const;

	template <typename T>
	void SetValue(T value)
	{
		std::stringstream ss;
		ss << value;
		m_strValue=ss.str();
	};

	template <typename T>
	void SetPointerValue(T* pointer)
	{
		std::stringstream ss;
		ss << reinterpret_cast<long>(pointer);
		m_strValue=ss.str();
	};


	/**
	 * @brief 设置参数值
	 * @param[in] strValue 参数值
	 */
	void SetStringValue(const std::string& strValue);
	/**
	 * @brief 获取参数值的字符串格式
	 * @return 参数值的字符串形式
	 */
	virtual std::string GetStringValue() const;

	/**
	 * @brief 设置参数ID
	 * @param[in] strId 参数id
	 */
	void SetId(const std::string& strId);
	/**
	 * @brief 获取参数Id
	 * @return 参数Id
	 */
	std::string GetId() const;
    /**
     * @brief 获取参数短Id,TODO should do most for array items.
     * @return 参数短Id
     */
	virtual std::string GetShortID() const;

	/**
	 * @brief 设置参数值名字
	 * @param[in] strName 参数值名字
	 */
	void SetName(const std::string& strName);
	/**
	 * @brief 获取参数名字
	 * @return 参数项的名字
	 */
	QString GetName() const;

	/**
	 * @brief 设置参数值描述
	 * @param[in] strDescription 参数值描述
	 */
	void SetDescription(const std::string& strDescription);
	/**
	 * @brief 获取参数描述
	 * @return 参数描述
	 */
	std::string GetDescription() const;

	/**
	 * @brief 设置参数项类型
	 * @param[in] eType 参数项类型
	 */
	void SetType(ParameterType eType);
	/**
	 * @brief 获取参数项类型
	 * @return 参数类型
	 */
	ParameterType GetType() const;

	/**
	 * @brief 设置参数项输入类型
	 * @param[in] eType 参数项输入类型
	 */
	void SetInputType(ParameterInputType eType);
	/**
	 * @brief 获取参数项输入类型
	 * @return 参数项的输入类型
	 */
	ParameterInputType GetInputType() const;

	/**
	 * @brief 获取最大值
	 * @return 参数的最大值
	 */
	std::string GetMax() const { return this->m_strMax; }

	/**
	 * @brief 设置参数项的最大值
	 * @param[in] strMax 参数项的最大值
	 */
	void SetMax(std::string strMax) { this->m_strMax = strMax; }

	/**
	 * @brief 获取参数项的最小值
	 * @return 参数项的最小值
	 */
	std::string GetMin() const { return this->m_strMin; }

	/**
	 * @brief 设置参数项的最小值
	 * @param[in] strMin 参数项的最小值
	 */
	void SetMin(std::string strMin) { this->m_strMin = strMin; }

	/**
	 * @brief 获取参数项的默认值
	 * @return 参数项的默认值
	 */
	std::string GetDefault() const { return this->m_strDefault; }
	/**
	 * @brief 设置参数项的默认值
	 * @param[in] strDefault 参数项的默认值
	 */
	void SetDefault(std::string strDefault) { this->m_strDefault = strDefault; }

	/**
	 * @brief 参数项是否是必需参数
	 * @return 参数项必需则返回true，否则返回false
	 */
	bool IsNessary() const { return this->m_bNecessary; }
	/**
	 * @brief 设置参数项是否必需
	 * @param[in] bIsNessary 参数项是否必需
	 */
	void SetIsNessary(bool bIsNessary) { this->m_bNecessary = bIsNessary; }

	/**
	 * @brief 设置参数值分类
	 * @param[in] strCategory 参数值分类
	 */
	void SetCategory(const std::string& strCategory);
	/**
	 * @brief 获取参数分类
	 * @return 参数项的分类
	 */
	std::string GetCategory() const ;

    /**
     * @brief 设置参数项输入控件的元数据
     * @param[in] strInputMetaData 参数项输入控件的元数据
     */
    void SetInputMetaData(const std::string& strInputMetaData);
    /**
     * @brief 获取参数项输入控件的元数据
     * @return 参数项的输入控件的元数据
     */
    std::string GetInputMetaData() const ;

    /**
     * @brief 设置参数项输入控件的控制数据
     * @param[in] strInputData 参数项输入控件的控制数据
     */
    void SetInputData(const std::string& strInputData);
    /**
     * @brief 获取参数项输入控件的控制数据
     * @return 参数项输入控件的控制数据
     */
    std::string GetInputData() const ;
    /**
     * @brief 添加参数项输入控件的允许拖拽进的类型
     * @param[in] acceptDropTypes 参数项输入控件允许拖拽的类型
     */
    void AddAcceptDropType(AcceptDropType acceptDropType);
    /**
     * @brief 获取参数项输入控件允许拖拽进哪些类型的数据的类型集合
     * @return 参数项输入控件允许拖拽进哪些类型的数据的类型集合
     */
    std::vector<AcceptDropType> GetAcceptDropTypes() const ;
    /**
     * @brief 获取父参数项
     * @return 父参数项
     */
    CParameterItem* GetParentItem() const;

    /**
     * @brief 获取参数类型与字符串之间的映射
     * @return 参数类型与字符串之间的映射
     */
    std::map<std::string,ParameterType> GetTypeMap() const;
    /**
     * @brief 获取参数类型与字符串之间的映射
     * @return 参数类型与字符串之间的映射
     */
    std::map<std::string,ParameterInputType> GetInputTypeMap() const;
    /**
     * @brief 获取参数项控件可接受拖拽类型与字符串之间的映射
     * @return 参数项控件可接受拖拽类型与字符串之间的映射
     */
    std::map<std::string,AcceptDropType> GetAcceptDropTypeMap() const;
    /**
     * @brief 参数项的校验
     * @return 无错误则返回true，否则返回false
     */
	virtual bool Validate();
	/**
	 * @brief 该函数用来判断参数项的值是否与该参数项的缺省值相等，如果相等，则认为用户未曾改过此参数项
	 * @return 相同则返回true，否则返回false
	 */
	virtual bool SameAsDefault();
	/**
	 * @brief 设置父亲参数项，父亲参数项必须是数组类型或自定义类型
	 * @param[in] pParentItem 父亲参数项句柄
	 */
	void SetParentItem(CParameterItem* pParentItem);
	/**
	 * @brief 判断该参数项是否有效，如果属于非必填项且用户没有赋值，则认为该参数项无效
	 *        另外，如果用户给的值与类型不匹配也认为无效。
	 * @return 有效则返回true，否则返回false
	 */
	bool IsEffective() const;

    /**
     * @brief 设置参数值读入写出方向 ,本参数由模块的json文件自己带过来，尽量不要更改
     * @param[in] strInOut 参数读入写出方向
     */
    void SetInOut(const std::string& strInOut);
    /**
     * @brief 获取读入写出方向
     * @return 读入写出方向
     */
    std::string GetInOut() const;

    /**
     * @brief 设置参数数据类型，默认为空，只有当参数是数据时，这个字段才有意义 ,本参数由模块的json文件自己带过来，尽量不要更改
     * @param[in] strDataType 参数数据类型
     */
    void SetDataType(const std::string& strDataType);
    /**
     * @brief 获取参数数据类型
     * @return 参数数据类型
     */
    std::string GetDataType() const;

    /**
     * @brief 设置参数显示数据，默认为空
     * @param[in] strDataType 参数数据类型
     */
    void SetDisplayValue(const std::string& strDisplayValue);
    /**
     * @brief 获取参数显示数据
     * @return 参数显示数据
     */
    std::string GetDisplayValue() const;

	QString GetStringName() const;

	void SetName(const QString strName);


private:
	ParameterType m_eType;//参数项类型
	ParameterInputType m_eInputType;//参数项输入类型
	std::string m_strId;//参数项Id
	std::string m_strValue;//参数项值
	QString m_strName;//参数项名字
	std::string m_strDescription;//参数项描述
	std::string m_strDefault;//参数项缺省值
	std::string m_strCategory;//参数项分类
	std::string m_strMax;//参数项最大值
	std::string m_strMin;//参数项最小值
	std::string m_strInputMetaData;//参数项输入控件的元数据
	std::string m_strInputData;//参数项输入控件的控制数据
	std::string m_strInOut;//参数方向
	std::string m_strDataType;//当参数是数据的时候，该数据的类型
	std::string m_strDisplayValue;//数据显示
	int m_iAccptDropTypes;//参数项输入控件允许拖拽进哪些类型的数据的类型集合
	bool m_bNecessary;//是否必填参数
	CParameterItem* m_pParent;

};
/**
 * @class CCompositeParameterItem
 * @brief 组合式的参数项，用于非原子类型的自定义参数项
 * @date 2011-12-19
 * @author Sinopec
 */
class PAI_MODULE_EXPORT CCompositeParameterItem:public CParameterItem
{
public:
    /**
     * @brief 构造函数
     */
    CCompositeParameterItem();
    /**
     * @brief 拷贝构造函数
     * @param[in] src 源对象
     */
    CCompositeParameterItem(const CCompositeParameterItem& src);
    /**
    * @brief 重载赋值符号
    * @param[in] srcParameter 赋值源对象
    */
    CCompositeParameterItem& operator=(const CCompositeParameterItem& srcCompositeItem);
    /**
    * @brief 重载相等符号==,判断两个参数项是否相等
    * @param[in] otherCompositeItem 对比对象
    */
    bool operator==(const CCompositeParameterItem& otherCompositeItem) const;
    /**
     * @brief 析构函数
     */
    virtual ~CCompositeParameterItem();
    /**
     * @brief 清空所有子参数项
     */
    void Clear();

    /**
     * @brief 获取参数值的字符串格式
     * @return 参数值的字符串格式
     */
    virtual std::string GetStringValue() const;
    /**
     * @brief 增加子参数项,注意本函数会复制一份子参数项加入到子参数项列表。
     * @param[in] childItem 子参数项
     * @param[in] bAmendID 是否需要修改ID及其子孙参数的参数项ID
     */
    void AddParameterItem(const CParameterItem& childItem,bool bAmendID=true);
    /**
     * @brief 插入子参数项,注意本函数会复制一份子参数项插入到子参数项列表。
     * @param[in] index 插入的位置 ，-1等同于末尾添加
     * @param[in] childItem 子参数项
     * @param[in] bAmendID 是否需要修改ID及其子孙参数的参数项ID
     */
    void InsertParameterItem(const int index,const CParameterItem& childItem,bool bAmendID=true);

    /**
     * @brief 删除指定ID的子参数项
     * @param[in] strItemID 子参数项Id
     * @return 删除成功返回true，否则返回false
     */
    bool RemoveParameterItem(const std::string& strItemID);
    /**
     * @brief 获取某个子参数项
     * @param[in] strItemID 子参数项Id,注意这个ID可能是一个包含父ID及祖先ID以及自身ID的复合ID
     * @code
     * GetParameterItem("File[0].TraceSelection.Key[1].Start")
     * @endcode
     * @return 子参数项
     */
    CParameterItem* GetParameterItem(const std::string& strItemID) const;
    /**
     * @brief 获取指定索引的子参数项
     * @param[in] iIndex 子参数项索引
     * @return 参数项
     */
    CParameterItem* GetParameterItem(int iIndex) const;
    /**
     * @brief 根据参数项的类别获取参数项
     * @param[in] strCategory 参数项类别名称
     * @return 符合条件的参数项
     */
    std::vector<CParameterItem*> GetParameterItemsByCategory(const std::string& strCategory) const;
    /**
     * @brief 获取子参数项的所有分类名字
     * @param[out] vecCategoryNames 所有类型名字的集合
     */
    void GetCategoryNames(std::vector<std::string>& vecCategoryNames);

    /**
     * @brief 获取子参数项个数，这个函数只返回本级孩子个数，不产生递归。
     * @return 子参数项个数
     */
    int GetChildCount() const;
    /**
     * @brief 判断该组合参数项是否是个数组
     * @return 是则返回true，否则返回false
     */
    bool IsArray() const;
    /**
     * @brief 递归查找并获取可编辑的子参数项列表
     * @param[out] vecResultItems 符合条件的参数项
     */
    void GetParameterItemsWithValidInputType(std::vector<CParameterItem*>& vecResultItems) const;
    /**
     * @brief 将组合参数项的所有叶子节点收集到线性表
     * @param[out] vecLeafItems 结果参数项集合
     */
    void GetAllLeafParameterItems(std::vector<CParameterItem>& vecLeafItems) const;
    /**
     * @brief 将本身及所有后代的ID改为shortID.
     */
    void InitializeToShortIDs();
    /**
     * @brief 判断该复合参数项的所有子项的值是否都准备好且可用，例如为空的必填项就不可用
     * @param[out] completeIndex 复合参数项所有子项的填写完备程度
     * @return 所有子项的值是否都准备好且可用则返回true，否则返回false
     */
    bool IsReady(ParameterCompleteIndex& completeIndex) const;
	/**
	 * @brief 该函数用来判断参数项的值是否与该参数项的缺省值相等，如果相等，则认为用户未曾改过此参数项
	 *        对于复合参数项而言，SameAsDefault的真值条件是需要每个子参数项和子参数项的缺省值相同
	 */
	virtual bool SameAsDefault();
private:
    /**
     * @brief 将传入子参数项加入到子参数项列表并修改ID及其子孙参数的参数项ID
     * @param[in] pChildItem 子参数项
     * @param[in] bAmendID 是否需要修改ID及其子孙参数的参数项ID
     */
    void _AddItemAndAmendItemID(CParameterItem* pChildItem,bool bAmendID);
    /**
     * @brief 将传入子参数项插入到子参数项列表并修改ID及其子孙参数的参数项ID
     * @param[in] index 插入的位置 ，-1等同于末尾添加
     * @param[in] pChildItem 子参数项
     * @param[in] bAmendID 是否需要修改ID及其子孙参数的参数项ID
     */
    void _InsertItemAndAmendItemID(const int index ,CParameterItem* pChildItem,bool bAmendID);

    /**
     * @brief 将传入子参数项加入到子参数项列表并为其设置父参数项为this
     * @param[in] pChildItem 子参数项
     */
    void _AddChildItem(CParameterItem* pChildItem);
public:
    /**
     * @brief 将pChildItem及其子孙参数的参数项ID都修正为包括父亲ID在内的ID，这个函数必须在_AddChildItem之后调用，保证pChildItem已经加入子参数项列表
     * @param[in] pChildItem 指定的子参数项
     * @param[in] iChildIndex 指定的子参数项在父亲的子参数项列表中的索引
     */
    void _AmendChildItemID(CParameterItem* pChildItem,int iChildIndex);

private:
    std::vector<CParameterItem*> m_vecChildItems;//子参数项列表
};

}
}

#endif