/**
*
*/
package com.hundsun.ares.studio.atom.compiler.token;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;
import org.eclipse.emf.common.util.EList;
import com.hundsun.ares.studio.atom.AtomFunction;
import com.hundsun.ares.studio.atom.compiler.constant.IAtomEngineContextConstant;
import com.hundsun.ares.studio.atom.compiler.skeleton.util.AtomFunctionCompilerUtil;
import com.hundsun.ares.studio.atom.compiler.skeleton.util.CodeUtil;
import com.hundsun.ares.studio.biz.ParamType;
import com.hundsun.ares.studio.biz.Parameter;
import com.hundsun.ares.studio.core.IARESProject;
import com.hundsun.ares.studio.engin.token.ICodeToken;
import com.hundsun.ares.studio.engin.util.TypeRule;
import com.hundsun.ares.studio.jres.model.metadata.util.MetadataServiceProvider;
/**
* ���ɰ�ͷtoken
*
* @author yanwj06282
*
*/
public class PackAddFieldHeadToken implements ICodeToken {
private String[] param_0;
private String param_1;
private boolean isObjectPack;
/**
*
* @param param_0 ��ͷ�������±�0
* @param param_1 ��ͷ�������±�1
*/
public PackAddFieldHeadToken(String[] param_0 , String param_1,boolean isObjectPack) {
this.param_0 = param_0;
this.param_1 = param_1;
this.isObjectPack = isObjectPack;
}
@Override
public String getContent() {
return null;
}
@Override
public int getType() {
return ICodeToken.CODE_TEXT;
}
@Override
public String genCode(Map<Object, Object> context) throws Exception {
return genParamCode(context);
}
/**
* ���ɰ�ͷ����
*
* @return
* @throws Exception
*/
public String genParamCode(Map<Object, Object> context) throws Exception{
StringBuffer sb = new StringBuffer();
String define = "lpOutPacker";
if (StringUtils.isNotBlank(param_1)) {
define = "v_" + StringUtils.replace(param_1, "@", "");
sb.append(define + "->BeginPack(); \r\n");
}
//����
for(String fieldName : param_0){
String type = getDataType(context, CodeUtil.trimTab(StringUtils.trim(fieldName)), MetadataServiceProvider.C_TYPE);
if(null == type || StringUtils.isBlank(type)){
throw new RuntimeException(fieldName+"��Ӧ�����Ͳ�����!��ȷ��"+fieldName+"�Ƿ��DZ��ֶ�");
}
//TODO:������Ҫ�ģ�Ŀǰֻ֧��Ĭ��
sb.append(define + "->" + getMethodTemp(context ,type, CodeUtil.trimTab(StringUtils.trim(fieldName))) +"\r\n");
}
return sb.toString();
}
public static String getDataType(Map<Object, Object> context , String fieldName , String type) throws Exception{
AtomFunction af = (AtomFunction) context.get(IAtomEngineContextConstant.ResourceModel);
IARESProject project = (IARESProject)context.get(IAtomEngineContextConstant.Aresproject);
if(isObjectParam(fieldName,context)){
return "object";
}
for(Parameter param : af.getInternalVariables()){
if (StringUtils.equals(param.getId(), fieldName)) {
if (param.getParamType().getValue() == ParamType.STD_FIELD_VALUE) {
return AtomFunctionCompilerUtil.getRealDataType(fieldName, project, MetadataServiceProvider.C_TYPE);
}
}
}
return AtomFunctionCompilerUtil.getRealDataType(fieldName, project, MetadataServiceProvider.C_TYPE);
}
private String getMethodTemp(Map<Object, Object> context ,String type ,String fieldName) throws Exception{
String macro = "";
IARESProject project = (IARESProject)context.get(IAtomEngineContextConstant.Aresproject);
List<String> ps = new ArrayList<String>();
ps.add(fieldName.trim());
if (TypeRule.typeRuleChar(type)) {
macro = "AddField(\"{0}\", '''C''');";
} else if (TypeRule.typeRuleDouble(type)||TypeRule.typeRuleFloat(type)) {
Map<String,String> parameterInfo = AtomFunctionCompilerUtil.getStandardFieldParameterInfo(fieldName, project);
String length = NumberUtils.toInt(StringUtils.defaultIfBlank(parameterInfo.get("length"), ""),0)+"";
String precision = StringUtils.defaultIfBlank(parameterInfo.get("precision"), "");
if (StringUtils.isNotBlank(length)&& StringUtils.isNotBlank(precision)) {
ps.add(length);
ps.add(precision);
}else{
throw new Exception("������������");
}
macro = "AddField(\"{0}\", '''D''', {1},{2});";
} else if (TypeRule.typeRuleInt(type)) {// charArray����
macro = "AddField(\"{0}\", '''I''');";
}else if (TypeRule.typeRuleClob(type)) {
ps.add("p");
macro = "AddField(\"{0}\", '''R''',{1}i_{0});";
} else if (TypeRule.typeRuleCharArray(type) && TypeRule.greaterThan255(type)) {// charArray���ͣ��ҳ��ȴ���255
Map<String,String> parameterInfo = AtomFunctionCompilerUtil.getStandardFieldParameterInfo(fieldName, project);
String length = parameterInfo.get("length");
ps.add(length);
macro = "AddField(\"{0}\", '''S''', {1});";
} else if (TypeRule.typeRuleCharArray(type)) {// charArray����
macro = "AddField(\"{0}\", '''S''');";
}else {
macro = "AddField(\"{0}\",'''S''');";
}
return MessageFormat.format(macro, ps.toArray(new String[0]));
}
/**
* �жϲ����Ƿ��Ƕ���
* @param paramName
* @param context
* @return
*/
private static boolean isObjectParam(String paramName, Map<Object, Object> context) {
AtomFunction atomFunction = (AtomFunction) context.get(IAtomEngineContextConstant.ResourceModel);
if( StringUtils.endsWith(paramName, "ResultSet")){
String objectName = "";
if(StringUtils.startsWith(paramName, "@")){
String varName = StringUtils.replaceOnce(paramName, "@", "");
int endIndex = StringUtils.lastIndexOf(varName, "ResultSet");
objectName = StringUtils.substring(varName, 0, endIndex);
}else{
int endIndex = StringUtils.lastIndexOf(paramName, "ResultSet");
objectName = StringUtils.substring(paramName, 0, endIndex);
}
EList<Parameter> parameters = atomFunction.getOutputParameters();
for(Parameter parameter:parameters){
if(parameter.getParamType().getValue() == ParamType.OBJECT_VALUE && StringUtils.equals(parameter.getId(),objectName)){
return true;
}
}
}else if(StringUtils.startsWith(paramName, "@") ){
int startIndex = StringUtils.indexOf(paramName, "@");
String realParamName = StringUtils.substring(paramName, startIndex+1);
EList<Parameter> parameters = atomFunction.getOutputParameters();
for(Parameter parameter:parameters){
if(parameter.getParamType().getValue() == ParamType.OBJECT_VALUE && StringUtils.equals(parameter.getId(),realParamName)){
return true;
}
}
}
return false;
}
}