com.datastax.data.dataset.Parser Maven / Gradle / Ivy

Go to download


package com.datastax.data.dataset;

import com.datastax.data.dataset.event.DataTableEventAdapter;
import net.sf.jga.fn.*;
import net.sf.jga.fn.adaptor.*;
import net.sf.jga.fn.algorithm.Accumulate;
import net.sf.jga.fn.algorithm.Count;
import net.sf.jga.fn.algorithm.TransformUnary;
import net.sf.jga.fn.arithmetic.Average;
import net.sf.jga.fn.arithmetic.Plus;
import net.sf.jga.fn.arithmetic.ValueOf;
import net.sf.jga.fn.comparison.Max;
import net.sf.jga.fn.comparison.Min;
import net.sf.jga.fn.property.*;
import net.sf.jga.parser.*;
import net.sf.jga.util.FilterIterator;

import java.text.MessageFormat;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;


class Parser extends JFXGParser {

    private DataTable table;

    private boolean inTableContext = false;

    private boolean inUse = false;

    
    private UnaryFunctor getRowsFn =
        new GetProperty(DataTable.class, "Rows");

    
    private UnaryFunctor getRowCountFn =
        new InvokeNoArgMethod(List.class, "size").compose(getRowsFn);

    
    private UnaryFunctor iterateTableFn =
        new InvokeNoArgMethod(List.class, "iterator")
            .compose(getRowsFn);

    
    private UnaryFunctor getValueFn =
        new GetProperty(DataValue.class, "Value");
    
    
    private Class[] filterCtorArgs = new Class[]{Iterator.class,UnaryFunctor.class};
    private BinaryFunctor,? extends Iterator>
        makeFilterFn = new Construct(filterCtorArgs,FilterIterator.class)
            .compose(new ArrayBinary>());

    public Parser(DataSet set) {
        bindThis(set);
        setUndecoratedDecimal(true);
    }
    
    
    
    

    synchronized boolean isInUse() { return inUse; }

    private Object element;
    
    
    synchronized UnaryFunctorRef parseComputedColumn(DataTable table, DataColumn column, String expression)
        throws ParseException
    {
        inUse = true;
        setCurrentTable(table);
        element = column;
        try {
            ReInit (new java.io.StringBufferInputStream(expression));
            return parseUnaryRef(DataRow.class);
        }
        finally {
            setCurrentTable(null);
            inUse = false;
            element =  null;
        }
    }

    
    synchronized GeneratorRef parseDataValue(String expression, DataValue value) throws ParseException {
        inUse = true;
        inTableContext = true;
        element = value;
        try {
            ReInit (new java.io.StringBufferInputStream(expression));
            return parseGeneratorRef();
        }
        finally {
            inTableContext = false;
            inUse = false;
            element = null;
            setCurrentTable(null);
        }
    }

    
    
    

    
    static Set register(Visitable exp, Object element, DataTableEventAdapter listener) {
        if (exp == null) 
            return new HashSet();
        
        Registrar registrar = new Registrar(element, listener);
        exp.accept(registrar);
        return registrar.sources;
    }

 
    
    
    static void unregister(Visitable exp, DataTableEventAdapter listener, Set dependencies)
    {
        if (exp != null)
            exp.accept(new Unregistrar(listener));

        dependencies.clear();
    }

    
    
    
    static private class Registrar extends AdaptorVisitor
            implements ConstantUnary.Visitor, TransformUnary.Visitor
    {
        
        
        
        private Set sources = new HashSet();

        
        
        
        private Object element;
        
        
        private DataTableEventAdapter listener;
        
        public Registrar(Object element, DataTableEventAdapter listener) {
            this.listener = listener;
            this.element = element;
        }
        
        public void visit(ConstantUnary constant) {
            Object value = constant.fn(null);
            if (value instanceof DataColumn) {
                DataColumn column = (DataColumn) value;
                column.getTable().addDataTableListener(listener);
                sources.add(column);
            }
        }
        
        public void visit(TransformUnary xform) {
            xform.getFunction().accept(this);
        }
        
        public void visit(Bind bind) {
            super.visit(bind);
            Object value = bind.getConstant();
            if (value instanceof DataTable) {
                DataTable table = (DataTable) value;
                table.addDataTableListener(listener);
            }
            else if (value instanceof DataValue) {
                DataValue data = (DataValue) value;
                data.addPropertyChangeListener("value", listener);
                data.addPropertyChangeListener("expression", listener);
                sources.add(data);
            }
        }
    }
        

    
    
    static private class Unregistrar extends AdaptorVisitor
            implements ConstantUnary.Visitor, TransformUnary.Visitor
    {
        private DataTableEventAdapter listener;
        
        public Unregistrar(DataTableEventAdapter listener) {
            this.listener = listener;
        }
        
        public void visit(ConstantUnary constant) {
            Object value = constant.fn(null);
            if (value instanceof DataColumn) {
                DataTable table = ((DataColumn) value).getTable();
                if (table != null)
                    table.removeDataTableListener(listener);
            }
        }
        
        public void visit(TransformUnary xform) {
            xform.getFunction().accept(this);
        }
        
        public void visit(Bind bind) {
            super.visit(bind);
            Object value = bind.getConstant();
            if (value instanceof DataTable) {
                DataTable table = (DataTable) value;
                table.removeDataTableListener(listener);
            }
            else if (value instanceof DataValue) {
                DataValue data = (DataValue) value;
                data.removePropertyChangeListener("value", listener);
                data.removePropertyChangeListener("expression", listener);
            }
        }
    }

    
    
    
    

