All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.thelastcheck.x937.generator.GenerateX937XML Maven / Gradle / Ivy

There is a newer version: 2.5.3
Show newest version
/*******************************************************************************
 * Copyright (c) 2009-2015 The Last Check, LLC, All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * You may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/

package com.thelastcheck.x937.generator;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.StreamTokenizer;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.exolab.castor.xml.MarshalException;
import org.exolab.castor.xml.ValidationException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.thelastcheck.x937.xml.InterfaceDefinition;
import com.thelastcheck.x937.xml.InterfaceDefinitionItem;
import com.thelastcheck.x937.xml.InterfaceDefinitionList;
import com.thelastcheck.x937.xml.InterfaceDefinitionListItem;
import com.thelastcheck.x937.xml.InterfaceField;
import com.thelastcheck.x937.xml.X937GenRules;
import com.thelastcheck.x937.xml.X937GenRulesItem;

public class GenerateX937XML {
	private static Logger log = LoggerFactory.getLogger(GenerateX937XML.class);
	private String currentClassName = null;
	private String rulesFiles = null;
	private String packageNameImpl = null;
	private String sourceLocation = null;
	private File packageFileImpl = null;
	private int fieldArrayCount = 0;
	X937GenRules genRules = null;
	X937GenRulesItem genItem = null;
	InterfaceDefinitionList interfaceDefinitionList = null;
	InterfaceDefinition interfaceDefinition = null;

	/*
	 * C,X937CheckDetailRecordImpl F,AuxiliaryOn-Us,C,03,17,15,NBSM
	 * F,ExternalProcessingCode,C,18,18,1,ANS
	 */

	public static void main(String[] args) {
		new GenerateX937XML().run(args);
	}

	private void run(String[] args) {
		for (int i = 0; i < args.length; i++) {
			String string = args[i];
			if (string.equals("-f")) {
				rulesFiles = args[i + 1];
				i++;
			}
			if (string.equals("-s")) {
				sourceLocation = args[i + 1];
				i++;
			}
			if (string.equals("-p")) {
				packageNameImpl = args[i + 1];
				i++;
			}
		}
		if (rulesFiles == null) {
			rulesFiles = "./gendata/rules.txt";
		}
		if (sourceLocation == null) {
			sourceLocation = "./";
		}
		// String packagePath = packageNameImpl.replace('.', '/');
		packageFileImpl = new File(sourceLocation, "");
		packageFileImpl.mkdirs();

		File xmlFile = new File(packageFileImpl, "genrules_x937.xml");
		if (xmlFile.exists()) {
			xmlFile.delete();
		}

		genRules = new X937GenRules();
		genItem = new X937GenRulesItem();
		genRules.addX937GenRulesItem(genItem);
		interfaceDefinitionList = new InterfaceDefinitionList();
		genItem.setInterfaceDefinitionList(interfaceDefinitionList);
		interfaceDefinitionList.setPackage(packageNameImpl);

		List items = readTokensFromFile(rulesFiles);
		for (Iterator iter = items.iterator(); iter.hasNext();) {
			String[] element = iter.next();
			if (element[0] == null) {
				continue;
			}
			if (element[0].equals("C")) {
				newClass(element);
			}
			if (element[0].equals("F")) {
				newField(element);
			}
		}
		if (currentClassName != null) {
			flushClass();
		}
		Writer writer = null;
		try {
			writer = new PrintWriter(xmlFile);
		} catch (FileNotFoundException e1) {
			e1.printStackTrace();
		}
		try {
			genRules.marshal(writer);
		} catch (MarshalException e) {
			e.printStackTrace();
		} catch (ValidationException e) {
			e.printStackTrace();
		}
	}

	private void flushClass() {
	}

	private void newField(String[] fieldArgs) {
		String argString = formatArgs(fieldArgs);
		if (fieldArgs.length < 8) {
			log.warn("Missing field arguments");
			log.warn(argString);
		}
		String fieldNumber = fieldArgs[1];
		String fieldName = fieldArgs[2];
		String fieldStart = fieldArgs[4];
		String fieldLength = fieldArgs[6];
		String fieldType = fieldArgs[7];

		int fieldNumberInt = 0;
		try {
			fieldNumberInt = Integer.parseInt(fieldNumber);
		} catch (NumberFormatException e) {
			log.warn("invalid field number value");
			log.warn(argString);
		}
		// skip field one - in base X9.37Record class.
		// if (fieldNumberInt == 1) {
		// return;
		// }

		int fieldStartInt = 0;
		try {
			fieldStartInt = Integer.parseInt(fieldStart);
		} catch (NumberFormatException e) {
			log.warn("invalid start value");
			log.warn(argString);
		}
		// make it relative to 0.
		fieldStartInt--;

		InterfaceField field = new InterfaceField();
		field.setName(fieldName);
		field.setType(fieldType);
		InterfaceDefinitionItem interfaceDefinitionItem = new InterfaceDefinitionItem();
		interfaceDefinitionItem.setInterfaceField(field);
		interfaceDefinition.addInterfaceDefinitionItem(interfaceDefinitionItem);
		fieldArrayCount++;
	}

	private String formatArgs(String[] fieldArgs) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < fieldArgs.length; i++) {
			String string = fieldArgs[i];
			if (i > 0) {
				sb.append(" : ");
			}
			if (string == null) {
				sb.append("");
			} else {
				sb.append(string);
			}
		}
		return sb.toString();
	}

	private void newClass(String[] args) {
		String argString = formatArgs(args);
		String className = args[1];
		if (currentClassName != null) {
			flushClass();
		}
		currentClassName = className;
		log.info("Generate class: " + className);

		String recordNumber = args[2];
		if (recordNumber.length() < 2) {
			recordNumber = "0" + recordNumber;
		}

		int currentFieldMax = 0;
		try {
			currentFieldMax = Integer.parseInt(args[3]);
		} catch (NumberFormatException e) {
			log.warn("invalid number of fields value");
			log.warn(argString);
		}

		StringBuffer sb = new StringBuffer();
		for (int i = 4; i < args.length; i++) {
			if (args[i] != null) {
				if (i > 4) {
					sb.append("_");
				}
				sb.append(args[i]);
			}
		}
		String recordType = sb.toString();

		interfaceDefinition = new InterfaceDefinition();
		interfaceDefinition.setName(className);
		interfaceDefinition.setType(recordType);
		interfaceDefinition.setRecordType(recordNumber);
		InterfaceDefinitionListItem listItem = new InterfaceDefinitionListItem();
		listItem.setInterfaceDefinition(interfaceDefinition);
		interfaceDefinitionList.addInterfaceDefinitionListItem(listItem);
	}

	private List readTokensFromFile(String fileName) {
		List items = new ArrayList();
		try {
			FileReader f = new FileReader(fileName);
			Reader r = new BufferedReader(f);
			StreamTokenizer st = new StreamTokenizer(r);
			st.eolIsSignificant(true);
			String[] args = new String[10];
			int argument = 0;
			while (true) {
				st.nextToken();
				switch (st.ttype) {
				case StreamTokenizer.TT_EOF:
					break;
				case StreamTokenizer.TT_EOL:
					if (args[0] != null && args[0].charAt(0) != ';') {
						items.add(args);
					}
					args = new String[10];
					argument = 0;
					break;
				case StreamTokenizer.TT_NUMBER:
					if (argument >= 10) {
						log.warn("Found too many arguments at " + st.lineno()
								+ " value " + st.nval);
					} else {
						int ival = (int) st.nval;
						args[argument++] = Integer.toString(ival);
					}
					break;
				case StreamTokenizer.TT_WORD:
					if (argument >= 10) {
						log.warn("Found too many arguments at " + st.lineno()
								+ " value " + st.sval);
					} else {
						args[argument++] = st.sval;
					}
					break;
				}
				if (st.ttype == StreamTokenizer.TT_EOF) {
					break;
				}
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return items;
	}

}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy