Statistics
| Revision:

svn-gvsig-desktop / trunk / org.gvsig.desktop / org.gvsig.desktop.library / org.gvsig.expressionevaluator / org.gvsig.expressionevaluator.lib / org.gvsig.expressionevaluator.lib.api / src / main / java / org / gvsig / expressionevaluator / ExpressionUtils.java @ 44215

History | View | Annotate | Download (5.25 KB)

1
package org.gvsig.expressionevaluator;
2

    
3
import org.apache.commons.lang3.StringUtils;
4
import org.gvsig.expressionevaluator.ExpressionBuilder.Value;
5
import org.gvsig.tools.script.Script;
6

    
7
/**
8
 *
9
 * @author jjdelcerro
10
 */
11
public class ExpressionUtils {
12

    
13
    public static boolean isEmpty(Expression expression) {
14
        return expression == null || expression.isEmpty();
15
    }
16

    
17
    public static boolean isPhraseEmpty(Expression expression) {
18
        return expression == null || expression.isPhraseEmpty();
19
    }
20
    
21
    public static Expression defaultIfEmpty(Expression expression, Expression defaultValue) {
22
        if( expression==null || expression.isEmpty() ) {
23
            return defaultValue;
24
        }
25
        return expression;
26
    }
27
    
28
    public static Expression defaultNullIfEmpty(Expression expression) {
29
        if( expression==null || expression.isEmpty() ) {
30
            return null;
31
        }
32
        return expression;
33
    }
34
    
35
    public static Expression defaultIfPhraseEmpty(Expression expression, Expression defaultValue) {
36
        if( expression==null || expression.isPhraseEmpty() ) {
37
            return defaultValue;
38
        }
39
        return expression;
40
    }
41

    
42
    public static Expression defaultNullIfPhraseEmpty(Expression expression) {
43
        if( expression==null || expression.isPhraseEmpty() ) {
44
            return null;
45
        }
46
        return expression;
47
    }
48
   
49
    public static Expression createExpression() {
50
        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();
51
        return expression;
52
    }
53

    
54
    public static Expression createExpression(String phrase) {
55
        if( StringUtils.isBlank(phrase) ) {
56
            return null;
57
        }
58
        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();
59
        expression.setPhrase(phrase);
60
        return expression;
61
    }
62

    
63
    public static Expression createExpression(String phrase, String code, Script... scripts) {
64
        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();
65
        expression.setPhrase(phrase);
66
        expression.setUserScript(code);
67
        for (Script script : scripts) {
68
            expression.addScript(script);
69
        }
70
        return expression;
71
    }
72

    
73
    public static Expression createExpression(String phrase, String code, String languaje, Script... scripts) {
74
        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();
75
        expression.setPhrase(phrase);
76
        expression.setUserScript(code, languaje);
77
        for (Script script : scripts) {
78
            expression.addScript(script);
79
        }
80
        return expression;
81
    }
82

    
83
    public static ExpressionBuilder createExpressionBuilder() {
84
        ExpressionBuilder builder = ExpressionEvaluatorLocator.getManager().createExpressionBuilder();
85
        return builder;
86
    }
87

    
88
    public static Code compile(String expression) {
89
        if( StringUtils.isBlank(expression) ) {
90
            return null;
91
        }
92
        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();
93
        Code code = manager.compile(expression);
94
        return code;
95
    }
96

    
97
    public static Object evaluate(SymbolTable symbolTable, String expression) {
98
        if( StringUtils.isBlank(expression) ) {
99
            return null;
100
        }
101
        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();
102
        Object x = manager.evaluate(symbolTable, expression);
103
        return x;
104
    }
105

    
106
    public static Object evaluate(SymbolTable symbolTable, Code code) {
107
        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();
108
        Object x = manager.evaluate(symbolTable, code);
109
        return x;
110
    }
111

    
112
    public static Code optimize(SymbolTable symbolTable, Code code) {
113
        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();
114
        code = manager.optimize(symbolTable, code);
115
        return code;
116
    }
117

    
118
    public static String toString(Value value, Formatter formatter) {
119
        if( value == null ) {
120
            return null;
121
        }
122
        if( formatter==null ) {
123
            formatter = ExpressionBuilder.EMPTY_FORMATTER;
124
        }
125
        return value.toString(formatter);
126
    }
127

    
128
    public static String toString(Value value) {
129
        if( value == null ) {
130
            return null;
131
        }
132
        return value.toString(ExpressionBuilder.EMPTY_FORMATTER);
133
    }
134

    
135
    public static String toString(Code code, Formatter formatter) {
136
        if( code == null ) {
137
            return null;
138
        }
139
        if( formatter==null ) {
140
            formatter = Code.EMPTY_FORMATTER;
141
        }
142
        return code.toString(formatter);
143
    }
144

    
145
    public static String toString(Code code) {
146
        if( code == null ) {
147
            return null;
148
        }
149
        return code.toString(Code.EMPTY_FORMATTER);
150
    }
151

    
152
    public static Expression createExpressionFromJSON(String json) {
153
        Expression expression = ExpressionUtils.createExpression();
154
        expression.fromJSON(json);
155
        return expression;
156
    }
157

    
158
    public static MutableSymbolTable createSymbolTable() {
159
        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();
160
        MutableSymbolTable symbolTable = manager.createSymbolTable();
161
        return symbolTable;
162
    }
163

    
164
}