<%@ jet 
	imports="
		org.talend.core.model.process.INode 
		org.talend.core.model.process.ElementParameterParser 
		org.talend.core.model.metadata.IMetadataTable 
		org.talend.core.model.metadata.IMetadataColumn 
		org.talend.core.model.process.IConnection
		org.talend.core.model.process.IConnectionCategory
		org.talend.designer.codegen.config.CodeGeneratorArgument
		org.talend.core.model.metadata.types.JavaTypesManager
		org.talend.core.model.metadata.types.JavaType
		java.util.List 
    	java.util.Map		
	" 
%>
	<%@ include file="../templates/Row/RowHelper.javajet"%>
	<% 
    CodeGeneratorArgument codeGenArgument = (CodeGeneratorArgument) argument;
    INode node = (INode)codeGenArgument.getArgument();
    final String cid = node.getUniqueName();	
	
	String projectName = codeGenArgument.getCurrentProjectName();
	String jobName = codeGenArgument.getJobName();
	String jobVersion = codeGenArgument.getJobVersion();
	
	String tempDir = ElementParameterParser.getValue(node, "__TEMP_DIR__");
	
	String vcid = "";

	String destination = ElementParameterParser.getValue(node, "__DESTINATION__");
	if(destination!=null && !"".equals(destination)){
		vcid = destination;
	}
	
		
	class GenerateCode{
		public int colLen = 0; // the length of the column in the input schema
		public void generateDynamicSchemaCode(boolean isCsv){
		%>
			if(isFirstCheckDyn_<%=cid %>){// for the header line
				<%
				if(isCsv){
				%>
					int colsLen_<%=cid %> = row<%=cid %>.length;
				<%
				}else{
				%>
					int colsLen_<%=cid %> = fid_<%=cid %>.getColumnsCountOfCurrentRow();
				<%
				}
				%>
    			for (int i = <%=colLen %>-1; i < colsLen_<%=cid %>; i++) {
			    	routines.system.DynamicMetadata dynamicMetadata_<%=cid%> = new routines.system.DynamicMetadata();
			    	dynamicMetadata_<%=cid%>.setName(<%if(isCsv){%>row<%=cid %>[i]<%}else{%>fid_<%=cid %>.get(i)<%}%>.replaceAll("[ .-]+", "_"));
			    	dynamicMetadata_<%=cid%>.setDbName(dynamicMetadata_<%=cid%>.getName());
			    	dynamicMetadata_<%=cid%>.setType("id_String");
			    	dynamicMetadata_<%=cid%>.setDbType("VARCHAR");
			    	dynamicMetadata_<%=cid%>.setLength(100);
			    	dynamicMetadata_<%=cid%>.setPrecision(0);
			    	dynamicMetadata_<%=cid%>.setNullable(true);
			    	dynamicMetadata_<%=cid%>.setKey(false);
			    	dynamicMetadata_<%=cid%>.setSourceType(routines.system.DynamicMetadata.sourceTypes.demilitedFile);
			    	dynamicMetadata_<%=cid%>.setColumnPosition(i);
			    	dynamic_<%=cid%>.metadatas.add(dynamicMetadata_<%=cid%>);
			    }
    			isFirstCheckDyn_<%=cid %> = false;
    			continue;
			}
		<%
		}
		public void checkFooterAndRandom(String footer,String random){
		%>
			int footer_value_<%=cid %> = <%=footer %>, random_value_<%=cid %> = <%=random %>;
			if(footer_value_<%=cid %> >0 || random_value_<%=cid %> > 0){
				throw new Exception("When the input source is a stream,footer and random shouldn't be bigger than 0.");				
			}
		<%
		}
		
		public void checkFooter(String footer){
		%>
			int footer_value_<%=cid %> = <%=footer %>;
			if(footer_value_<%=cid%> > 0){
				throw new Exception("When the input source is a stream,footer shouldn't be bigger than 0.");
			}
		<%	
		}
	}
	GenerateCode generateCode = new GenerateCode();

	if(("false").equals(ElementParameterParser.getValue(node,"__CSV_OPTION__"))) {	
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		class RowUtil extends DefaultRowUtil{
			public void codeForValueToConn(INode node, IMetadataTable metadata, String sourceValueClass, String sourceValueName, String targetConnName){
				codeForValueToConnWithD(node, metadata, sourceValueClass, sourceValueName, targetConnName, null);
			}
			public void codeForValueToConnWithD(INode node, IMetadataTable metadata, String sourceValueClass, String sourceValueName, String targetConnName, String dynamicName){
				
				String encoding = ElementParameterParser.getValue(node,"__ENCODING__");
				
				List<Map<String, String>> trimSelects = (List<Map<String,String>>)ElementParameterParser.getObjectValue(node, "__TRIMSELECT__");
				String isTrimAllStr = ElementParameterParser.getValue(node,"__TRIMALL__");
				boolean isTrimAll = (isTrimAllStr!=null&&!("").equals(isTrimAllStr))?("true").equals(isTrimAllStr):true;
				
				String checkDateStr = ElementParameterParser.getValue(node,"__CHECK_DATE__");
				boolean checkDate = (checkDateStr!=null&&!("").equals(checkDateStr))?("true").equals(checkDateStr):false;
				
				String checkNumStr = ElementParameterParser.getValue(node, "__CHECK_FIELDS_NUM__");
				boolean checkNum = (checkNumStr!=null&&!("").equals(checkNumStr))?("true").equals(checkNumStr):false; 
				
				String advancedSeparatorStr = ElementParameterParser.getValue(node, "__ADVANCED_SEPARATOR__");
				boolean advancedSeparator = (advancedSeparatorStr!=null&&!("").equals(advancedSeparatorStr))?("true").equals(advancedSeparatorStr):false;
				String thousandsSeparator = ElementParameterParser.getValueWithJavaType(node, "__THOUSANDS_SEPARATOR__", JavaTypesManager.CHARACTER);
				String decimalSeparator = ElementParameterParser.getValueWithJavaType(node, "__DECIMAL_SEPARATOR__", JavaTypesManager.CHARACTER);
				
				List<IMetadataColumn> listColumns = metadata.getListColumns();
				int sizeListColumns = listColumns.size();
				boolean noStringTypeExist = false;
				
				for (int valueN=0; valueN<sizeListColumns; valueN++) {
					IMetadataColumn column = listColumns.get(valueN);
					JavaType javaType = JavaTypesManager.getJavaTypeFromId(column.getTalendType());
					if(javaType == JavaTypesManager.STRING || javaType == JavaTypesManager.OBJECT){
					}else{
						noStringTypeExist = true;
						break;
					}
				}
				boolean hasStringDefault = false;
				for (int valueM=0; valueM<sizeListColumns; valueM++) {
					IMetadataColumn column = listColumns.get(valueM);
					JavaType javaType = JavaTypesManager.getJavaTypeFromId(column.getTalendType());
					if(javaType == JavaTypesManager.STRING || javaType == JavaTypesManager.OBJECT){
						if(hasStringDefault==false && column.getDefault()!=null && column.getDefault().length() > 0 ){
							hasStringDefault = true;
							break;
						}
					}
				}
				if(noStringTypeExist || hasStringDefault){
				%>
					String temp = ""; 
				<%
				}
				for (int valueN=0; valueN<sizeListColumns; valueN++) {
					IMetadataColumn column = listColumns.get(valueN);
					String typeToGenerate = JavaTypesManager.getTypeToGenerate(column.getTalendType(), column.isNullable());
					JavaType javaType = JavaTypesManager.getJavaTypeFromId(column.getTalendType());
					String patternValue = column.getPattern() == null || column.getPattern().trim().length() == 0 ? null : column.getPattern();%><%
					if(javaType == JavaTypesManager.STRING || javaType == JavaTypesManager.OBJECT){
						String defaultValue = column.getDefault();
						if(defaultValue!=null && defaultValue.length()>0){
						%>
							temp  = <%=sourceValueName%>.get(<%=valueN%>)<%=(isTrimAll || (!trimSelects.isEmpty() && ("true").equals(trimSelects.get(valueN).get("TRIM"))))?".trim()":"" %>;
							if(temp.length() > 0){
								<%=targetConnName %>.<%=column.getLabel() %> = temp;
							}else{
								<%=targetConnName %>.<%=column.getLabel() %> = <%=defaultValue %>;
							}
						<%
						}else{
						%>
							<%=targetConnName %>.<%=column.getLabel() %> = <%=sourceValueName%>.get(<%=valueN%>)<%=(isTrimAll || (!trimSelects.isEmpty() && ("true").equals(trimSelects.get(valueN).get("TRIM"))))?".trim()":"" %>;
						<%
						}
					}else if(column.getTalendType().equals("id_Dynamic")){
					%>
						<%=dynamicName%>.clearColumnValues();
						int fieldCount = <%=sourceValueName%>.getColumnsCountOfCurrentRow();
						for (int i = 0; i < <%=dynamicName%>.getColumnCount(); i++) {
							if ((<%=sizeListColumns%>-1+i) < fieldCount){
								<%=dynamicName%>.addColumnValue(<%=sourceValueName%>.get(<%=sizeListColumns%>-1+i)<%=(isTrimAll || (!trimSelects.isEmpty() && ("true").equals(trimSelects.get(valueN).get("TRIM"))))?".trim()":"" %>);
							}
							else{
								<%=dynamicName%>.addColumnValue("");
							}
						}
						<%=targetConnName %>.<%=column.getLabel() %>=<%=dynamicName%>;
					<%
					}else{
					%>
						temp = <%=sourceValueName%>.get(<%=valueN%>)<%=(isTrimAll || (!trimSelects.isEmpty() && ("true").equals(trimSelects.get(valueN).get("TRIM"))))?".trim()":"" %>;
						if(temp.length() > 0) {
							<%
							if(javaType == JavaTypesManager.STRING || javaType == JavaTypesManager.OBJECT) {
							} else if(javaType == JavaTypesManager.BYTE_ARRAY){ 
							%>
								<%=targetConnName %>.<%=column.getLabel() %> = temp.getBytes(<%=encoding%>);
							<%
							}else if(javaType == JavaTypesManager.DATE) { 
								if(checkNum || checkDate){
								%>
									<%=targetConnName %>.<%=column.getLabel() %> = ParserUtils.parseTo_Date(temp, <%= patternValue %>, false);
								<%
								}else{
								%>
									<%=targetConnName %>.<%=column.getLabel() %> = ParserUtils.parseTo_Date(temp, <%= patternValue %>);
								<%
								}
							}else if(advancedSeparator && JavaTypesManager.isNumberType(javaType, column.isNullable())) { 
							%>
								<%=targetConnName %>.<%=column.getLabel() %> = ParserUtils.parseTo_<%= typeToGenerate %>(ParserUtils.parseTo_Number(temp, <%= thousandsSeparator %>, <%= decimalSeparator %>));
							<%
							} else { 
							%>
								<%=targetConnName %>.<%=column.getLabel() %> = ParserUtils.parseTo_<%= typeToGenerate %>(temp);
							<%
							}
							%>
						} else {						
							<%
							String defaultValue = JavaTypesManager.getDefaultValueFromJavaType(typeToGenerate, column.getDefault());
							if(defaultValue == null) {
							%>
								throw new RuntimeException("Value is empty for column : '<%= column.getLabel() %>' in '<%=targetConnName %>' connection, value is invalid or this column should be nullable or have a default value.");
							<%
							} else {
							%>
								<%=targetConnName %>.<%=column.getLabel() %> = <%=defaultValue %>;
							<%
							}
							%>
						}
					<%
					}
				}
				%>
				<%if(checkNum) {%>
				 	int filedsum = <%=sourceValueName%>.getColumnsCountOfCurrentRow();
				 	if(filedsum < <%=metadata.getListColumns().size() %>){
					 	throw new RuntimeException("Column(s) missing");
					 } else if(filedsum > <%=metadata.getListColumns().size() %>) {
					 	throw new RuntimeException("Too many columns");
					 }     
				<%
				}
			}
			
			public void codeForConnToConn(INode node, IMetadataTable metadata, String sourceConnName, String targetConnName){
    			for(IMetadataColumn column : metadata.getListColumns()) {
    			%>
    				<%=targetConnName%>.<%=column.getLabel()%> = <%=sourceConnName%>.<%=column.getLabel()%>;
				<%
				}
				%>
			<%
			}
		}//class defined end

		List<IMetadataTable> metadatas = node.getMetadataList();
		if ((metadatas!=null)&&(metadatas.size()>0)) {
			IMetadataTable metadata = metadatas.get(0);
			if (metadata!=null) {
				String filename = ElementParameterParser.getValue(node,"__FILENAME__");
				
				if(!("".equals(vcid))) {
					filename = "\"/"+filename.substring(1, filename.length()-1)+vcid+"_"+projectName+"_"+jobName+"_"+jobVersion+"\"";
					filename = tempDir+"+"+filename;
				}
				
		    	String encoding = ElementParameterParser.getValue(node,"__ENCODING__");
		    	String header = ElementParameterParser.getValue(node, "__HEADER__");
		    	if(("").equals(header)){
		    		header="0";
		    	}
		    	String limit = ElementParameterParser.getValue(node, "__LIMIT__");
				if(("").equals(limit)){
					limit = "-1";
				}
		    	String footer = ElementParameterParser.getValue(node, "__FOOTER__");
				boolean uncompress = ("true").equals(ElementParameterParser.getValue(node,"__UNCOMPRESS__"));
		    	if(("").equals(footer) || uncompress){
		    		footer="0";
		    	}
		    	String random = "-1";
		    	String ran = ElementParameterParser.getValue(node, "__RANDOM__");
		    	if(("true").equals(ran)){
		    		random = ElementParameterParser.getValue(node, "__NB_RANDOM__");
		    		if(("").equals(random)){
		    			random="0";
		    		}
		    	}
		    	if(uncompress){
		    		random="-1";
		    	}
				
		    	String fieldSeparator = ElementParameterParser.getValue(node, "__FIELDSEPARATOR__");
		    	String rowSeparator = ElementParameterParser.getValue(node, "__ROWSEPARATOR__");
		    	String removeEmptyRowFlag =  ElementParameterParser.getValue(node, "__REMOVE_EMPTY_ROW__");
		    	String dieOnErrorStr = ElementParameterParser.getValue(node, "__DIE_ON_ERROR__");
				boolean dieOnError = (dieOnErrorStr!=null&&!("").equals(dieOnErrorStr))?("true").equals(dieOnErrorStr):false; 
				
				String splitRecordStr = ElementParameterParser.getValue(node, "__SPLITRECORD__");
				boolean splitRecord = (splitRecordStr!=null&&!("").equals(splitRecordStr))?("true").equals(splitRecordStr):false;
				
				//find main & reject conns;
				List< ? extends IConnection> conns = node.getOutgoingSortedConnections();
			    String rejectConnName = "";
			    List<? extends IConnection> rejectConns = node.getOutgoingConnections("REJECT");
			    if(rejectConns != null && rejectConns.size() > 0) {
			        IConnection rejectConn = rejectConns.get(0);
			        rejectConnName = rejectConn.getName();
			    }
			    List<IMetadataColumn> rejectColumnList = null;
			    IMetadataTable metadataTable = node.getMetadataFromConnector("REJECT");
			    if(metadataTable != null) {
			        rejectColumnList = metadataTable.getListColumns();      
			    }
			    String firstConnName = "";
				if (conns!=null) {
					if (conns.size()>0) {
						IConnection conn = conns.get(0);
						firstConnName = conn.getName();		
					}
				}			    
				
				RowUtil rowUtil = new RowUtil(); 
				boolean hasDynamic = metadata.isDynamicSchema();
				if (conns!=null) {
				    if (conns.size()>0) {
						if(hasDynamic){
							rowUtil.prepareValueToConnWithD(metadata, "org.talend.fileprocess.FileInputDelimited", "fid", firstConnName, "dynamic");
							%>
							boolean isFirstCheckDyn_<%=cid %> = true;
							routines.system.Dynamic dynamic_<%=cid %> = new routines.system.Dynamic();
						<%
						}else{
							rowUtil.prepareValueToConn(metadata, "org.talend.fileprocess.FileInputDelimited", "fid", firstConnName);
						}
						if(!("").equals(rejectConnName)&&!rejectConnName.equals(firstConnName)&&rejectColumnList != null && rejectColumnList.size() > 0) {
							rowUtil.prepareConnToConn(metadata, firstConnName, rejectConnName);
						}
						rowUtil.generateClass(node);
					}
				}
				%>
				int nb_line_<%=cid%> = 0;
				org.talend.fileprocess.FileInputDelimited fid_<%=cid %> = null;
				try{
					<%
					if(uncompress){
					%>
						Object filename_<%=cid %> = <%=filename %>;	
						java.util.zip.ZipInputStream zis_<%=cid %> = null;
						try {
							if(filename_<%=cid %> instanceof java.io.InputStream){
								zis_<%=cid %> = new java.util.zip.ZipInputStream(new java.io.BufferedInputStream((java.io.InputStream)filename_<%=cid %>));
							}else{
								zis_<%=cid %> = new java.util.zip.ZipInputStream(new java.io.BufferedInputStream(new java.io.FileInputStream(String.valueOf(filename_<%=cid %>))));
							}
						} catch(Exception e) {
							<% if(dieOnError) {%>
								throw e;
							<% } else { %>
								System.err.println(e.getMessage());
							<% } %>
						}
						java.util.zip.ZipEntry entry_<%=cid %> = null;
		
						while (true) {
							try {
								entry_<%=cid %> = zis_<%=cid %>.getNextEntry();
							} catch(Exception e) {
								<% if(dieOnError) {%>
									throw e;
								<% } else { %>
									System.err.println(e.getMessage());
									break;
								<% } %>
							}
							if(entry_<%=cid %> == null) {
								break;
							}
							if(entry_<%=cid %>.isDirectory()){ //directory
								continue;
							}
							try {
								fid_<%=cid %> = new org.talend.fileprocess.FileInputDelimited(zis_<%=cid %>, <%=encoding %>,<%=fieldSeparator %>,<%=rowSeparator %>,<%=removeEmptyRowFlag %>,<%=header %><%=hasDynamic?"-1":""%>,<%=footer %>,<%=limit %>,<%=random %>, <%= splitRecord%>);
							} catch(Exception e) {
								<% if(dieOnError) {%>
									throw e;
								<% } else { %>
									System.err.println(e.getMessage());
								<% } %>
							}
					<%
					}else{
					%>
						Object filename_<%=cid %> = <%=filename %>;
						if(filename_<%=cid %> instanceof java.io.InputStream){
							<%
									generateCode.checkFooterAndRandom(footer,random);
							%>
						}
						try {
							fid_<%=cid %> = new org.talend.fileprocess.FileInputDelimited(<%=filename %>, <%=encoding %>,<%=fieldSeparator %>,<%=rowSeparator %>,<%=removeEmptyRowFlag %>,<%=header %><%=hasDynamic?"-1":""%>,<%=footer %>,<%=limit %>,<%=random %>, <%= splitRecord%>);
						} catch(Exception e) {
							<% if(dieOnError) {%>
								throw e;
							<% } else { %>
								System.err.println(e.getMessage());
							<% } %>
						}
					<%
					}
					%>
					while (fid_<%=cid %>!=null && fid_<%=cid %>.nextRecord()) {
						<%
				    	if (conns!=null) {
				    		if (conns.size()>0) {
				    			for (int i=0;i<conns.size();i++) {
				    				IConnection connTemp = conns.get(i);
				    				if (connTemp.getLineStyle().hasConnectionCategory(IConnectionCategory.DATA)) {
									%>
			    						<%=connTemp.getName() %> = null;			
									<%
				    				}
				    			}
				    	
								IConnection conn = conns.get(0);
								if (conn.getLineStyle().hasConnectionCategory(IConnectionCategory.DATA)) {
								%>			
									boolean whetherReject_<%=cid %> = false;
									<%=firstConnName %> = new <%=conn.getName() %>Struct();
									try {
										<%
										List<IMetadataColumn> listColumns = metadata.getListColumns();
										int sizeListColumns = listColumns.size();
										if(hasDynamic){// generate the dynamic schema code
											generateCode.colLen = sizeListColumns;
											generateCode.generateDynamicSchemaCode(false); //false: delimited mode
											rowUtil.callValueToConnWithD("fid_"+cid, firstConnName, "dynamic_"+cid);
										}else{
											rowUtil.callValueToConn("fid_"+cid, firstConnName);
										}
										
			
										
										if(rejectConnName.equals(firstConnName)) {
										%> 
											<%=firstConnName %> = null; 
										<%
										}
										%>
							
			    					} catch (Exception e) {
			        					whetherReject_<%=cid%> = true;
			        					<%
			        					if (dieOnError) {
			            				%>
			            					throw(e);
			            				<%
			        					} else {
			            					if(!("").equals(rejectConnName)&&!rejectConnName.equals(firstConnName)&&rejectColumnList != null && rejectColumnList.size() > 0) {
							                %>                    
			                    				<%=rejectConnName %> = new <%=rejectConnName %>Struct();
				                				<%rowUtil.callConnToConn(firstConnName, rejectConnName);%>
				                				<%=rejectConnName%>.errorMessage = e.getMessage() + " - Line: " + tos_count_<%=node.getUniqueName() %>;
			                					<%=firstConnName %> = null;
			                				<%
			            					} else if(("").equals(rejectConnName)){
			                				%>
			                					System.err.println(e.getMessage());
			                					<%=firstConnName %> = null;
			                				<%
			            					} else if(rejectConnName.equals(firstConnName)){%>
			            						<%=rejectConnName%>.errorMessage = e.getMessage() + " - Line: " + tos_count_<%=node.getUniqueName() %>;
			            					<%
									}
			        					} 
			        					%>
			    					}
								<%
								}
							}
							if (conns.size()>0) {
								boolean isFirstEnter = true;
								for (int i=0;i<conns.size();i++) {
									IConnection conn = conns.get(i);
									if ((conn.getName().compareTo(firstConnName)!=0)&&(conn.getName().compareTo(rejectConnName)!=0)&&(conn.getLineStyle().hasConnectionCategory(IConnectionCategory.DATA))) {
									
										if(isFirstEnter) {
										%>
											if(!whetherReject_<%=cid%>) { 
												<%isFirstEnter = false; 
										}
										%>      
			             				if(<%=conn.getName() %> == null){ 
			            	 				<%=conn.getName() %> = new <%=conn.getName() %>Struct();
			             				}				
										<%
						    	 		rowUtil.callConnToConn(firstConnName, conn.getName());
									}
								}
								 
								if(!isFirstEnter) {
								%> 
									} 
								<%
								}
								
							}
				  		}
			}
		}

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	}else{//the following is the tFileInputCSV component
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		class RowUtil extends DefaultRowUtil{
			public void codeForValueToConn(INode node, IMetadataTable metadata, String sourceValueClass, String sourceValueName, String targetConnName){
				codeForValueToConnWithD(node, metadata, sourceValueClass, sourceValueName, targetConnName, null);
			}
			public void codeForValueToConnWithD(INode node, IMetadataTable metadata, String sourceValueClass, String sourceValueName, String targetConnName, String dynamicName){
				
				String encoding = ElementParameterParser.getValue(node,"__ENCODING__");
				
				List<Map<String, String>> trimSelects = (List<Map<String,String>>)ElementParameterParser.getObjectValue(node, "__TRIMSELECT__");
				String isTrimAllStr = ElementParameterParser.getValue(node,"__TRIMALL__");
				boolean isTrimAll = (isTrimAllStr!=null&&!("").equals(isTrimAllStr))?("true").equals(isTrimAllStr):true;
				
				String checkDateStr = ElementParameterParser.getValue(node,"__CHECK_DATE__");
				boolean checkDate = (checkDateStr!=null&&!("").equals(checkDateStr))?("true").equals(checkDateStr):false;
				
				String checkNumStr = ElementParameterParser.getValue(node, "__CHECK_FIELDS_NUM__");
				boolean checkNum = (checkNumStr!=null&&!("").equals(checkNumStr))?("true").equals(checkNumStr):false; 
				
				String advancedSeparatorStr = ElementParameterParser.getValue(node, "__ADVANCED_SEPARATOR__");
				boolean advancedSeparator = (advancedSeparatorStr!=null&&!("").equals(advancedSeparatorStr))?("true").equals(advancedSeparatorStr):false;
				String thousandsSeparator = ElementParameterParser.getValueWithJavaType(node, "__THOUSANDS_SEPARATOR__", JavaTypesManager.CHARACTER);
				String decimalSeparator = ElementParameterParser.getValueWithJavaType(node, "__DECIMAL_SEPARATOR__", JavaTypesManager.CHARACTER);
				
				List<IMetadataColumn> columns=metadata.getListColumns();
				int columnSize = columns.size();
				%>				
				if(<%=sourceValueName%>.length == 1 && ("\015").equals(<%=sourceValueName%>[0])){//empty line when row separator is '\n'
					<%
					for (IMetadataColumn column1: metadata.getListColumns()) {
					%>
						<%=targetConnName %>.<%=column1.getLabel() %> = <%=JavaTypesManager.getDefaultValueFromJavaIdType(column1.getTalendType(), column1.isNullable())%>;
					<%
					}
					%>
				}else{
					<%
					boolean hasStringDefault = false;
					for (int valueM=0; valueM<columnSize; valueM++) {
						IMetadataColumn column = columns.get(valueM);
						JavaType javaType = JavaTypesManager.getJavaTypeFromId(column.getTalendType());
						if(javaType == JavaTypesManager.STRING || javaType == JavaTypesManager.OBJECT){
							if(hasStringDefault==false && column.getDefault()!=null && column.getDefault().length() > 0 ){
								hasStringDefault = true;
								break;
							}
						}
					}
					
					if(hasStringDefault==true){
					%>
						String temp = "";
					<%
					}
					for (int i=0;i<columnSize;i++) {
						IMetadataColumn column=columns.get(i);
						String typeToGenerate = JavaTypesManager.getTypeToGenerate(column.getTalendType(), column.isNullable());
						JavaType javaType = JavaTypesManager.getJavaTypeFromId(column.getTalendType());
						String patternValue = column.getPattern() == null || column.getPattern().trim().length() == 0 ? null : column.getPattern();
						%>
						if(<%=i %> < <%=sourceValueName%>.length){				
							<%
							if(javaType == JavaTypesManager.STRING || javaType == JavaTypesManager.OBJECT) {
								String defaultValue = column.getDefault();
								if(defaultValue!=null && defaultValue.length()>0){
								%>
									temp = <%=sourceValueName%>[<%=i %>]<%=(isTrimAll || (!trimSelects.isEmpty() && ("true").equals(trimSelects.get(i).get("TRIM"))))?".trim()":"" %>;
									if(temp.length() > 0){
										<%=targetConnName %>.<%=column.getLabel() %> = temp;
									}else{
										<%=targetConnName %>.<%=column.getLabel() %> = <%=defaultValue %>;
									}
								<%
								}else{
								%>
									<%=targetConnName %>.<%=column.getLabel() %> = <%=sourceValueName%>[<%=i %>]<%=(isTrimAll || (!trimSelects.isEmpty() && ("true").equals(trimSelects.get(i).get("TRIM"))))?".trim()":"" %>;
								<%
								}
							} else {
							%>
								if(<%=sourceValueName%>[<%=i %>].length() > 0) {
									<%
									if(javaType == JavaTypesManager.DATE) {
										if(checkNum || checkDate){
										%>
											<%=targetConnName %>.<%=column.getLabel() %> = ParserUtils.parseTo_Date(<%=sourceValueName%>[<%=i %>]<%=(isTrimAll || (!trimSelects.isEmpty() && ("true").equals(trimSelects.get(i).get("TRIM"))))?".trim()":"" %>, <%= patternValue %>, false);
										<%
										}else{
										%>
											<%=targetConnName %>.<%=column.getLabel() %> = ParserUtils.parseTo_Date(<%=sourceValueName%>[<%=i %>]<%=(isTrimAll || (!trimSelects.isEmpty() && ("true").equals(trimSelects.get(i).get("TRIM"))))?".trim()":"" %>, <%= patternValue %>);
										<%
										}
									} else if(advancedSeparator && JavaTypesManager.isNumberType(javaType, column.isNullable())) { 
									%>
										<%=targetConnName %>.<%=column.getLabel() %> = ParserUtils.parseTo_<%= typeToGenerate %>(ParserUtils.parseTo_Number(<%=sourceValueName%>[<%=i %>]<%=(isTrimAll || (!trimSelects.isEmpty() && ("true").equals(trimSelects.get(i).get("TRIM"))))?".trim()":"" %>, <%= thousandsSeparator %>, <%= decimalSeparator %>));
									<%
									}else if(javaType == JavaTypesManager.BYTE_ARRAY){ 
									%>							
		    							<%=targetConnName %>.<%=column.getLabel() %> = <%=sourceValueName%>[<%=i %>]<%=(isTrimAll || (!trimSelects.isEmpty() && ("true").equals(trimSelects.get(i).get("TRIM"))))?".trim()":"" %>.getBytes(<%=encoding %>);
									<%
									}else if(column.getTalendType().equals("id_Dynamic")){
									%>
										for (int i = 0; i < <%=dynamicName%>.getColumnCount(); i++) {
											<%=dynamicName%>.clearColumnValues();
										}
										int fieldCount = <%=sourceValueName%>.length;	
										for (int i = 0; i < <%=dynamicName%>.getColumnCount(); i++) {
											if ((<%=columnSize%>-1+i) < fieldCount)
												<%=dynamicName%>.addColumnValue(<%=sourceValueName%>[<%=columnSize%>-1+i]<%=(isTrimAll || (!trimSelects.isEmpty() && ("true").equals(trimSelects.get(i).get("TRIM"))))?".trim()":"" %>);
											else
												<%=dynamicName%>.addColumnValue("");
										}
										<%=targetConnName %>.<%=column.getLabel() %> = <%=dynamicName%>;
									<%
									}else {
									%>
										<%=targetConnName %>.<%=column.getLabel() %> = ParserUtils.parseTo_<%= typeToGenerate %>(<%=sourceValueName%>[<%=i %>]<%=(isTrimAll || (!trimSelects.isEmpty() && ("true").equals(trimSelects.get(i).get("TRIM"))))?".trim()":"" %>);
									<%
									}
									%>					
								}else{
									<%=targetConnName %>.<%=column.getLabel() %> = <%=JavaTypesManager.getDefaultValueFromJavaType(typeToGenerate, column.getDefault())%>;
								}
							<%					
							}
							%>	
						}else{
							<%=targetConnName %>.<%=column.getLabel() %> = <%=JavaTypesManager.getDefaultValueFromJavaType(typeToGenerate, column.getDefault()) %>;
						}
					<%
					}
					%>
				}
				<%if(checkNum) {%>
 					int filedsum = <%=sourceValueName%>.length;
 					if(filedsum < <%=metadata.getListColumns().size() %>){
 						throw new Exception("Column(s) missing");
 					} else if(filedsum > <%=metadata.getListColumns().size() %>) {
 						throw new RuntimeException("Too many columns");
 					}     
				<%
				}
			}
			
			public void codeForConnToConn(INode node, IMetadataTable metadata, String sourceConnName, String targetConnName){
    			for(IMetadataColumn column : metadata.getListColumns()) {
    			%>
    				<%=targetConnName%>.<%=column.getLabel()%> = <%=sourceConnName%>.<%=column.getLabel()%>;
				<%
				}
				%>
			<%
			}
		}//class defined end
		
		List<IMetadataTable> metadatas = node.getMetadataList();
		if ((metadatas!=null)&&(metadatas.size()>0)) {
		    IMetadataTable metadata = metadatas.get(0);
		    if (metadata!=null) {
		    
		        String filename = ElementParameterParser.getValueWithUIFieldKey(node,"__FILENAME__", "FILENAME");
		    	String encoding = ElementParameterParser.getValue(node,"__ENCODING__");
		    	String header = ElementParameterParser.getValue(node, "__HEADER__");
		    	String footer = ElementParameterParser.getValue(node, "__FOOTER__");
		    	String limit = ElementParameterParser.getValue(node, "__LIMIT__");
		    	if(("").equals(limit)){
		    		limit="-1";
		    	}
		    	String delim1 = ElementParameterParser.getValue(node, "__FIELDSEPARATOR__");     	
		    	String rowSeparator1 = ElementParameterParser.getValue(node, "__CSVROWSEPARATOR__");
		    	
		    	
		    	String escapeChar1 = ElementParameterParser.getValue(node, "__ESCAPE_CHAR__");
		    	
		    	if(("").equals(escapeChar1)){
		    		escapeChar1 = "\"\"";
		    	}
		    	String escapeChar = escapeChar1.substring(1,escapeChar1.length()-1);
		    	if(("'").equals(escapeChar)){
		    		escapeChar = "\\'";
		    	}
		    	String textEnclosure1 = ElementParameterParser.getValue(node, "__TEXT_ENCLOSURE__");
		    	if(("").equals(textEnclosure1)){
		    		textEnclosure1 = "\"\"";
		    	}
		    	String textEnclosure = textEnclosure1.substring(1,textEnclosure1.length()-1);
		    	if ("".equals(textEnclosure)) 
		    		textEnclosure = "\0";
		    	if(("'").equals(textEnclosure)){
		    		textEnclosure = "\\'";
		    	}
		    	
		    	String removeEmptyRow = ElementParameterParser.getValue(node, "__REMOVE_EMPTY_ROW__");
		    	
		    	String dieOnErrorStr = ElementParameterParser.getValue(node, "__DIE_ON_ERROR__");
				boolean dieOnError = (dieOnErrorStr!=null&&!("").equals(dieOnErrorStr))?("true").equals(dieOnErrorStr):false;
				
				boolean uncompress = ("true").equals(ElementParameterParser.getValue(node,"__UNCOMPRESS__"));
				if(uncompress){
					footer = "0";
				}
				
				List< ? extends IConnection> conns = node.getOutgoingSortedConnections();
			    String rejectConnName = "";
    			List<? extends IConnection> rejectConns = node.getOutgoingConnections("REJECT");
    			if(rejectConns != null && rejectConns.size() > 0) {
        			IConnection rejectConn = rejectConns.get(0);
        			rejectConnName = rejectConn.getName();
   				}
    			List<IMetadataColumn> rejectColumnList = null;
    			IMetadataTable metadataTable = node.getMetadataFromConnector("REJECT");
    			if(metadataTable != null) {
        			rejectColumnList = metadataTable.getListColumns();      
    			}
    			String firstConnName = "";
				if (conns!=null) {
					if (conns.size()>0) {
						IConnection conn = conns.get(0);
						firstConnName = conn.getName();		
					}
				}
				
				RowUtil rowUtil = new RowUtil(); 
				boolean hasDynamic = metadata.isDynamicSchema();
				if (conns!=null) {
				    if (conns.size()>0) {
						if(hasDynamic){
							rowUtil.prepareValueToConnWithD(metadata, "String[]", "row", firstConnName, "dynamic");
							%>
							boolean isFirstCheckDyn_<%=cid %> = true;
							routines.system.Dynamic dynamic_<%=cid %> = new routines.system.Dynamic();
						<%
						}else{
							rowUtil.prepareValueToConn(metadata, "String[]", "row", firstConnName);
						}
						if(!("").equals(rejectConnName)&&!rejectConnName.equals(firstConnName)&&rejectColumnList != null && rejectColumnList.size() > 0) {
							rowUtil.prepareConnToConn(metadata, firstConnName, rejectConnName);
						}
						rowUtil.generateClass(node);
					}
				}	
				%>
				int nb_line_<%=cid%> = 0;
				int footer_<%=cid %> = <%= footer%>;
				int totalLine<%=cid %> = 0;
				int limit<%=cid %> = <%= limit %>;
				int lastLine<%=cid %> = -1;	
				
				char fieldSeparator_<%=cid %>[] = null;
				
				//support passing value (property: Field Separator) by 'context.fs' or 'globalMap.get("fs")'. 
				if ( ((String)<%=delim1%>).length() > 0 ){
					fieldSeparator_<%=cid %> = ((String)<%=delim1%>).toCharArray();
				}else {			
					throw new IllegalArgumentException("Field Separator must be assigned a char."); 
				}
			
				char rowSeparator_<%=cid %>[] = null;
			
				//support passing value (property: Row Separator) by 'context.rs' or 'globalMap.get("rs")'. 
				if ( ((String)<%=rowSeparator1%>).length() > 0 ){
					rowSeparator_<%=cid %> = ((String)<%=rowSeparator1%>).toCharArray();
				}else {
					throw new IllegalArgumentException("Row Separator must be assigned a char."); 
				}
			
				Object filename_<%=cid %> = <%=filename %>;		
				com.talend.csv.CSVReader csvReader<%=cid %> = null;
	
				try{
					<%
					if(uncompress){
					%>
	        			java.util.zip.ZipInputStream zis_<%=cid %> = null;
	        			try {
		        			if(filename_<%=cid %> instanceof java.io.InputStream){
		        				zis_<%=cid %> = new java.util.zip.ZipInputStream(new java.io.BufferedInputStream((java.io.InputStream)filename_<%=cid %>));
		        			}else{
		        				zis_<%=cid %> = new java.util.zip.ZipInputStream(new java.io.BufferedInputStream(new java.io.FileInputStream(String.valueOf(filename_<%=cid %>))));
		        			}
	        			} catch(Exception e) {
	        				<% if(dieOnError) {%>
								throw e;
							<% } else { %>
								System.err.println(e.getMessage());
							<% } %>
	        			}
	        			java.util.zip.ZipEntry entry_<%=cid %> = null;
		        
				        while (true) {
			        		try {
	        					entry_<%=cid %> = zis_<%=cid %>.getNextEntry();
	        				} catch(Exception e) {
	        					<% if(dieOnError) {%>
									throw e;
								<% } else { %>
									System.err.println(e.getMessage());
									break;
								<% } %>
	        				}
	        				if(entry_<%=cid %> == null) {
								break;
							}
	        				if(entry_<%=cid %>.isDirectory()){ //directory
	        					continue;
	        				}
	        				String[] row<%=cid %>=null;
	        				int currentLine<%=cid %> = 0;
	        				int outputLine<%=cid %> = 0;
	        				try {//TD110 begin
	        					csvReader<%=cid %>=new com.talend.csv.CSVReader(zis_<%=cid %>, fieldSeparator_<%=cid %>[0], <%=encoding %>);
					<%
					}else{
					%>
						String[] row<%=cid %>=null;
						int currentLine<%=cid %> = 0;
	        			int outputLine<%=cid %> = 0;
						try {//TD110 begin
							if(filename_<%=cid %> instanceof java.io.InputStream){
							<%
								generateCode.checkFooter(footer);
							%>
								csvReader<%=cid %>=new com.talend.csv.CSVReader((java.io.InputStream)filename_<%=cid %>, fieldSeparator_<%=cid %>[0], <%=encoding %>);
							}else{
								csvReader<%=cid %>=new com.talend.csv.CSVReader(new java.io.BufferedReader(new java.io.InputStreamReader(
		                		new java.io.FileInputStream(String.valueOf(filename_<%=cid %>)),<%=encoding %>)), fieldSeparator_<%=cid %>[0]);
		        			}
					<%
					}
					%>
					
					csvReader<%=cid %>.setTrimWhitespace(false);
					if ( (rowSeparator_<%=cid %>[0] != '\n') && (rowSeparator_<%=cid %>[0] != '\r') )
	        			csvReader<%=cid %>.setLineEnd(""+rowSeparator_<%=cid %>[0]);
						<%
						if(("").equals(textEnclosure1) || textEnclosure1.startsWith("\"")){//normal situation
						%>
	        				csvReader<%=cid %>.setQuoteChar('<%=textEnclosure %>');
						<%
						}else{ //context and global variables
						%>
							String textEnclosure1_<%=cid %> = <%=textEnclosure1 %>; 
							char textEnclosure_<%=cid %>[] = null;
			        
	    				    if(((String)textEnclosure1_<%=cid %>).length() > 0 ){ 
	  							textEnclosure_<%=cid %> = ((String)textEnclosure1_<%=cid %>).toCharArray(); 
							}else { 
	            				throw new IllegalArgumentException("Text Enclosure must be assigned a char."); 
	        				}
							csvReader<%=cid %>.setQuoteChar(textEnclosure_<%=cid %>[0]); 
						<%
						}
					
						if(("").equals(escapeChar1) || escapeChar1.startsWith("\"")){//normal situation
	        				if(("\\\\").equals(escapeChar)){
	        				%>
	            				csvReader<%=cid %>.setEscapeChar('\\');
							<%
	        				}else if(escapeChar.equals(textEnclosure)){
	        				%>
	            				csvReader<%=cid %>.setEscapeChar(csvReader<%=cid %>.getQuoteChar());
							<%
	        				}else{
	        				%>
	            				//?????doesn't work for other escapeChar
	            				//the default escape mode is double escape
	            				csvReader<%=cid %>.setEscapeChar(csvReader<%=cid %>.getQuoteChar());
							<%
	        				}
	        			}else{//context and global variables
	 					%> 
		        			String escapeChar1_<%=cid %> = <%=escapeChar1 %>;          
		        			char escapeChar_<%=cid %>[] = null;
			        
					        if(((String)escapeChar1_<%=cid %>).length() > 0 ){ 
					        	escapeChar_<%=cid %> = ((String)escapeChar1_<%=cid %>).toCharArray(); 
					  		}else { 
		        			    throw new IllegalArgumentException("Escape Char must be assigned a char."); 
		        			}
		       				if(escapeChar_<%=cid %>[0] == '\\'){
		       					csvReader<%=cid %>.setEscapeChar('\\');
		       				}else if(escapeChar_<%=cid %>[0] ==<%if(("").equals(textEnclosure1) || textEnclosure1.startsWith("\"")){%>'<%=textEnclosure %>'<%}else{%>textEnclosure_<%=cid %>[0]<%}%>){
		       					csvReader<%=cid %>.setEscapeChar(csvReader<%=cid %>.getQuoteChar());
		       				} else {
		       					//the default escape mode is double escape
		       					csvReader<%=cid %>.setEscapeChar(csvReader<%=cid %>.getQuoteChar());
		       				}
						<%
						}
						%>      
		
			
						if(footer_<%=cid %> > 0){
						for(totalLine<%=cid %>=0;totalLine<%=cid %> < <%= header %>; totalLine<%=cid %>++){
							csvReader<%=cid %>.readNext();
						}
						csvReader<%=cid %>.setSkipEmptyRecords(<%=removeEmptyRow %>);
			            while (csvReader<%=cid %>.readNext()) {
							<%
						   	if(("true").equals(removeEmptyRow)){
						   	%>
								row<%=cid %>=csvReader<%=cid %>.getValues();
								if(!(row<%=cid %>.length == 1 && ("\015").equals(row<%=cid %>[0]))){//empty line when row separator is '\n'
							<%
							}
							%>
	                
	                		totalLine<%=cid %>++;
	                
							<%
							if(("true").equals(removeEmptyRow)){
							%>
								}
							<%
							}
							%>
	                
			            }
	            		int lastLineTemp<%=cid %> = totalLine<%=cid %> - footer_<%=cid %>   < 0? 0 : totalLine<%=cid %> - footer_<%=cid %> ;
	            		if(lastLine<%=cid %> > 0){
	                		lastLine<%=cid %> = lastLine<%=cid %> < lastLineTemp<%=cid %> ? lastLine<%=cid %> : lastLineTemp<%=cid %>; 
	            		}else {
	                		lastLine<%=cid %> = lastLineTemp<%=cid %>;
	            		}
	         
			          	csvReader<%=cid %>.close();
				        if(filename_<%=cid %> instanceof java.io.InputStream){
				 			csvReader<%=cid %>=new com.talend.csv.CSVReader((java.io.InputStream)filename_<%=cid %>, fieldSeparator_<%=cid %>[0], <%=encoding %>);
		        		}else{
				 			csvReader<%=cid %>=new com.talend.csv.CSVReader(new java.io.BufferedReader(new java.io.InputStreamReader(
				          	new java.io.FileInputStream(String.valueOf(filename_<%=cid %>)),<%=encoding %>)), fieldSeparator_<%=cid %>[0]);
						}
						csvReader<%=cid %>.setTrimWhitespace(false);
						if ( (rowSeparator_<%=cid %>[0] != '\n') && (rowSeparator_<%=cid %>[0] != '\r') )	
	        				csvReader<%=cid %>.setLineEnd(""+rowSeparator_<%=cid %>[0]);
						<%
						if(("").equals(textEnclosure1) || textEnclosure1.startsWith("\"")){//normal situation
						%>
							csvReader<%=cid %>.setQuoteChar('<%=textEnclosure %>');
						<%
						}else{
						%>
							csvReader<%=cid %>.setQuoteChar(textEnclosure_<%=cid %>[0]);
						<%
						}
						if(("").equals(escapeChar1) || escapeChar1.startsWith("\"")){//normal situation
	        				if(("\\\\").equals(escapeChar)){
	        				%>
	        				csvReader<%=cid %>.setEscapeChar('\\');
							<%
	        				}else if(escapeChar.equals(textEnclosure)){
	        				%>
	        				csvReader<%=cid %>.setEscapeChar(csvReader<%=cid %>.getQuoteChar());
							<%
	        				}else{
	        				%>
	        				//?????doesn't work for other escapeChar
	        				//the default escape mode is double escape
	        				csvReader<%=cid %>.setEscapeChar(csvReader<%=cid %>.getQuoteChar());
							<%
	        				}
	        			}else{//context and global variables
						%> 
	       					if(escapeChar_<%=cid %>[0] == '\\'){
	       						csvReader<%=cid %>.setEscapeChar('\\');
	       					}else if(escapeChar_<%=cid %>[0] == <%if(("").equals(textEnclosure1) || textEnclosure1.startsWith("\"")){%>'<%=textEnclosure %>'<%}else{%>textEnclosure_<%=cid %>[0]<%}%>){
	       						csvReader<%=cid %>.setEscapeChar(csvReader<%=cid %>.getQuoteChar());
	       					} else {
	       						//the default escape mode is double escape
	        					csvReader<%=cid %>.setEscapeChar(csvReader<%=cid %>.getQuoteChar());
	       					}
						<%
	        			}
	        			%>  
	        		}
	        
			        if(limit<%=cid%> != 0){
			        	for(currentLine<%=cid %>=0;currentLine<%=cid %> < <%= header %><%=hasDynamic?"-1":""%>;currentLine<%=cid %>++){
			        		csvReader<%=cid %>.readNext();
			        	}
			        }
			        csvReader<%=cid %>.setSkipEmptyRecords(<%=removeEmptyRow %>);
	        
	    		} catch(Exception e) {
					<% if(dieOnError) {%>
						throw e;
					<% } else { %>
						System.err.println(e.getMessage());
					<% } %>
	    		}//TD110 end
	        
	        	while ( limit<%=cid%> != 0 && csvReader<%=cid %>!=null && csvReader<%=cid %>.readNext() ) { 
	        
		        	row<%=cid %>=csvReader<%=cid %>.getValues();
	        	
					<%
	   				if(("true").equals(removeEmptyRow)){
	   				%>
	        			if(row<%=cid %>.length == 1 && ("\015").equals(row<%=cid %>[0])){//empty line when row separator is '\n'
	        				continue;
	        			}
					<%
					}
					%>
	        	
	        	
	        		currentLine<%=cid %>++;
	            
		            if(lastLine<%=cid %> > -1 && currentLine<%=cid %> > lastLine<%=cid %>) {
		                break;
	    	        }
	        	    outputLine<%=cid %>++;
	            	if (limit<%=cid %> > 0 && outputLine<%=cid %> > limit<%=cid %>) {
	                	break;
	            	}  
	                                                                      
					<%
			    	if (conns!=null) {
	    				if (conns.size()>0) {
	    					for (int i=0;i<conns.size();i++) {
	    						IConnection connTemp = conns.get(i);
	    						if (connTemp.getLineStyle().hasConnectionCategory(IConnectionCategory.DATA)) {
								%>
	    							<%=connTemp.getName() %> = null;			
								<%
	    						}
	    					}
	    					
							IConnection conn = conns.get(0);
							if (conn.getLineStyle().hasConnectionCategory(IConnectionCategory.DATA)) {
							%>
								boolean whetherReject_<%=cid %> = false;
								<%=firstConnName %> = new <%=conn.getName() %>Struct();
								try {			
									<%
									List<IMetadataColumn> columns=metadata.getListColumns();
									int columnSize = columns.size();
									if(hasDynamic){// generate the dynamic schema code
										generateCode.colLen = columnSize;
										generateCode.generateDynamicSchemaCode(true); //true: CSV mode
										rowUtil.callValueToConnWithD("row"+cid, firstConnName, "dynamic_"+cid);
									}else{
										rowUtil.callValueToConn("row"+cid, firstConnName);
									}
										
	
									if(rejectConnName.equals(firstConnName)) {
									%> 
										<%=firstConnName %> = null; 
									<%
									}
									%>
	    						} catch (Exception e) {
							        whetherReject_<%=cid%> = true;
        							<%
        							if (dieOnError) {
            						%>
            							throw(e);
            						<%
        							} else {
            							if(!("").equals(rejectConnName)&&!rejectConnName.equals(firstConnName)&&rejectColumnList != null && rejectColumnList.size() > 0) {
						                %>
						                    <%=rejectConnName %> = new <%=rejectConnName %>Struct();
                							<%
                							rowUtil.callConnToConn(firstConnName, rejectConnName);
                							%>
                							<%=rejectConnName%>.errorMessage = e.getMessage() + " - Line: " + tos_count_<%=node.getUniqueName() %>;
                							<%=firstConnName %> = null;
                						<%
            							} else if(("").equals(rejectConnName)){
                						%>
                							System.err.println(e.getMessage());
                							<%=firstConnName %> = null;
                						<%	
            							} else if(rejectConnName.equals(firstConnName)){
            							%>
            								<%=rejectConnName%>.errorMessage = e.getMessage() + " - Line: " + tos_count_<%=node.getUniqueName() %>;
            							<%
            							}
        							} 
        							%>
	    						}
	
							<%			
							}
						}
						if (conns.size()>0) {	
							boolean isFirstEnter = true;
							for (int i=0;i<conns.size();i++) {
								IConnection conn = conns.get(i);
								if ((conn.getName().compareTo(firstConnName)!=0)&&(conn.getName().compareTo(rejectConnName)!=0)&&(conn.getLineStyle().hasConnectionCategory(IConnectionCategory.DATA))) {
									if(isFirstEnter) {
									%>
										if(!whetherReject_<%=cid%>) { 
											<%isFirstEnter = false; 
									}
									%>      
	             					if(<%=conn.getName() %> == null){ 
	            	 					<%=conn.getName() %> = new <%=conn.getName() %>Struct();
	             					}
									<%
        							rowUtil.callConnToConn(firstConnName, conn.getName());
								}
							}
							if(!isFirstEnter) {
							%> 
								} 
							<%
							}
						}
					}
			}
		}
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  	}
	%>