Revision 43521 trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/src/main/java/org/gvsig/expressionevaluator/impl/DefaultCodeBuilder.java

View differences:

DefaultCodeBuilder.java
15 15
import static org.gvsig.expressionevaluator.Code.UNDEFINED;
16 16
import org.gvsig.expressionevaluator.CodeBuilder;
17 17
import org.gvsig.expressionevaluator.Function;
18
import org.gvsig.expressionevaluator.Interpreter;
18 19
import org.gvsig.tools.exception.BaseException;
19 20
import org.gvsig.tools.visitor.Visitor;
20 21

  
......
27 28
            return UNDEFINED;
28 29
        }
29 30

  
30
        @Override
31
        public String toString() {
32
            return this.toString(this);
33
        }
31
//        @Override
32
//        public String toString() {
33
//            return this.toString(this);
34
//        }
35
//
36
//        private String toString(Code code) {
37
//            StringBuilder builder = new StringBuilder();
38
//            switch( code.code() ) {
39
//            case CONSTANT: {
40
//                Object value = ((Constant) code).value();
41
//                if( value instanceof CharSequence ) {
42
//                    value = StringUtils.wrap(value.toString(), "'");
43
//                }
44
//                builder.append(value);
45
//            }
46
//            break;
47
//
48
//            case IDENTIFIER:
49
//                builder.append(((Identifier) code).name());
50
//                break;
51
//
52
//            case CALLER:
53
//                Caller caller = (Caller) code;
54
//                builder.append(caller.name());
55
//                builder.append("(");
56
//                if( caller.args() != null ) {
57
//                    boolean skipcoma = true;
58
//                    for( Code arg : caller.args() ) {
59
//                        if( skipcoma ) {
60
//                            skipcoma = false;
61
//                        } else {
62
//                            builder.append(", ");
63
//                        }
64
//                        builder.append(toString(arg));
65
//                    }
66
//                }
67
//                builder.append(")");
68
//                break;
69
//            }
70
//            return builder.toString();
71
//        }
34 72

  
35
        private String toString(Code code) {
36
            StringBuilder builder = new StringBuilder();
37
            switch( code.code() ) {
38
            case CONSTANT: {
39
                    Object value = ((Constant) code).value();
40
                    if( value instanceof CharSequence ) {
41
                        value = StringUtils.wrap(value.toString(), "'");
42
                    }
43
                    builder.append(value);
44
                }
45
                break;
46

  
47
            case IDENTIFIER:
48
                builder.append(((Identifier) code).name());
49
                break;
50

  
51
            case CALLER:
52
                Caller caller = (Caller) code;
53
                builder.append(caller.name());
54
                builder.append("(");
55
                if( caller.args()!=null ) {
56
                    boolean skipcoma = true; 
57
                    for( Code arg : caller.args() ) {
58
                        if( skipcoma ) {
59
                            skipcoma = false;
60
                        } else {
61
                            builder.append(", ");
62
                        }
63
                        builder.append(toString(arg));
64
                    }
65
                }
66
                builder.append(")");
67
                break;
68
            }
69
            return builder.toString();
70
        }
71

  
72 73
        @Override
73 74
        public void accept(Visitor visitor) throws BaseException {
74 75
            visitor.visit(this);
......
94 95
            return this.value;
95 96
        }
96 97

  
98
        @Override
99
        public String toString() {
100
            StringBuilder builder = new StringBuilder();
101
            Object v = this.value();
102
            if( v instanceof CharSequence ) {
103
                v = StringUtils.wrap(v.toString(), "'");
104
            }
105
            builder.append(v);
106
            return builder.toString();
107
        }
108

  
97 109
    }
98 110

  
99 111
    public class BaseIdentifier extends BaseCode implements Identifier {
......
114 126
            return this.name;
115 127
        }
116 128

  
129
        @Override
130
        public String toString() {
131
            StringBuilder builder = new StringBuilder();
132
            builder.append("[");
133
            builder.append(this.name());
134
            builder.append("]");
135
            return builder.toString();
136
        }
137

  
117 138
    }
118 139

  
119 140
    public class BaseArguments implements Arguments {
......
149 170

  
150 171
        @Override
151 172
        public void accept(Visitor visitor) throws BaseException {
152
            for( Code arg : this.args) {
173
            for( Code arg : this.args ) {
153 174
                visitor.visit(arg);
154 175
            }
155 176
        }
156 177

  
178
        @Override
179
        public String toString() {
180
            if( args != null ) {
181
                StringBuilder builder = new StringBuilder();
182
                boolean skipcoma = true;
183
                for( Code arg : args ) {
184
                    if( skipcoma ) {
185
                        skipcoma = false;
186
                    } else {
187
                        builder.append(", ");
188
                    }
189
                    builder.append(arg.toString());
190
                }
191
                return builder.toString();
192
            }
193
            return "";
194
        }
195

  
157 196
    }
158 197

  
159 198
    public class BaseCaller extends BaseCode implements Caller {
......
176 215
        }
177 216

  
178 217
        @Override
179
        public Object call(Object[] args) throws Exception {
180
            return this.function.call(args);
218
        public Object call(Interpreter interpreter, Object[] args) throws Exception {
219
            return this.function.call(interpreter, args);
181 220
        }
182 221

  
183 222
        @Override
......
212 251
            this.args.accept(visitor);
213 252
        }
214 253

  
254
        @Override
255
        public String toString() {
256
            StringBuilder builder = new StringBuilder();
257
            builder.append(this.name());
258
            builder.append("(");
259
            if( this.args()!=null ) {
260
                builder.append(this.args().toString());
261
            }
262
            builder.append(")");
263
            return builder.toString();
264
        }
265

  
215 266
    }
216 267

  
217 268
    @Override

Also available in: Unified diff