Java tutorial
/* * This file is part of Dorado 7.x (http://dorado7.bsdn.org). * * Copyright (c) 2002-2012 BSTEK Corp. All rights reserved. * * This file is dual-licensed under the AGPLv3 (http://www.gnu.org/licenses/agpl-3.0.html) * and BSDN commercial (http://www.bsdn.org/licenses) licenses. * * If you are unsure which license is appropriate for your use, please contact the sales department * at http://www.bstek.com/contact. */ package com.bstek.dorado.data.config.xml; import java.util.HashMap; import java.util.LinkedHashSet; import java.util.Map; import java.util.Set; import java.util.Stack; import org.apache.commons.lang.StringUtils; import org.w3c.dom.Element; import org.w3c.dom.Node; import com.bstek.dorado.config.ParseContext; import com.bstek.dorado.config.definition.DefaultDefinitionReference; import com.bstek.dorado.config.definition.DefinitionReference; import com.bstek.dorado.config.xml.XmlConstants; import com.bstek.dorado.data.config.definition.DataProviderDefinition; import com.bstek.dorado.data.config.definition.DataProviderDefinitionManager; import com.bstek.dorado.data.config.definition.DataResolverDefinition; import com.bstek.dorado.data.config.definition.DataResolverDefinitionManager; import com.bstek.dorado.data.config.definition.DataTypeDefinition; import com.bstek.dorado.data.config.definition.DataTypeDefinitionManager; import com.bstek.dorado.data.config.definition.DataTypeDefinitionReference; /** * ??? * * @author Benny Bao (mailto:benny.bao@bstek.com) * @since Feb 21, 2007 */ public class DataParseContext extends ParseContext { private String resourceName; private String dataObjectIdPrefix = ""; private Map<String, NodeWrapper> configuredDataTypes = new HashMap<String, NodeWrapper>(); private Map<String, DataTypeDefinition> parsedDataTypes = new HashMap<String, DataTypeDefinition>(); private Map<String, NodeWrapper> configuredDataProviders = new HashMap<String, NodeWrapper>(); private Map<String, DataProviderDefinition> parsedDataProviders = new HashMap<String, DataProviderDefinition>(); private Map<String, NodeWrapper> configuredDataResolvers = new HashMap<String, NodeWrapper>(); private Map<String, DataResolverDefinition> parsedDataResolvers = new HashMap<String, DataResolverDefinition>(); private Set<Node> parsingNodes = new LinkedHashSet<Node>(); private DataTypeDefinitionManager dataTypeDefinitionManager; private DataProviderDefinitionManager dataProviderDefinitionManager; private DataResolverDefinitionManager dataResolverDefinitionManager; private boolean duringParsingDataElement; private Stack<String> privateObjectNameStack = new Stack<String>(); private Stack<DefinitionReference<DataTypeDefinition>> currentDataTypeStack = new Stack<DefinitionReference<DataTypeDefinition>>(); public String getResourceName() { return resourceName; } public void setResourceName(String resourceName) { this.resourceName = resourceName; } public String getDataObjectIdPrefix() { return dataObjectIdPrefix; } public void setDataObjectIdPrefix(String dataObjectIdPrefix) { this.dataObjectIdPrefix = dataObjectIdPrefix; } /** * ?DataTypeMap?MapDataType??XML */ public Map<String, NodeWrapper> getConfiguredDataTypes() { return configuredDataTypes; } /** * ??DataType??MapDataType??? */ public Map<String, DataTypeDefinition> getParsedDataTypes() { return parsedDataTypes; } /** * ?DataProviderMap?MapDataProvider??XML */ public Map<String, NodeWrapper> getConfiguredDataProviders() { return configuredDataProviders; } /** * ??DataProvider??MapDataProvider??? */ public Map<String, DataProviderDefinition> getParsedDataProviders() { return parsedDataProviders; } /** * ?DataResolverMap?MapDataResolver??XML */ public Map<String, NodeWrapper> getConfiguredDataResolvers() { return configuredDataResolvers; } /** * ??DataResolver??MapDataResolver??? */ public Map<String, DataResolverDefinition> getParsedDataResolvers() { return parsedDataResolvers; } /** * ?????????? */ public Set<Node> getParsingNodes() { return parsingNodes; } /** * DataType?? */ public void setDataTypeDefinitionManager(DataTypeDefinitionManager dataTypeDefinitionManager) { this.dataTypeDefinitionManager = dataTypeDefinitionManager; } /** * DataType?? */ public DataTypeDefinitionManager getDataTypeDefinitionManager() { return dataTypeDefinitionManager; } /** * DataProvider?? */ public void setDataProviderDefinitionManager(DataProviderDefinitionManager dataProviderDefinitionManager) { this.dataProviderDefinitionManager = dataProviderDefinitionManager; } /** * DataProvider?? */ public DataProviderDefinitionManager getDataProviderDefinitionManager() { return dataProviderDefinitionManager; } /** * DataResolver?? */ public void setDataResolverDefinitionManager(DataResolverDefinitionManager dataResolverDefinitionManager) { this.dataResolverDefinitionManager = dataResolverDefinitionManager; } /** * DataResolver?? */ public DataResolverDefinitionManager getDataResolverDefinitionManager() { return dataResolverDefinitionManager; } /** * ?DataType?????DataType? * * @param name * DataType?? * @return ? */ public DefinitionReference<DataTypeDefinition> getDataTypeReference(String name) { return new DataTypeDefinitionReference(name); } private String getFinalDataObjectName(String name, DataParseContext context) { if (name.charAt(0) == '#') { String resourceName = context.getResourceName(); if (StringUtils.isNotEmpty(resourceName)) { String prefix; int i1 = resourceName.lastIndexOf('/'); int i2 = resourceName.lastIndexOf('.'); int i = (i1 > i2) ? i1 : i2; if (i > 0 && i < (resourceName.length() - 1)) { prefix = resourceName.substring(i + 1); } else { prefix = resourceName; } name = StringUtils.uncapitalize(prefix) + name; } } return name; } /** * ?DataProvider?????DataProvider? * * @param name * DataProvider?? * @return ? */ public DefinitionReference<DataProviderDefinition> getDataProviderReference(String name, DataParseContext context) { name = getFinalDataObjectName(name, context); name = name.trim(); return new DefaultDefinitionReference<DataProviderDefinition>(dataProviderDefinitionManager, name); } /** * ?DataResolver?????DataResolver? * * @param name * DataResolver?? * @return ? */ public DefinitionReference<DataResolverDefinition> getDataResolverReference(String name, DataParseContext context) { name = getFinalDataObjectName(name, context); name = name.trim(); return new DefaultDefinitionReference<DataResolverDefinition>(dataResolverDefinitionManager, name); } /** * ???? */ public boolean isDuringParsingDataElement() { return duringParsingDataElement; } /** * ???? */ public void setDuringParsingDataElement(boolean duringParsingDataElement) { this.duringParsingDataElement = duringParsingDataElement; } /** * ?DataType */ public DefinitionReference<DataTypeDefinition> getCurrentDataType() { if (!currentDataTypeStack.isEmpty()) { return currentDataTypeStack.peek(); } return null; } /** * ?DataType */ public void setCurrentDataType(DefinitionReference<DataTypeDefinition> definitionReference) throws Exception { currentDataTypeStack.push(definitionReference); } /** * ?DataType */ public void restoreCurrentDataType() { if (currentDataTypeStack.size() > 0) { currentDataTypeStack.pop(); } } /** * ????? */ public String getPrivateNameSection(Node node) { String section = null; if (node instanceof Element) { Element element = (Element) node; String keyValue = element.getAttribute(XmlConstants.ATTRIBUTE_ID); if (StringUtils.isEmpty(keyValue)) { keyValue = element.getAttribute(XmlConstants.ATTRIBUTE_NAME); } if (StringUtils.isNotEmpty(keyValue)) { section = DataXmlConstants.PATH_SUB_OBJECT_PREFIX + keyValue; } else { section = DataXmlConstants.PATH_PROPERTY_PREFIX + element.getTagName(); } } else { section = DataXmlConstants.PATH_PROPERTY_PREFIX + node.getNodeName(); } return section; } /** * ???? */ public String getPrivateObjectName() { if (privateObjectNameStack.size() > 0) { return privateObjectNameStack.peek(); } else { return null; } } /** * ???? */ public void setPrivateObjectName(String name) { privateObjectNameStack.push(name); } /** * ???? */ public String setPrivateObjectNameSection(String section) { String prefix = getPrivateObjectName(); prefix = StringUtils.defaultString(prefix, ""); String name = prefix + section; setPrivateObjectName(name); return name; } /** * ???? */ public void restorePrivateObjectName() { if (privateObjectNameStack.size() > 0) { privateObjectNameStack.pop(); } } }