Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.io.IOException;

import java.io.PushbackReader;

import java.io.StringReader;

import org.gvsig.expressionevaluator.spi.BaseExpressionEvaluator;

import java.io.StringWriter;

import java.io.Writer;

import java.net.URI;

import java.util.ArrayList;

import org.gvsig.expressionevaluator.Grammar;

import org.gvsig.expressionevaluator.GrammarFactory;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.io.output.ProxyWriter;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.Optimizer;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.SymbolTableFactory;

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.ConverterToCode;

import org.gvsig.expressionevaluator.ExpressionEvaluator;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.GrammarSet;

import org.gvsig.expressionevaluator.ReprMethod;

import org.gvsig.expressionevaluator.UserOperator;

import org.gvsig.expressionevaluator.impl.converterstocode.ArrayToCode;

import org.gvsig.expressionevaluator.impl.converterstocode.BooleanToCode;

import org.gvsig.expressionevaluator.impl.converterstocode.CharsequenceToCode;

import org.gvsig.expressionevaluator.impl.converterstocode.IterableToCode;

import org.gvsig.expressionevaluator.impl.converterstocode.IteratorToCode;

import org.gvsig.expressionevaluator.impl.converterstocode.ListToCode;

import org.gvsig.expressionevaluator.impl.converterstocode.NullToCode;

import org.gvsig.expressionevaluator.impl.converterstocode.NumberToCode;

import org.gvsig.expressionevaluator.impl.converterstocode.ObjectToCode;

import org.gvsig.expressionevaluator.impl.repr.ReprNull;

import org.gvsig.expressionevaluator.impl.repr.ReprObject;

import org.gvsig.expressionevaluator.spi.formatter.value.BaseFormatter;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.script.Script;

