001: /*
002: * Classifier.java February 2006
003: *
004: * Copyright (C) 2006, Niall Gallagher <niallg@users.sf.net>
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: *
010: * This library is distributed in the hope that it will be useful,
011: * but WITHOUT ANY WARRANTY; without even the implied warranty of
012: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
013: * GNU Lesser General Public License for more details.
014: *
015: * You should have received a copy of the GNU Lesser General
016: * Public License along with this library; if not, write to the
017: * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
018: * Boston, MA 02111-1307 USA
019: */
020:
021: package simple.page.translate;
022:
023: import java.lang.reflect.Constructor;
024:
025: /**
026: * The <code>Classifier</code> object is used to classify tokens that
027: * have been emitted from the lexical analysis phase. This will
028: * examine the text within the token to determine the class of token.
029: * Classification of the token results in a <code>Token</code> object
030: * being created. This object is then used to process the data.
031: *
032: * @author Niall Gallagher
033: */
034: final class Classifier {
035:
036: /**
037: * This method performs the classification of the token. This will
038: * examine the structure of the token before classifing it. This
039: * basically takes a look at the JSP tags beginning the token and
040: * from the tags determines the class of token it represents.
041: *
042: * @param token this is the token text to be classified
043: *
044: * @return this returns a token to process the provided text
045: */
046: public Token getToken(String token) {
047: if (token.startsWith("<%@ page")) {
048: return getToken(Page.class, token);
049: }
050: if (token.startsWith("<%@ include")) {
051: return getToken(Include.class, token);
052: }
053: if (token.startsWith("<%@ insert")) {
054: return getToken(Insert.class, token);
055: }
056: if (token.startsWith("<%=")) {
057: return getToken(Print.class, token);
058: }
059: if (token.startsWith("<%--")) {
060: return getToken(Comment.class, token);
061: }
062: if (token.startsWith("<%!")) {
063: return getToken(Declaration.class, token);
064: }
065: if (token.startsWith("<%")) {
066: return getToken(Code.class, token);
067: }
068: return getToken(Text.class, token);
069: }
070:
071: /**
072: * This method is used to create a token of the specified type. The
073: * class provided must extend the <code>Token</code> object. Once
074: * the token has been created it can be processed, and used to
075: * build the document definition before the generation phase.
076: *
077: * @param type this is the class implementing the token type
078: * @param token this is the text to be processed by the token
079: *
080: * @return this returns a token that can parse the text provided
081: */
082: public Token getToken(Class type, String token) {
083: try {
084: Constructor factory = getConstructor(type);
085: return (Token) factory.newInstance(new Object[] { token });
086: } catch (Exception e) {
087: return null;
088: }
089: }
090:
091: /**
092: * This is used to construct the token implementation using a well
093: * known signature. The constructor signature must take a string
094: * representing the token to be parsed. The <code>Class</code>
095: * provided must be an implementation of the token type.
096: *
097: * @param type this is the clas implementing the token type
098: *
099: * @return this returns a factory method for creating a token
100: */
101: private Constructor getConstructor(Class type) throws Exception {
102: Class[] list = new Class[] { String.class };
103: return type.getDeclaredConstructor(list);
104: }
105: }
|