    protected FunctorRef reservedWord(String name) throws ParseException {
        
        
        if (table == null) {
            DataTable maybeTable = ((DataSet) getBoundObject()).getTable(name);
            if (maybeTable != null) {
                setCurrentTable(maybeTable);
                return new GeneratorRef(new Constant(table), DataTable.class);
            }
        }
        
        
        
        
        if (table != null && name.equals(table.getName()))
            return new GeneratorRef(new Constant(table), DataTable.class);

        
        
        
        if (table != null) {
            DataColumn col = table.getColumn(name);
            if (col != null) {
                
                
                
                
                
                
                
                col.getType();
                if (col.dependsOn(element))
                    throw new UncheckedParseException("Circular Reference Exception");
                
                return makeColumnRef(table, col);
            }
        }

        
        DataValue maybeValue = ((DataSet) getBoundObject()).getValue(name);
        if (maybeValue != null) {
            if (maybeValue.dependsOn(element))
                throw new UncheckedParseException("Circular Reference Exception");
            
            return new GeneratorRef(getValueFn.bind(maybeValue), maybeValue.getType());
        }
        
        return null;
    }

    
    protected FunctorRef reservedField(FunctorRef prefix, String name) throws ParseException {
        if (isTableReference(prefix) && getReferencedTable(prefix).equals(table)) {
            DataColumn col = table.getColumn(name);
            if (col == null) {
                String err = "unknown column {0} in table {1}";
                String msg = MessageFormat.format(err, name, table.getName());
                throw new ParseException(msg);
            }

            return makeColumnRef(table, col);
        }                       

        return super.reservedField(prefix, name);
    }

    
    protected FunctorRef reservedFunction(String name, FunctorRef[] args) throws ParseException{
        if (inTableContext) {
            assert table != null;

            
            
            
            FunctorRef lastArgRef = args[args.length - 1];
            boolean hasFilter = (lastArgRef.getReturnType() == Boolean.class);

            UnaryFunctor filter = (hasFilter) ?
                ((UnaryFunctorRef) lastArgRef).getFunctor():
                new ConstantUnary(Boolean.TRUE);
            
            
            
            if ("count".equals(name)) {
                if (hasFilter) {
                    
                    
                    UnaryFunctor countFn =
                        new ValueOf(Integer.class)
                            .compose(new Count(filter))
                            .compose(iterateTableFn); 
                    
                    return new GeneratorRef(countFn.bind(table), Integer.class);
                }
                else {
                    return new GeneratorRef(getRowCountFn.bind(table), Integer.class);
                }
            }

            UnaryFunctor filterTableFn = (hasFilter) ?
                makeFilterFn.bind2nd(filter).compose(iterateTableFn): iterateTableFn;

            Generator iterateRows = filterTableFn.bind(table);

            
            
            
            
            Class type = args[0].getReturnType();
            if (type.isPrimitive())
                type = getBoxedType(type);
            
            TransformUnary xform = new TransformUnary(((UnaryFunctorRef) args[0]).getFunctor());
            
            
            
            if ("avg".equals(name)) {
                validateArgument(Number.class, type, name);

                Average avg = new Average(type);
                return new GeneratorRef(avg.generate(xform.generate(iterateRows)), type);
            }
            
            
            
            
            BinaryFunctor bf = null;
            
            if ("max".equals(name)) {
                validateArgument(Comparable.class, type, name);
                bf = new Max(new net.sf.jga.util.ComparableComparator());
            }
            else if ("min".equals(name)) {
                validateArgument(Comparable.class, type, name);
                bf = new Min(new net.sf.jga.util.ComparableComparator());
            }
            else if ("sum".equals(name)) {
                validateArgument(Number.class, type, name);
                bf = new Plus(type);
            }
            
            
            
            if (bf != null) {
                Generator gen = new Accumulate(bf).generate(xform.generate(iterateRows));
                return new GeneratorRef(gen, type);
            }
        }

        return super.reservedFunction(name, args);
    }


    
    
    

    
    
    private void setCurrentTable(DataTable table) throws ParseException {
        if (this.table != null && table != null)
            throw new ParseException("Parser is currently associated with table " +this.table);

        this.table = table;
    }

    
    private UnaryFunctorRef makeColumnRef(DataTable table, DataColumn column) {
        
        
        ApplyUnary args =
            new ApplyUnary(new UnaryFunctor[]
                { new Identity(),new ConstantUnary(column) });
        
        
        InvokeMethod getValue =
            new InvokeMethod(DataTable.class,"getValue",
                                               new Class[] {DataRow.class, DataColumn.class});
        
        
        
        UnaryFunctor value = getValue.bind1st(table).compose(args);
        
        
        return new UnaryFunctorRef(value, DataRow.class, ARG_NAME[0], column.getType());
    }
    
    
    
    private boolean isTableReference(FunctorRef ref) {
        return ref != null && ref.getReturnType().equals(DataTable.class) &&
               ref.getReferenceType() == FunctorRef.CONSTANT;
    }

    
    
    private DataTable getReferencedTable(FunctorRef ref) {
        return (DataTable)((GeneratorRef) ref).getFunctor().gen();
    }


    
    private void validateArgument(Class reqType, Class foundType, String fnName)
            throws ParseException
    {
        if (reqType.isAssignableFrom(foundType)) {
            return;
        }
        
        String msg = "Unable to compute {0} of type {1}";
        Object[] msgargs = new Object[] { fnName, foundType.getSimpleName() };
        throw new ParseException(MessageFormat.format(msg, msgargs));
    }
}