001: /*
002: * The contents of this file are subject to the terms of the Common Development
003: * and Distribution License (the License). You may not use this file except in
004: * compliance with the License.
005: *
006: * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
007: * or http://www.netbeans.org/cddl.txt.
008: *
009: * When distributing Covered Code, include this CDDL Header Notice in each file
010: * and include the License file at http://www.netbeans.org/cddl.txt.
011: * If applicable, add the following below the CDDL Header, with the fields
012: * enclosed by brackets [] replaced by your own identifying information:
013: * "Portions Copyrighted [year] [name of copyright owner]"
014: *
015: * The Original Software is NetBeans. The Initial Developer of the Original
016: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
017: * Microsystems, Inc. All Rights Reserved.
018: */
019:
020: package org.netbeans.modules.xml.xpath.ext;
021:
022: import javax.xml.namespace.NamespaceContext;
023: import org.netbeans.modules.xml.schema.model.SchemaComponent;
024: import org.netbeans.modules.xml.xpath.ext.spi.ExtensionFunctionResolver;
025: import org.netbeans.modules.xml.xpath.ext.spi.ExternalModelResolver;
026: import org.netbeans.modules.xml.xpath.ext.spi.VariableResolver;
027: import org.netbeans.modules.xml.xpath.ext.spi.validation.XPathValidationContext;
028:
029: /**
030: * Interface for an XPath parser wrapper.
031: *
032: * @author Enrico Lelina
033: * @version
034: */
035: public interface XPathModel extends XPathSchemaContextHolder {
036:
037: /**
038: * Returns current root XPath expression of the model.
039: * It is the result of latest parseExpression call.
040: */
041: XPathExpression getRootExpression();
042:
043: /**
044: * This method can be used when an XPath model is constructed
045: * from expressions but not by parsing a text.
046: * @param newExpr
047: */
048: void setRootExpression(XPathExpression newExpr);
049:
050: /**
051: * Parses an XPath expression.
052: * @param expression the XPath expression to parse
053: * @return an instance of XPathExpression
054: * @throws XPathException for any parsing errors
055: */
056: XPathExpression parseExpression(String expression)
057: throws XPathException;
058:
059: /**
060: * Returns a model factory.
061: */
062: XPathModelFactory getFactory();
063:
064: /**
065: * After calling this method the model is resolved again when
066: * a schema information is requested.
067: */
068: void discardResolvedStatus();
069:
070: /**
071: * Tries resolving all external references: variable, schema elements
072: * and attributes. Assigns schema contexts for all context holders.
073: *
074: * Only the model's root expression is processed here.
075: * If you create a new XPath expression with the help of the Factory,
076: * then it is not a part of the root expression and has to be processed
077: * separately with the help of resolveExpressionExtReferences() method.
078: *
079: * If the again attribute is true, resolve will be retried.
080: * Otherwise it will be executed only if it hasn't been done before.
081: *
082: * It does nothing and returns if the model in in resolve mode already.
083: * Be aware that the implementation method is synchronized. So the
084: * second thread will be locked until the method is not finished in
085: * the first thread.
086: */
087: void resolveExtReferences(boolean again);
088:
089: /**
090: * This method does almost the same as the resolveExtReferences but
091: * it is intended to process expressions, which aren't connected to
092: * the model root.
093: * The model root is assigned automatically when the parseExpression()
094: * is used. But it is not if you create an expression with the help of
095: * the factory methods. So there are two choise:
096: * - specify the expression as a root (method setRootExpression) and
097: * call the resolveExtReferences().
098: * - call this method (without specifying the expression as a root).
099: *
100: * Be aware that the implementation method is synchronized. So the
101: * second thread will be locked until the method is not finished in
102: * the first thread.
103: * @param expr
104: */
105: void resolveExpressionExtReferences(XPathExpression expr);
106:
107: /**
108: * Adds special replacing function stub() to all places where required
109: * components are skipped. At first it relates to skipped arguments of
110: * functions or operations. Actually all operations require the operands
111: * are specified. Otherwise the generated text representation will be
112: * corrupted.
113: */
114: void fillInStubs(XPathExpression expr);
115:
116: //--------------------------------------------------------------------------
117: // SPI methods
118: //--------------------------------------------------------------------------
119:
120: VariableResolver getVariableResolver();
121:
122: void setVariableResolver(VariableResolver resolver);
123:
124: /**
125: * An XPath can contain elements from various namespaces.
126: * The method provides an object which helps to resolve namespaces to models.
127: */
128: ExternalModelResolver getExternalModelResolver();
129:
130: void setExternalModelResolver(ExternalModelResolver resolver);
131:
132: /**
133: * It is necessary to convert prefixes to full namespace URIs and back.
134: */
135: NamespaceContext getNamespaceContext();
136:
137: void setNamespaceContext(NamespaceContext newContext);
138:
139: /**
140: * It's intended to collect validation messages.
141: */
142: XPathValidationContext getValidationContext();
143:
144: void setValidationContext(XPathValidationContext vContext);
145:
146: /**
147: * Helps to resolve extended functions. The set of such functins is
148: * specific to the particula case.
149: */
150: ExtensionFunctionResolver getExtensionFunctionResolver();
151:
152: void setExtensionFunctionResolver(
153: ExtensionFunctionResolver extFuncResolver);
154:
155: SchemaComponent getLastSchemaComponent();
156: }
|