import org.gvsig.tools.util.FilteredIterable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultExpressionEvaluatorManager implements ExpressionEvaluatorManager {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultExpressionEvaluatorManager.class);

    private Double accuracy;

    private final Map<String,SymbolTableFactory>symbolTableFactories;

    private final Map<String,GrammarFactory> grammarFactories;

    private Bookmarks<Expression> bookmarks;

    private static final String BOOKMARKSANDHISTORY_NAME = "ExpressionManager";

    private History<Expression> history;

    private SymbolTable inmutableSymbolTable;

    private ResourcesStorage scriptsResourcesStorage;

    private final List<ClassLoader> loaders;

    private Formatter<ExpressionBuilder.Value> expressionBuilderFormatter;

    private Map<String,ConverterToCode> convertersToCode;

    private Map<String,ConverterToCode> convertersToCode0;

    private Map<String,UserOperator> userOperators;

    public DefaultExpressionEvaluatorManager() {

        this.symbolTableFactories = new HashMap<>();

        this.grammarFactories = new HashMap<>();

        this.loaders = new ArrayList<>();

        this.scriptsResourcesStorage = ResourcesStorage.EMPTY_RESOURCESSTORAGE;

        this.loaders.add(this.getClass().getClassLoader());

        this.expressionBuilderFormatter = new BaseFormatter();

    }

    @Override

    public SymbolTable getSymbolTable(String name) {

        if( name == null ) {

            return null;

        }

        SymbolTableFactory factory = this.symbolTableFactories.get(name.toUpperCase());

        if( factory == null ) {

            return null;

        }

        return factory.create();

    }

    @Override

    public Collection<SymbolTableFactory> getSymbolTableFactories() {

        return this.symbolTableFactories.values();

    }

    @Override

    public final void registerSymbolTable(SymbolTableFactory factory) {

        if( factory == null ) {

            throw new IllegalArgumentException("factory can't be null");

        }

        this.symbolTableFactories.put(factory.getName().toUpperCase(),factory);

        this.inmutableSymbolTable = null;

    }

    @Override

    public SymbolTable getInmutableSymbolTable() {

        if( this.inmutableSymbolTable==null ) {

            this.inmutableSymbolTable = new InmutableSymbolTable();

        }

        return this.inmutableSymbolTable;

    }

    @Override

    public Object evaluate(String source) {

        Compiler compiler = this.createCompiler();

        Code code = compiler.compileExpression(source);

        DefaultInterpreter interpreter = new DefaultInterpreter();

        return interpreter.run(code);

    }

    @Override

    public Object evaluate(SymbolTable symbolTable, String source) {

        Compiler compiler = this.createCompiler();

        Code code = compiler.compileExpression(source);

        return this.evaluate(symbolTable, code);

    }

    @Override

    public Object evaluate(SymbolTable symbolTable, Code code) {

        DefaultInterpreter interpreter = new DefaultInterpreter();

        if( symbolTable!=null ) {

            interpreter.setSymbolTable(symbolTable);

        }

        return interpreter.run(code);

    }

    @Override

    public String evaluateDynamicText(String source) {

        return evaluateDynamicText(null, source);

    }

    @Override

    public boolean isDynamicText(String source) {

        String[] sources = StringUtils.substringsBetween(source, DYNAMICTEXT_STARTTAG, DYNAMICTEXT_ENDTAG);

        if( ArrayUtils.isEmpty(sources) ) {

            return false;

        }

        return true;

    }

    private static final int MODE_EXPRESSION = 0;

    private static final int MODE_STATEMENT = 1;

    public static String dynamicTextToScript(String s, String contentsName) {

        PushbackReader reader = new PushbackReader(new StringReader(s),100);

        StringBuilder script = new StringBuilder();

        StringBuilder buffer = new StringBuilder();

        try {

            script.append("begin\n");

//            script.append(contentsName);

//            script.append(" := StringWriter();\n");

            int mode;

            int ch;

            int ch2;

            while(true) {

                ch = reader.read();

                if( ch == -1 ) {

                    break;

                }

                switch(ch) {

                    case '<':

                        ch2 = reader.read();

                        if( ch2 != '%') {

                            buffer.append((char)ch);

                            buffer.append((char)ch2);

                            break;

                        }

                        ch2 = reader.read();

                        if( ch2 == '=' ) {

                            mode = MODE_EXPRESSION;

                        } else {

                            mode = MODE_STATEMENT;

                            reader.unread(ch2);

                        }

                        if( buffer.length()>0 ) {

                            script.append(contentsName);

                            script.append(".append('");

                            script.append(buffer.toString());

                            script.append("');");

                        }

                        buffer.setLength(0);

                        while(true) {

                            ch = reader.read();

                            if( ch==-1) {

                                break;

                            }

                            if( ch == '%' ) {

                                ch2 = reader.read();

                                if( ch2 == '>') {

                                    if( mode == MODE_EXPRESSION ) {

                                        if( buffer.length()>0 ) {

                                            script.append(contentsName);

                                            script.append(".append(");

                                            script.append(buffer.toString());

                                            script.append(");");

                                        }

                                    } else {

                                        script.append(buffer.toString());

                                    }

                                    buffer.setLength(0);

                                    break;

                                } else {

                                    buffer.append((char)ch);

                                    buffer.append((char)ch2);

                                }

                            } else {

                                buffer.append((char)ch);

                            }

                        }

                        break;

                    case '\'':

                        buffer.append('\'');

                        buffer.append('\'');

                        break;

                    default:

                        buffer.append((char)ch);

                        break;

                }

            }

        } catch (IOException ex) {

        }

        if( buffer.length()>0 ) {

            script.append(contentsName);

            script.append(".append('");

            script.append(buffer.toString());

            script.append("');");        

            script.append("\n");

        }

//        script.append(contentsName);

//        script.append(".toString();\n");

        script.append("end\n");

        return script.toString();

    }

    @Override

    public String evaluateDynamicText(SymbolTable symbolTable, String source) {

        return evaluateDynamicText(symbolTable, source, null);

    }

    public static class AppendExWriter extends ProxyWriter {

        public AppendExWriter(Writer writer) {

            super(writer);

        }

        public Writer append(Object x) throws IOException {

            if( x!=null ) {

                this.append(x.toString());

            }

            return this;

        }

        public Writer getWriter() {

            return this.out;

        }

    }

    @Override

    public String evaluateDynamicText(SymbolTable symbolTable, String source, Writer output) {

        return this.evaluateDynamicText(symbolTable, source, output, scriptsResourcesStorage);

    }

    @Override

    public String evaluateDynamicText(SymbolTable symbolTable, String source, Writer output, ResourcesStorage resources) {

        try {

            if (!StringUtils.contains(source, DYNAMICTEXT_STARTTAG)) {

                if (output == null) {

                    return source;

                }

                output.append(source);

                return null;

            }

            AppendExWriter writer;

            if (output == null) {

                writer = new AppendExWriter(new StringWriter());

            } else {

                writer = new AppendExWriter(output);

            }

            String script = dynamicTextToScript(source, "contents");

            MutableSymbolTable st = this.createSymbolTable();

            if (symbolTable != null) {

                st.addSymbolTable(symbolTable);

            }

            st.setVar("contents", writer);

            Compiler compiler = this.createCompiler();

            DefaultInterpreter interpreter = new DefaultInterpreter();

            interpreter.setSymbolTable(st);

            if( resources!=null ) {

                interpreter.setResourcesStorage(resources);

            }

            Code code = compiler.compileExpression(script);

            interpreter.run(code);            

            if (output == null) {

                return ((StringWriter) writer.getWriter()).toString();

            }

            return null;

        } catch (IOException ex) {

            throw new RuntimeException("Can't evaluate dynamic-text.", ex);

        }

    }

    public String evaluateDynamicText_old(SymbolTable symbolTable, String source) {

        String[] sources = StringUtils.substringsBetween(source, DYNAMICTEXT_STARTTAG, DYNAMICTEXT_ENDTAG);

        if( ArrayUtils.isEmpty(sources) ) {

            return source;

        }

        String[] values = new String[sources.length];

        DefaultInterpreter interpreter = new DefaultInterpreter();

        if( symbolTable!=null ) {

            interpreter.setSymbolTable(symbolTable);

        }

        StringWriter writer = new StringWriter();

        interpreter.setWriter(writer);

        DefaultCompiler compiler = new DefaultCompiler(this);

        for (int i = 0; i < sources.length; i++) {

            String theSource = sources[i];

            if( StringUtils.startsWith(theSource, "=") ) {

                Code code = compiler.compileExpression(theSource.substring(1));

                Object value = interpreter.run(code);

                values[i] = Objects.toString(value, "");

            } else {

                Code code = compiler.compileExpression(theSource.substring(0));

                writer.getBuffer().setLength(0);

                interpreter.run(code);

                values[i] = writer.toString();

            }

            sources[i] = DYNAMICTEXT_STARTTAG+sources[i]+DYNAMICTEXT_ENDTAG;

        }

        String output = StringUtils.replaceEach(source, sources, values);

        return output;

    }

    @Override

    public Code compile(String source) {

        Compiler compiler = this.createCompiler();

        return compiler.compileExpression(source);

    }

    @Override

    public Code compile(LexicalAnalyzer lex, String source) {

        Compiler compiler = this.createCompiler();

        compiler.setLexicalAnalyzer(lex);

        return compiler.compileExpression(source);

    }

    @Override

    public Code optimize(SymbolTable symbolTable, Code code) {

        Optimizer optimizer = this.createOptimizer();

        return optimizer.optimize(symbolTable, code);

    }

    @Override

    public MutableSymbolTable createSymbolTable() {

        DefaultSymbolTable theSymbolTable = new DefaultSymbolTable();

        return theSymbolTable;

    }

    @Override

    public void populateSymbolTable(SymbolTable aSymbolTable) {

        for (SymbolTableFactory factory : this.getSymbolTableFactories() ) {

            try {

                if( factory.isAutoload() ) {

                    SymbolTable symbolTable = factory.create();

                    aSymbolTable.addSymbolTable(symbolTable);

                }

            } catch(Throwable th) {

                String factoryName = "Unknown";

                try {

                    factoryName = factory.getName();

                } catch(Throwable th2) {

                    // Do nothing

                }

                LOGGER.warn("Can't create symbol table '"+factoryName+"', ignore this symbol table.");

                LOGGER.debug("Error creating symbol table.",th);

            }

        }

    }

    @Override

    public LexicalAnalyzer createLexicalAnalyzer() {

        return new SQLLexicalAnalyzer();

    }

    @Override

    public CodeBuilder createCodeBuilder() {

        return new DefaultCodeBuilder(this);

    }

    @Override

    public Compiler createCompiler() {

        DefaultCompiler compiler = new DefaultCompiler(this);

        this.populateGrammars(compiler);

        return  compiler;

    }

    @Override

    public Interpreter createInterpreter() {

        Interpreter interpreter = new DefaultInterpreter();

        interpreter.setResourcesStorage(this.scriptsResourcesStorage);

        return interpreter;

    }

    @Override

    public Double getAccuracy() {

        return this.accuracy;

    }

    @Override

    public void setAccuracy(Double accuracy) {

        this.accuracy = accuracy;

    }

    @Override

    public Expression createExpression() {

        DefaultExpression e = new DefaultExpression(this);

        return e;

    }

    @Override

    public ExpressionBuilder createExpressionBuilder() {

        ExpressionBuilder x = new DefaultExpressionBuilder(this);

        return x;

    }

    @Override

    public Optimizer createOptimizer() {

        Optimizer x = new DefaultOptimizer(this);

        return x;

    }

    @Override

    public void registerGrammar(GrammarFactory factory) {

        if( factory==null ) {

            throw new IllegalArgumentException("factory can't be null");

        }

        this.grammarFactories.put(factory.getName(), factory);

    }

    @Override

    public Collection<GrammarFactory> getGrammarFactories() {

        return this.grammarFactories.values();

    }

    public void populateGrammars(Compiler compiler) {

        GrammarSet grammarSet = compiler.getGrammars();

        for (GrammarFactory factory : this.getGrammarFactories() ) {

            if( factory.isAutoload() ) {

                Grammar grammar = factory.create();

                grammarSet.add(grammar);

            }

        }

    }

    @Override

    public Grammar createGrammar(String name) {

        DefaultGrammar grammar = new DefaultGrammar(name);

        return grammar;

    }

    @Override

    public Bookmarks<Expression> getBookmarks() {

        if( this.bookmarks==null ) {

             this.bookmarks = ToolsLocator.getBookmarksAndHistoryManager().getBookmarksGroup(BOOKMARKSANDHISTORY_NAME); 

        }

        return this.bookmarks;

    }

    @Override

    public History<Expression> getHistory() {

        if( this.history==null ) {

            this.history = ToolsLocator.getBookmarksAndHistoryManager().getHistoryGroup(BOOKMARKSANDHISTORY_NAME);

        }

        return this.history;

    }

    @Override

    public Script createScript(String name, String code, String languaje) {

        SimpleScript sc = new SimpleScript(this.createInterpreter(), name, code);

        return sc;

    }

    @Override

    public Script locateScript(String name) {

        return loadScript(this.scriptsResourcesStorage, name);

    }

    @Override

    public Script loadScript(final URI location) {

        ResourcesStorage.Resource res = null;

        try {

            if( location==null ) {

                return null;

            }

            String resourceName = FilenameUtils.getBaseName(location.getPath());

            res = ResourcesStorage.createResource(resourceName, location);

            if( res == null || !res.exists() ) {

                return null;

            }

            Script script = loadScript(res, resourceName);

            return script;

        } catch (Exception ex) {

            LOGGER.warn("Can't load script from URI.", ex);

            return null;

        } finally {

            IOUtils.closeQuietly(res);

        }

    }

    @Override

    public Script loadScript(ResourcesStorage storage, String name) {

        ResourcesStorage.Resource res = null;

        try {

            if( storage==null ) {

                return null;

            }

            res = storage.getResource(name);

            if( res == null || !res.exists() ) {

                return null;

            }

            Script script = loadScript(res, name);

            return script;

        } catch (Exception ex) {

            LOGGER.warn("Can't load script from resources storage.", ex);

            return null;

        } finally {

            IOUtils.closeQuietly(res);

        }

    }

    private static final Pattern RE_LANG = Pattern.compile(".*lang[:]\\s*([a-zA-Z_][a-zA-Z_0-9_]*).*");

    private static final Pattern RE_ENCODING = Pattern.compile(".*encoding[:]\\s*([a-zA-Z_][a-zA-Z0-9_-]*).*");

    private Script loadScript(ResourcesStorage.Resource res, String name) {

        try {

            if( res == null || !res.exists() ) {

                return null;

            }

            String head = EncodingUtils.getFirstLine(res.asInputStream());

            IOUtils.closeQuietly(res); // Eliminar con org.gvsig.tools > 3.0.230

            if( StringUtils.isEmpty(head) ) {

                return null;

            }

            String encoding = EncodingUtils.getEncoding(head);

            String lang = "cosa";

            Matcher m = RE_LANG.matcher(head);

            if( m!=null && m.matches() && m.groupCount()==1 ) {

                String s = m.group(1);

                if( !StringUtils.isBlank(s) ) {

                    lang = s;

                }

            }

            String source;

            if( StringUtils.isBlank(encoding) ) {

                source = IOUtils.toString(res.asInputStream());

            } else {

                source = IOUtils.toString(res.asInputStream(), encoding);

            }

            Script script = this.createScript(name, source, lang);

            return script;

        } catch (Exception ex) {

            LOGGER.warn("Can't load script from resource.", ex);

            return null;

        } finally {

            IOUtils.closeQuietly(res);

        }

    }

    @Override

    public ResourcesStorage getScriptsResourcesStorage() {

        return this.scriptsResourcesStorage;

    }

    @Override

    public void setScriptsResourcesStorage(ResourcesStorage scriptsResourcesStorage) {

        if(this.scriptsResourcesStorage != null){

            DisposeUtils.disposeQuietly(this.scriptsResourcesStorage);

        }

        DisposeUtils.bind(scriptsResourcesStorage);

        this.scriptsResourcesStorage = scriptsResourcesStorage;

    }

    private final List<ReprMethod> reprMethods = new ArrayList<>();

    private final Map<Class,ReprMethod> reprMethodsCache = new HashMap<>();

    private final ReprMethod reprNull = new ReprNull();

    private final ReprMethod reprObject = new ReprObject();

    @Override

    public void addReprMethod(ReprMethod method) {

        this.reprMethods.add(method);

        this.reprMethodsCache.clear();

    }

    @Override

    public ReprMethod getReprMethod(Object value) {

        if( value == null ) {

            return this.reprNull;

        }

        ReprMethod method = this.reprMethodsCache.get(value.getClass());

        if( method!=null ) {

            return method;

        }

        for (ReprMethod theMethod : reprMethods) {

            if( theMethod.isApplicable(value) ) {

                this.reprMethodsCache.put(value.getClass(), theMethod);

                return theMethod;

            }

        }

        return this.reprObject;

    }

    @Override

    public void registerClassLoader(ClassLoader loader) {

      this.loaders.add(loader);

    }

    @Override

    public List<ClassLoader> getClassLoaders() {

      return Collections.unmodifiableList(loaders);

    }

    @Override

    public Formatter<ExpressionBuilder.Value> getExpressionBuilderFormatter() {

      return expressionBuilderFormatter;

    }

    @Override

    public void registerExpressionBuilderFormatter(Formatter<ExpressionBuilder.Value> formatter) {

      this.expressionBuilderFormatter = formatter;

    }

    @Override

    public ExpressionEvaluator createExpressionEvaluator(Expression expression) {

        return new BaseExpressionEvaluator(expression);

    }

    @Override

    public ExpressionEvaluator createEvaluator(String expression) {

        Expression exp = this.createExpression();

        exp.setPhrase(expression);

        return new BaseExpressionEvaluator(exp);

    }

    @Override

    public boolean hasHostExpressions(Code statement) {

        try {

            List<Code> hostExpressions = new ArrayList<>();

            statement.accept(

                    (Object code) -> {

                        if( !(code instanceof Code.Callable) ) {

                            return;

                        }

                        Code.Callable callable = (Code.Callable) code;

                        if( StringUtils.equalsIgnoreCase(callable.name(), ExpressionBuilder.FUNCTION_$HOSTEXPRESSION) ) {

                            hostExpressions.add(callable);

                        }

                    }, null

            );

            return !hostExpressions.isEmpty();

        } catch (BaseException ex) {

            throw new RuntimeException("Can't check host expressions", ex);

        }

    }

    @Override

    public boolean hasHostExpressions(ExpressionBuilder.Value statement) {

        return HostExpressionUtils.hasHostExpressions(statement);

    }

    @Override

    public Code resolveHostExpressions(Code statement, Interpreter interpreter) {

        return HostExpressionUtils.resolveHostExpressions(statement, interpreter);

    }

    @Override

    public ExpressionBuilder.Value resolveHostExpressions(ExpressionBuilder.Value statement, SymbolTable symbolTable) {

        return HostExpressionUtils.resolveHostExpressions(statement, symbolTable);

    }

    @Override

    public Code resolveHostExpressions(Code statement, SymbolTable symbolTable) {

        return HostExpressionUtils.resolveHostExpressions(statement, symbolTable);

    }

    @Override

    public Expression resolveHostExpressions(Expression expression, SymbolTable symbolTable) {

        return HostExpressionUtils.resolveHostExpressions(expression, symbolTable);

    }

    @Override

    public boolean hasHostExpressions(String statement) {

        return HostExpressionUtils.hasHostExpressions(statement);

    }

    @Override

    public ExpressionBuilder.Value getHostExpressionValue(ExpressionBuilder.Function hostExpression, ExpressionBuilder expbuilder) {

        return HostExpressionUtils.getHostExpressionValue(hostExpression, expbuilder);

    }

    @Override

    public ExpressionBuilder.Value getHostExpressionValue(ExpressionBuilder.Function hostExpression, ExpressionBuilder expbuilder, SymbolTable symbolTable) {

        return HostExpressionUtils.getHostExpressionValue(hostExpression, expbuilder, symbolTable);

    }

    public void initConvertersToCode() {

        this.convertersToCode0 = new LinkedHashMap<>();

        ConverterToCode[] converters = new ConverterToCode[] { 

            new NullToCode(),

            new CharsequenceToCode(),

            new NumberToCode(),

            new BooleanToCode(),

            new IteratorToCode(),

            new IterableToCode(),

            new ListToCode(),

            new ArrayToCode(),

            new ObjectToCode()

        };

        for (ConverterToCode converter : converters) {

            this.convertersToCode0.put(converter.getName(),converter);

        }

        this.convertersToCode = new LinkedHashMap<>();

    }

    @Override

    public void registerCodeConverter(ConverterToCode converter) {

        if( this.convertersToCode == null ) {

            this.initConvertersToCode();

        }

        this.convertersToCode.put(converter.getName(), converter);

    }

    @Override

    public ConverterToCode getConverterToCode(Object ob) {

        if( this.convertersToCode == null ) {

            this.initConvertersToCode();

        }

        for (ConverterToCode converter : this.convertersToCode.values()) {

            if( converter.isApplicable(ob) ) {

                return converter;

            }

        }

        for (ConverterToCode converter : this.convertersToCode0.values()) {

            if( converter.isApplicable(ob) ) {

                return converter;

            }

        }

        return null;

    }

    @Override

    public ExpressionBuilder.Value convertToValue(Object obj) {

        Code code = this.convertToCode(obj);

        ExpressionBuilder.Value value = code.toValue();

        return value;

    }

    @Override

    public Code convertToCode(Object obj) {

        return convertToCode(null, obj, null);

    }

    @Override

    public Code convertToCode(CodeBuilder builder, Object obj, Map<String,Object> props) {

        if( this.convertersToCode == null ) {

            this.initConvertersToCode();

        }

        if( builder == null ) {

            builder = this.createCodeBuilder();

        }

        for (ConverterToCode converter : this.convertersToCode.values()) {

            if( converter.isApplicable(obj) ) {

                return converter.toCode(builder, obj, props);

            }

        }

        for (ConverterToCode converter : this.convertersToCode0.values()) {

            if( converter.isApplicable(obj) ) {

                return converter.toCode(builder, obj, props);

            }

        }

        return null;

    }

    public ConverterToCode getConverterToCodeByName(String name) {

        ConverterToCode converter = this.convertersToCode.get(name);

        if( converter!=null ) {

            return converter;

        }

        converter = this.convertersToCode0.get(name);

        return converter;

    }

    @Override

    public void registerUserOperator(UserOperator userOperator) {

        if( this.userOperators == null ) {

            this.userOperators = new HashMap<>();

        }

        this.userOperators.put(userOperator.name(), userOperator);

    }

    @Override

    public Iterable<UserOperator> getUserDefinedOperators(String precedence) {

        if( this.userOperators == null ) {

            return Collections.EMPTY_LIST;

        }

        if( StringUtils.isBlank(precedence) ) {

            return this.userOperators.values();

        }

        return new FilteredIterable<>(

                this.userOperators.values(), 

                (UserOperator t) -> StringUtils.equalsIgnoreCase(precedence, t.precedence())

        );

    }

}