OpticalSwitchCardProfileLoader.java

package org.opennaas.extensions.router.model.utils;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Hashtable;
import java.util.List;
import java.util.Vector;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class OpticalSwitchCardProfileLoader {

	Log						logger							= LogFactory.getLog(OpticalSwitchCardProfileLoader.class);

	Hashtable<String, Node>	cardsHashTable					= new Hashtable<String, Node>();

	private final String	DEFAULT_CARD_PROFILE_FILEPATH	= "/proteusCards.xml";

	// private final String DEFAULT_CARD_PROFILE_FILEPATH = System.getProperty("user.dir") + "\\proteusCards.xml";

	// NodeList listOfCards;

	public OpticalSwitchCardProfileLoader() throws IOException {

		InputStream is = getClass().getResourceAsStream(DEFAULT_CARD_PROFILE_FILEPATH);
		// logger.info(convertStreamToString(is));
		load(is);

		// load(DEFAULT_CARD_PROFILE_FILEPATH);
	}

	public OpticalSwitchCardProfileLoader(String configFile) throws IOException {
		load(configFile);
	}

	public void load(String configFile) throws IOException {

		FileInputStream s = new FileInputStream(new File(configFile));
		load(s);
	}

	private void load(InputStream configFileContent) throws IOException {

		try {
			DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
			DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
			Document doc = docBuilder.parse(configFileContent);

			doc.getDocumentElement().normalize();

			NodeList listOfCards = doc.getElementsByTagName("card");
			int totalCards = listOfCards.getLength();

			for (int s = 0; s < totalCards; s++) {
				Node cardNode = listOfCards.item(s);
				if (cardNode.getNodeType() == Node.ELEMENT_NODE) {
					String type = cardNode.getAttributes().getNamedItem("type").getTextContent();

					String subtypes = ((cardNode.getAttributes().getNamedItem("subtype") != null) ? cardNode.getAttributes().getNamedItem("subtype")
							.getTextContent() : "");
					if (subtypes.length() > 0) {
						String[] dataSubtype = subtypes.split(",");
						for (int t = 0; t < dataSubtype.length; t++) {
							String subtypevalue = dataSubtype[t];
							this.cardsHashTable.put(type + subtypevalue, cardNode);
						}
					} else {
						this.cardsHashTable.put(type + "0", cardNode);
					}
				}
			}
		} catch (SAXException e) {
			throw new IOException("Error parsing card profiles file:", e);
		} catch (ParserConfigurationException e) {
			throw new IOException("Error parsing card profiles file:", e);
		}

	}

	public String getValue(int type, int subtype, String Param) {
		return getValue(String.valueOf(type), String.valueOf(subtype), Param, "");
	}

	public String getValue(String type, String subtype, String Param) {
		return getValue(String.valueOf(type), String.valueOf(subtype), Param, "");
	}

	public String getValue(int type, int subtype, String Param, String DefaultValue) {
		return getValue(String.valueOf(type), String.valueOf(subtype), Param, DefaultValue);
	}

	public String getValue(String type, String subtype, String Param, String DefaultValue) {
		String value = DefaultValue;
		Node cardNode = (Node) cardsHashTable.get(type + subtype);

		if (cardNode != null) {
			NodeList cardData = cardNode.getChildNodes();

			for (int i = 0; i < cardData.getLength(); i++) {
				Node nodeData = cardData.item(i);
				if (nodeData.getNodeType() == Node.ELEMENT_NODE) {
					if (nodeData.getNodeName().trim().equals(Param)) {
						value = nodeData.getTextContent().trim();
						break;
					}
				}
			}
		}

		return value;
	}

	public String[] getParameters(int type, int subtype, String Param, String name) {
		return getParameters(String.valueOf(type), String.valueOf(subtype), Param, name);
	}

	public String[] getParameters(String type, String subtype, String Param, String name) {
		String[] values = null;
		Vector<String> vector = new Vector<String>();

		Node cardNode = (Node) cardsHashTable.get(type + subtype);

		if (cardNode != null) {
			NodeList cardData = cardNode.getChildNodes();
			for (int i = 0; i < cardData.getLength(); i++) {
				Node nodeData = cardData.item(i);
				if (nodeData.getNodeType() == Node.ELEMENT_NODE) {
					if (nodeData.getNodeName().trim().equals(Param)) {
						NodeList paramsData = nodeData.getChildNodes();

						for (int j = 0; j < paramsData.getLength(); j++) {
							Node paramData = paramsData.item(j);
							if (paramData.getNodeType() == Node.ELEMENT_NODE) {
								if (paramData.getAttributes().getNamedItem("name").getTextContent().equals(name)) {
									vector.add(paramData.getTextContent().trim());
								}
							}
						}
					}
				}
			}
		}

		values = new String[vector.size()];
		int count = 0;
		for (int i = 0; i < vector.size(); i++) {
			values[count] = (String) vector.get(count);
			count += 1;
		}

		return values;
	}

	public String[] getPortsParameter(int type, int subtype, String paramName) {
		return getPortsParameter(String.valueOf(type), String.valueOf(subtype), paramName);
	}

	/**
	 * 
	 * @param type
	 * @param subtype
	 * @param Param
	 * @param name
	 * @return
	 */
	public String[] getPortsParameter(String type, String subtype, String paramName) {

		Vector<String> vector = new Vector<String>();

		NodeList ports = getPorts(type, subtype);
		if (ports != null) {
			for (int j = 0; j < ports.getLength(); j++) {
				Node port = ports.item(j);
				if (port.getNodeType() == Node.ELEMENT_NODE) {
					if (port.getNodeName().trim().equals("port")) {
						// get desired param
						boolean added = false;
						NodeList portParams = port.getChildNodes();
						for (int k = 0; k < portParams.getLength(); k++) {
							Node paramData = portParams.item(k);
							if (paramData.getNodeType() == Node.ELEMENT_NODE) {
								if (paramData.getAttributes() != null) {
									if (paramData.getAttributes().getNamedItem("name") != null) {
										if (paramData.getAttributes().getNamedItem("name").getTextContent().equals(paramName)) {
											vector.add(paramData.getTextContent().trim());
											added = true;
										}
									}
								}
							}
						}
						// if param is not found add empty string
						if (!added) {
							vector.add("");
						}
					}
				}
			}
		}
		String[] values = new String[vector.size()];
		return vector.toArray(values);
	}

	public List<String> getPortInternalConnections(int type, int subtype, String portNum) {
		return getPortInternalConnections(String.valueOf(type), String.valueOf(subtype), portNum);
	}

	private List<String> getPortInternalConnections(String type, String subtype, String portNum) {

		Vector<String> vector = new Vector<String>();
		NodeList internalConnections = null;

		Node port = getPort(type, subtype, portNum);
		if (port != null) {
			NodeList portChilds = port.getChildNodes();
			for (int i = 0; i < portChilds.getLength(); i++) {
				Node child = portChilds.item(i);
				if (child.getNodeType() == Node.ELEMENT_NODE) {
					if (child.getNodeName().trim().equals("internalConnections")) {
						internalConnections = child.getChildNodes();
						break;
					}
				}
			}
			if (internalConnections != null) {
				Node connection;
				for (int i = 0; i < internalConnections.getLength(); i++) {
					connection = internalConnections.item(i);
					if (connection.getNodeType() == Node.ELEMENT_NODE) {
						vector.add(connection.getTextContent().trim());
					}
				}
			}
		}
		return vector;
	}

	private NodeList getPorts(String type, String subtype) {

		Node cardNode = (Node) cardsHashTable.get(type + subtype);

		if (cardNode != null) {
			// get ports Node
			Node portsNode = null;
			NodeList cardData = cardNode.getChildNodes();
			for (int i = 0; i < cardData.getLength(); i++) {

				Node cardChild = cardData.item(i);
				if (cardChild.getNodeType() == Node.ELEMENT_NODE) {
					if (cardChild.getNodeName().trim().equals("ports")) {
						portsNode = cardChild;
						break;
					}
				}
			}
			if (portsNode != null)
				return portsNode.getChildNodes();
		}
		return null;
	}

	private Node getPort(String type, String subtype, String portNum) {
		NodeList ports = getPorts(type, subtype);

		if (ports != null) {
			for (int j = 0; j < ports.getLength(); j++) {
				Node port = ports.item(j);
				if (port.getNodeType() == Node.ELEMENT_NODE) {
					if (port.getNodeName().trim().equals("port")) {
						// check portNum
						NodeList portParams = port.getChildNodes();
						for (int k = 0; k < portParams.getLength(); k++) {
							Node paramData = portParams.item(k);
							if (paramData.getNodeType() == Node.ELEMENT_NODE) {
								if (paramData.getAttributes() != null) {
									if (paramData.getAttributes().getNamedItem("name") != null) {
										if (paramData.getAttributes().getNamedItem("name").getTextContent().equals("portNumber")) {
											if (paramData.getTextContent().trim().equals(portNum))
												return port;
										}
									}
								}
							}
						}
					}
				}
			}
		}
		return null;
	}

	public boolean existsCardOfType(int type) {
		return existsCardOfType(String.valueOf(type));
	}

	public boolean existsCardOfType(String type) {
		return cardsHashTable.containsKey(type);
	}

	public String convertStreamToString(InputStream is)
			throws IOException {
		/*
		 * To convert the InputStream to String we use the Reader.read(char[] buffer) method. We iterate until the Reader return -1 which means
		 * there's no more data to read. We use the StringWriter class to produce the string.
		 */
		if (is != null) {
			Writer writer = new StringWriter();

			char[] buffer = new char[1024];
			try {
				Reader reader = new BufferedReader(
						new InputStreamReader(is, "UTF-8"));
				int n;
				while ((n = reader.read(buffer)) != -1) {
					writer.write(buffer, 0, n);
				}
			} finally {
				is.close();
			}
			return writer.toString();
		} else {
			return "";
		}
	}

}