001: //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/trunk/src/org/deegree/io/datastore/sql/wherebuilder/FeatureTypeNode.java $
002: /*---------------- FILE HEADER ------------------------------------------
003:
004: This file is part of deegree.
005: Copyright (C) 2001-2008 by:
006: EXSE, Department of Geography, University of Bonn
007: http://www.giub.uni-bonn.de/deegree/
008: lat/lon GmbH
009: http://www.lat-lon.de
010:
011: This library is free software; you can redistribute it and/or
012: modify it under the terms of the GNU Lesser General Public
013: License as published by the Free Software Foundation; either
014: version 2.1 of the License, or (at your option) any later version.
015:
016: This library is distributed in the hope that it will be useful,
017: but WITHOUT ANY WARRANTY; without even the implied warranty of
018: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
019: Lesser General Public License for more details.
020:
021: You should have received a copy of the GNU Lesser General Public
022: License along with this library; if not, write to the Free Software
023: Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
024:
025: Contact:
026:
027: Andreas Poth
028: lat/lon GmbH
029: Aennchenstraße 19
030: 53177 Bonn
031: Germany
032: E-Mail: poth@lat-lon.de
033:
034: Prof. Dr. Klaus Greve
035: Department of Geography
036: University of Bonn
037: Meckenheimer Allee 166
038: 53115 Bonn
039: Germany
040: E-Mail: greve@giub.uni-bonn.de
041:
042: ---------------------------------------------------------------------------*/
043: package org.deegree.io.datastore.sql.wherebuilder;
044:
045: import java.util.ArrayList;
046: import java.util.HashMap;
047: import java.util.Iterator;
048: import java.util.List;
049: import java.util.Map;
050:
051: import org.deegree.io.datastore.schema.MappedFeatureType;
052: import org.deegree.io.datastore.schema.MappedPropertyType;
053:
054: /**
055: * Represents a {@link MappedFeatureType} as a node in a {@link QueryTableTree}.
056: *
057: * @author <a href="mailto:schneider@lat-lon.de">Markus Schneider </a>
058: * @author last edited by: $Author: aschmitz $
059: *
060: * @version $Revision: 10506 $, $Date: 2008-03-06 08:50:33 -0800 (Thu, 06 Mar 2008) $
061: */
062: class FeatureTypeNode {
063:
064: // associated MappedFeatureType instance (contains the table name)
065: private MappedFeatureType ft;
066:
067: // alias (may be null)
068: private String ftAlias;
069:
070: // unique alias for the corresponding table
071: private String tableAlias;
072:
073: private Map<MappedPropertyType, List<PropertyNode>> propertyMap = new HashMap<MappedPropertyType, List<PropertyNode>>();
074:
075: /**
076: * Creates a new <code>FeatureTypeNode</code> from the given parameters.
077: *
078: * @param ft
079: * @param ftAlias
080: * @param tableAlias
081: */
082: FeatureTypeNode(MappedFeatureType ft, String ftAlias,
083: String tableAlias) {
084: this .ft = ft;
085: this .ftAlias = ftAlias;
086: this .tableAlias = tableAlias;
087: }
088:
089: /**
090: * Returns the associated {@link MappedFeatureType}.
091: *
092: * @return associated MappedFeatureType
093: */
094: public MappedFeatureType getFeatureType() {
095: return this .ft;
096: }
097:
098: /**
099: * Returns the alias as specified in the corresponding query.
100: *
101: * @return the alias (may be null)
102: */
103: public String getFtAlias() {
104: return this .ftAlias;
105: }
106:
107: /**
108: * Returns the name of the associated table.
109: *
110: * @return the name of the associated table
111: */
112: public String getTable() {
113: return this .ft.getTable();
114: }
115:
116: /**
117: * Returns the alias that uniquely identifies the table (in an SQL query).
118: *
119: * @return the unique alias for the table
120: */
121: public String getTableAlias() {
122: return this .tableAlias;
123: }
124:
125: /**
126: * Returns all child {@link PropertyNode}s.
127: *
128: * @return all child PropertyNodes
129: */
130: public PropertyNode[] getPropertyNodes() {
131: List<PropertyNode> propertyNodeList = new ArrayList<PropertyNode>();
132: Iterator<?> iter = this .propertyMap.values().iterator();
133: while (iter.hasNext()) {
134: Iterator<?> iter2 = ((List) iter.next()).iterator();
135: while (iter2.hasNext()) {
136: propertyNodeList.add((PropertyNode) iter2.next());
137: }
138: }
139: return propertyNodeList
140: .toArray(new PropertyNode[propertyNodeList.size()]);
141: }
142:
143: /**
144: * Returns the child {@link PropertyNode}s with the given type.
145: *
146: * @param type
147: * the property type to look up
148: * @return the child PropertyNode for the given property, may be null
149: */
150: public PropertyNode getPropertyNode(MappedPropertyType type) {
151: PropertyNode propertyNode = null;
152: List<?> propertyNodeList = this .propertyMap.get(type);
153: if (propertyNodeList != null) {
154: Iterator<?> propertyNodeIter = propertyNodeList.iterator();
155: boolean found = false;
156: while (propertyNodeIter.hasNext()) {
157: propertyNode = (PropertyNode) propertyNodeIter.next();
158: if (propertyNode.getProperty() == type) {
159: found = true;
160: break;
161: }
162: }
163: if (!found) {
164: propertyNode = null;
165: }
166: }
167: return propertyNode;
168: }
169:
170: /**
171: * Adds the given property node as a child.
172: *
173: * @param propertyNode
174: * the child node to add
175: */
176: public void addPropertyNode(PropertyNode propertyNode) {
177: List<PropertyNode> propertyNodeList = this .propertyMap
178: .get(propertyNode.getProperty());
179: if (propertyNodeList == null) {
180: propertyNodeList = new ArrayList<PropertyNode>();
181: this .propertyMap.put(propertyNode.getProperty(),
182: propertyNodeList);
183: }
184: propertyNodeList.add(propertyNode);
185: }
186:
187: /**
188: * Returns an indented string representation of the object.
189: *
190: * @return an indented string representation of the object
191: */
192: String toString(String indent) {
193: StringBuffer sb = new StringBuffer();
194: sb.append(indent);
195: sb.append("- ");
196: sb.append(this .ft.getName());
197: sb.append(" (FeatureTypeNode, alias: '");
198: sb.append(this .ftAlias == null ? '-' : this .ftAlias);
199: sb.append("', table: '");
200: sb.append(this .ft.getTable());
201: sb.append("', tableAlias: '");
202: sb.append(this .tableAlias);
203: sb.append("')\n");
204: Iterator<?> iter = this .propertyMap.values().iterator();
205: while (iter.hasNext()) {
206: List<?> propertyNodeList = (List) iter.next();
207: Iterator<?> iter2 = propertyNodeList.iterator();
208: while (iter2.hasNext()) {
209: PropertyNode propertyNode = (PropertyNode) iter2.next();
210: sb.append(propertyNode.toString(indent + " "));
211: }
212: }
213: return sb.toString();
214: }
215:
216: @Override
217: public boolean equals(Object obj) {
218: if (obj == null || (!(obj instanceof FeatureTypeNode))) {
219: return false;
220: }
221: FeatureTypeNode that = (FeatureTypeNode) obj;
222: if (this .getTable().equals(that.getTable())
223: && this .tableAlias.equals(that.tableAlias)) {
224: return true;
225: }
226: return false;
227: }
228:
229: @Override
230: public int hashCode() {
231: return this.tableAlias.hashCode();
232: }
233: }
|