001: /*
002: * GeoTools - OpenSource mapping toolkit
003: * http://geotools.org
004: * (C) 2002-2006, GeoTools Project Managment Committee (PMC)
005: *
006: * This library is free software; you can redistribute it and/or
007: * modify it under the terms of the GNU Lesser General Public
008: * License as published by the Free Software Foundation;
009: * version 2.1 of the License.
010: *
011: * This library is distributed in the hope that it will be useful,
012: * but WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * Lesser General Public License for more details.
015: */
016: package org.geotools.xml.impl;
017:
018: /**
019: * A utility class used to parse objects in a type hierarchy.
020: *
021: * @author Justin Deoliveira,Refractions Research Inc.,jdeolive@refractions.net
022: *TODO: kill this class
023: */
024: public class ParseHierarchy {
025: // XSDTypeDefinition bottom;
026: // StrategyFactory factory;
027: //
028: // List strategies;
029: //
030: // ParseHierarchy(XSDTypeDefinition bottom, StrategyFactory factory) {
031: // this.bottom = bottom;
032: // this.factory = factory;
033: // strategies = new ArrayList();
034: // }
035: //
036: // /**
037: // * Initialized the hierarchy by walking from the bottom type up.
038: // */
039: // void initialize(MutablePicoContainer context) {
040: // strategies.clear();
041: //
042: // XSDTypeDefinition type = bottom;
043: // while(type != null) {
044: // //look up the associated strategy object for this type
045: // Strategy strategy = null;
046: // if (type.getName() != null) {
047: // QName qName = new QName(type.getTargetNamespace(),type.getName());
048: // Class strategyClass = factory.getStrategy(qName);
049: // strategy = (Strategy)
050: // context.getComponentInstanceOfType(strategyClass);
051: // if (strategy == null) {
052: // context.registerComponentImplementation(strategyClass);
053: // strategy = (Strategy)
054: // context.getComponentInstanceOfType(strategyClass);
055: // }
056: // }
057: // else {
058: // //special case check, look for an anonymous complex type
059: // // with simple content
060: // if (type instanceof XSDComplexTypeDefinition &&
061: // type.getBaseType() instanceof XSDSimpleTypeDefinition) {
062: // //we assign the default complex strategy instread of
063: // // delegating to parent, because if we dont, any attributes
064: // // defined by the type will not be parsed because simple
065: // // types cannot have attributes.
066: // //TODO: put this somewhere else, perahps in teh factories
067: // // that create the strategy objects
068: // strategy = new XSAnyTypeStrategy();
069: // }
070: // }
071: //
072: // if (strategy != null) {
073: // //add the strategy
074: // strategies.add(strategy);
075: //
076: // //check execution mode, if override break out
077: // if (strategy.getExecutionMode() == Strategy.OVERRIDE)
078: // break;
079: // }
080: // else {
081: // //two posibilities
082: // if (!strategies.isEmpty()) {
083: // //make the last strategy the new root of the hierarchy
084: // break;
085: // }
086: // //else continue on to try to find a strategy further up in
087: // // type hierarchy
088: // }
089: //
090: // //get the next base type, if it is equal to this type then we have
091: // // reached the root of the type hierarchy
092: // if (type.equals(type.getBaseType()))
093: // break;
094: // type = type.getBaseType();
095: // }
096: // }
097: //
098: // /**
099: // * Performs the parse in the order specified by the type hierarchy.
100: // *
101: // * @param element The element being parsed.
102: // * @param children The parsed values of any children.
103: // * @param attrs The parsed values of any attributes.
104: // *
105: // * @return the final parsed value for the element.
106: // */
107: // Object parse(InstanceComponent instance, Node[] children, Node[] attrs) {
108: // //never pass null arguments to strategies
109: // children = children != null ? children : new Node[]{};
110: // attrs = attrs != null ? attrs : new Node[]{};
111: //
112: // //last parsed, null for first in execution order
113: // Object value = null;
114: //
115: // //before we do anything, process any facets
116: // value = parseFacets(instance);
117: //
118: // //simulated call stack
119: // Stack stack = new Stack();
120: // //execute strategies from bottom to top
121: // for (int i = 0; i < strategies.size(); i++) {
122: // Strategy strategy = (Strategy) strategies.get(i);
123: //
124: // if (strategy.getExecutionMode() == Strategy.AFTER) {
125: // //put on stack to execute after parent
126: // stack.push(strategy);
127: // continue;
128: // }
129: //
130: // //execute the strategy
131: // try {
132: // if (strategy instanceof SimpleStrategy) {
133: // value = ((SimpleStrategy)strategy).parse(instance,value);
134: // }
135: // else {
136: // value = ((ComplexStrategy)strategy)
137: // .parse((Element)instance,children,attrs,value);
138: // }
139: //
140: // }
141: // catch (Throwable t) {
142: // String msg = "Parsing failed for " + instance.getName();
143: // throw new RuntimeException(msg, t);
144: // }
145: // }
146: //
147: // //unwind the call stack
148: // while(!stack.isEmpty()) {
149: // Strategy strategy = (Strategy)stack.pop();
150: // try {
151: // if (strategy instanceof SimpleStrategy) {
152: // value = ((SimpleStrategy)strategy).parse(instance,value);
153: // }
154: // else {
155: // value = ((ComplexStrategy)strategy)
156: // .parse((Element) instance,children,attrs,value);
157: // }
158: // }
159: // catch(Throwable t) {
160: // String msg = "Parsing failed for " + instance.getName();
161: // throw new RuntimeException(msg, t);
162: // }
163: // }
164: //
165: // return value;
166: //
167: // }
168: }
|