printdata.java

Java写的ERP系统

			throw new IllegalArgumentException("PrintData.addNode - Node cannot be null");
		if (m_nodes == null)
			addRow(false, 0);
		m_nodes.add (node);
	}	//	addNode

	/**
	 * 	Get Node with index in row
	 * 	@param index index
	 * 	@return PrintData(Element) of index or null
	 */
	public Object getNode (int index)
	{
		if (m_nodes == null || index < 0 || index >= m_nodes.size())
			return null;
		return m_nodes.get(index);
	}	//	getNode

	/**
	 * 	Get Node with Name in row
	 * 	@param name name
	 * 	@return PrintData(Element) with Name or null
	 */
	public Object getNode (String name)
	{
		int index = getIndex (name);
		if (index < 0)
			return null;
		return m_nodes.get(index);
	}	//	getNode

	/**
	 * 	Get Node with AD_Column_ID in row
	 * 	@param AD_Column_ID AD_Column_ID
	 * 	@return PrintData(Element) with AD_Column_ID or null
	 */
	public Object getNode (Integer AD_Column_ID)
	{
		int index = getIndex (AD_Column_ID.intValue());
		if (index < 0)
			return null;
		return m_nodes.get(index);
	}	//	getNode

	/**
	 * 	Get Primary Key in row
	 * 	@return PK or null
	 */
	public PrintDataElement getPKey()
	{
		if (m_nodes == null)
			return null;
		for (int i = 0; i < m_nodes.size(); i++)
		{
			Object o = m_nodes.get(i);
			if (o instanceof PrintDataElement)
			{
				PrintDataElement pde = (PrintDataElement)o;
				if (pde.isPKey())
					return pde;
			}
		}
		return null;
	}	//	getPKey

	/**
	 * 	Get Index of Node in Structure (not recursing) row
	 * 	@param columnName name
	 * 	@return index or -1
	 */
	public int getIndex (String columnName)
	{
		if (m_nodes == null)
			return -1;
		for (int i = 0; i < m_nodes.size(); i++)
		{
			Object o = m_nodes.get(i);
			if (o instanceof PrintDataElement)
			{
				if (columnName.equals(((PrintDataElement)o).getColumnName()))
					return i;
			}
			else if (o instanceof PrintData)
			{
				if (columnName.equals(((PrintData)o).getName()))
					return i;
			}
			else
				Log.error("PrintData.getIndex - Element not PrintData(Element) " + o.getClass().getName());
		}
		//	As Data is stored sparse, there might be lots of NULL values
	//	Log.error("PrintData.getIndex - Element not found - " + name);
		return -1;
	}	//	getIndex

	/**
	 * 	Get Index of Node in Structure (not recursing) row
	 * 	@param AD_Column_ID AD_Column_ID
	 * 	@return index or -1
	 */
	public int getIndex (int AD_Column_ID)
	{
		if (m_columnInfo == null)
			return -1;
		for (int i = 0; i < m_columnInfo.length; i++)
		{
			if (m_columnInfo[i].getAD_Column_ID() == AD_Column_ID)
				return getIndex(m_columnInfo[i].getColumnName());
		}
		Log.error("PrintData.getIndex - Column not found - AD_Column_ID=" + AD_Column_ID);
		return -1;
	}	//	getIndex

	/*************************************************************************/

	/**
	 * 	Dump All Data
	 */
	public void dump()
	{
		dump(this);
	}	//	dump

	/**
	 * 	Dump All Data
	 */
	public void dumpCurrentRow()
	{
		dumpRow(this, m_row);
	}	//	dump

	/**
	 * 	Dump PrintData
	 *  @param pd print data
	 */
	private static void dump (PrintData pd)
	{
		System.out.println("");
		System.out.println(pd);
		if (pd.getColumnInfo() != null)
		{
			System.out.println("ColumnInfo:");
			for (int i = 0; i < pd.getColumnInfo().length; i++)
				System.out.println(i + ": " + pd.getColumnInfo()[i]);
		}
		for (int i = 0; i < pd.getRowCount(); i++)
			dumpRow(pd, i);
	}	//	dump

	/**
	 * 	Dump Row
	 *  @param pd print data
	 * 	@param row row
	 */
	private static void dumpRow (PrintData pd, int row)
	{
		System.out.println("Row #" + row);
		if (row < 0 || row >= pd.getRowCount())
		{
			System.out.println("- invalid -");
			return;
		}
		pd.setRowIndex(row);
		if (pd.getNodeCount() == 0)
		{
			System.out.println("- n/a -");
			return;
		}
		for (int i = 0; i < pd.getNodeCount(); i++)
		{
			Object obj = pd.getNode(i);
			if (obj instanceof PrintData)
			{
				System.out.println("");
				dump((PrintData)obj);
			}
			else if (obj instanceof PrintDataElement)
			{
				if (i != 0)
					System.out.print(" - ");
				System.out.print(((PrintDataElement)obj).dump());
			}
			else
			{
				System.out.println("");
				System.out.println("- INVALID: " + obj);
			}
		}
		System.out.println("");
	}	//	dumpRow

	/*************************************************************************/

	/**
	 * 	Get XML Document representation
	 * 	@return XML document
	 */
	public Document getDocument()
	{
		Document document = null;
		try
		{
			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
			//	System.out.println(factory.getClass().getName());
			DocumentBuilder builder = factory.newDocumentBuilder();
			document = builder.newDocument();
			document.appendChild(document.createComment(Compiere.getSummaryAscii()));
		}
		catch (Exception e)
		{
			System.err.println(e);
			e.printStackTrace();
		}
		//	Root
		Element root = document.createElement(PrintData.XML_TAG);
		root.setAttribute(XML_ATTRIBUTE_NAME, getName());
		root.setAttribute(XML_ATTRIBUTE_COUNT, String.valueOf(getRowCount()));
		document.appendChild(root);
		processXML (this, document, root);
		return document;
	}	//	getDocument

	/**
	 * 	Process PrintData Tree
	 * 	@param pd Print Data
	 * 	@param document document
	 *  @param root element to add to
	 */
	private static void processXML (PrintData pd, Document document, Element root)
	{
		for (int r = 0; r < pd.getRowCount(); r++)
		{
			pd.setRowIndex(r);
			Element row = document.createElement(PrintData.XML_ROW_TAG);
			row.setAttribute(XML_ATTRIBUTE_NO, String.valueOf(r));
			if (pd.isFunctionRow())
				row.setAttribute(XML_ATTRIBUTE_FUNCTION_ROW, "yes");
			root.appendChild(row);
			//
			for (int i = 0; i < pd.getNodeCount(); i++)
			{
				Object o = pd.getNode(i);
				if (o instanceof PrintData)
				{
					PrintData pd_x = (PrintData)o;
					Element element = document.createElement(PrintData.XML_TAG);
					element.setAttribute(XML_ATTRIBUTE_NAME, pd_x.getName());
					element.setAttribute(XML_ATTRIBUTE_COUNT, String.valueOf(pd_x.getRowCount()));
					row.appendChild(element);
					processXML (pd_x, document, element);		//	recursive call
				}
				else if (o instanceof PrintDataElement)
				{
					PrintDataElement pde = (PrintDataElement)o;
					if (!pde.isNull())
					{
						Element element = document.createElement(PrintDataElement.XML_TAG);
						element.setAttribute(PrintDataElement.XML_ATTRIBUTE_NAME, pde.getColumnName());
						if (pde.hasKey())
							element.setAttribute(PrintDataElement.XML_ATTRIBUTE_KEY, pde.getValueKey());
						element.appendChild(document.createTextNode(pde.getValueDisplay(null)));	//	not formatted
						row.appendChild(element);
					}
				}
				else
					Log.error("PrintData.processTree - Element not PrintData(Element) " + o.getClass().getName());
			}	//	columns
		}	//	rows
	}	//	processTree


	/**
	 * 	Create XML representation to StreamResult
	 * 	@param result StreamResult
	 * 	@return true if success
	 */
	public boolean createXML (StreamResult result)
	{
		try
		{
			DOMSource source = new DOMSource(getDocument());
			TransformerFactory tFactory = TransformerFactory.newInstance();
			Transformer transformer = tFactory.newTransformer();
			transformer.transform (source, result);
		}
		catch (Exception e)
		{
			Log.error("PrintData.createXML (StreamResult)", e);
			return false;
		}
		return true;
	}	//	createXML

	/**
	 * 	Create XML representation to File
	 * 	@param fileName file name
	 * 	@return true if success
	 */
	public boolean createXML (String fileName)
	{
		try
		{
			File file = new File(fileName);
			file.createNewFile();
			StreamResult result = new StreamResult(file);
			createXML (result);
		}
		catch (Exception e)
		{
			Log.error("PrintData.createXML (file)", e);
			return false;
		}
		return true;
	}	//	createXMLFile

	/*************************************************************************/

	/**
	 *	Create PrintData from XML
	 * 	@param input InputSource
	 * 	@return PrintData
	 */
	public static PrintData parseXML (Properties ctx, File input)
	{
		Log.trace(Log.l3_Util, "PrintData.parseXML", input);
		PrintData pd = null;
		try
		{
			PrintDataHandler handler = new PrintDataHandler(ctx);
			SAXParserFactory factory = SAXParserFactory.newInstance();
			SAXParser parser = factory.newSAXParser();
			parser.parse(input, handler);
			pd = handler.getPrintData();
		}
		catch (Exception e)
		{
			Log.error("PrintData.parseXML", e);
		}
		return pd;
	}	//	parseXML


	/*************************************************************************/

	/**
	 * 	Test
	 * 	@param args test
	 */
	public static void main(String[] args)
	{
		System.setProperty("javax.xml.parsers.DocumentBuilderFactory",
			"org.apache.crimson.jaxp.DocumentBuilderFactoryImpl");	//	System Default
		//	"org.apache.xerces.jaxp.DocumentBuilderFactoryImpl");
		System.setProperty("javax.xml.parsers.SAXParserFactory",
			"org.apache.crimson.jaxp.SAXParserFactoryImpl");	//	System Default
		//	"org.apache.xerces.jaxp.SAXParserFactoryImpl");

		PrintData pd = new PrintData(new Properties(), "test1");
		pd.addNode(new PrintDataElement("test1element1","testvalue<1>",0));
		pd.addNode(new PrintDataElement("test1element2","testvalue&2&",0));

		PrintData pdx = new PrintData(new Properties(), "test2");
		pdx.addNode(new PrintDataElement("test2element1-1","testvalue11",0));
		pdx.addNode(new PrintDataElement("test2element1-2","testvalue12",0));
		pdx.addRow(false, 0);
		pdx.addNode(new PrintDataElement("test2element2-1","testvalue21",0));
		pdx.addNode(new PrintDataElement("test2element2-2","testvalue22",0));

		pd.addNode(pdx);
		pd.addNode(new PrintDataElement("test1element3","testvalue/3/",0));

		pd.createXML("C:\\Temp\\printData.xml");
		pd.createXML(new StreamResult(System.out));
		System.out.println("");
		pd.dump();

		//	parse
		System.out.println("");
		PrintData pd1 = parseXML (new Properties(), new File("C:\\Temp\\printData.xml"));
		pd1.createXML(new StreamResult(System.out));
		System.out.println("");
		pd1.dump();
	}	//	main

}	//	PrintData