* Encodes a {@link Filter} into an {@link EObjectCondition} statement.

* <p>

* This class is based on the org.geotools.data.jdbc.FilterToSQL source code by Chris Holmes (TOPP)

* and Saul Farber (MassGIS)

*

* @author kengu

*

*

* @source $URL$

*/

   

    /** {@link Logger} instance for this class */

    private Logger LOGGER = Logging.getLogger(EObjectConditionEncoder.class);

    /**

     * The srid of the schema, so the BBOX conforms.

     */

    private String srid;

    /**

     * Cached {@link SimpleFeatureType} instance

     */

    private SimpleFeatureType featureType;

    /**

     * The geometry attribute to use if none is specified.

     */

    // private String defaultGeom;

    /**

     * Cached {@link EFeatureInfo} instance. The following information is used:

     * <ol>

     * <li>Name of default geometry attribute, used if none is specified</li>

     * </ol>

     */

    private EFeatureInfo eFeatureInfo;

    /**

     * Whether the BBOX filter should be strict (using the exact geom), or loose (using the

     * envelopes)

     */

    private boolean looseBBox = false;

    /**

     * Cached {@link FilterCapabilities} supported by {@link EFeatureQuery}

     */

    private Capabilities capabilities;

    /**

     * Cached {@link EObjectCondition} built during encoding

     */

    private Condition eCondition;

    /**

     * Stack of {@link Condition}s waiting to be logically combined

     */

    private Stack<Condition> eConditionStack = new Stack<Condition>();

    /**

     * Stack of {@link Expression} evaluation results waiting to be combined into an

     * {@link EFeatureFilter} expression

     */

    private Stack<Object> eExpressionStack = new Stack<Object>();

    /**

     * {@link EObjectConditionEncoder} constructor

     *

     * @param eFeatureInfo - {@link EFeatureInfo} instance

     * @param looseBBox -

     */

    public EObjectConditionEncoder(EFeatureInfo eFeatureInfo, boolean looseBBox) {

        this.eFeatureInfo = eFeatureInfo;

        this.srid = eFeatureInfo.getSRID();

        this.featureType = eFeatureInfo.getFeatureType();

        this.looseBBox = looseBBox;

    }

    public Capabilities getCapabilities() {

        if (capabilities == null) {

            capabilities = createFilterCapabilities();

        }

        return capabilities;

    }

    /**

     * Determines if specific filter passed in is supported.

     *

     * @param filter - the Filter to be tested.

     * @return true if supported, false otherwise.

     * @see IsSupportedFilterVisitor

     */

    public boolean supports(Filter filter) {

        return getCapabilities().supports(filter);

    }

    /**

     * Determines if the filter and all its sub filters and expressions are supported.

     * <p>

     *

     * @param filter - the filter to be tested.

     * @return true if all sub filters are supported, false otherwise.

     * @see IsFullySupportedFilterVisitor

     */

    public boolean fullySupports(Filter filter) {

        return getCapabilities().fullySupports(filter);

    }

    /**

     * Determines if the expression and all its sub expressions is supported.

     * <p>

     *

     * @param filter the filter to be tested.

     * @return true if all sub filters are supported, false otherwise.

     * @see IsFullySupportedFilterVisitor

     */

    public boolean fullySupports(Expression expression) {

        return getCapabilities().fullySupports(expression);

    }

    /**

     * Gets whether the Filter.BBOX query will be strict and use an intersects or 'loose' and just

     * operate against the geometry envelopes.

     *

     * @return <tt>true</tt> if this encoder is going to do loose filtering.

     */

    public boolean isLooseBBox() {

        return looseBBox;

    }

    /**

     * Sets whether the Filter.BBOX query should be 'loose', meaning that it should just do a

     * bounding box against the envelope. If set to <tt>false</tt> then the BBOX query will perform

     * a full intersects against the geometry, ensuring that it is exactly correct. If <tt>true</tt>

     * then the query will likely perform faster, but may not be exactly correct.

     *

     * @param isLooseBBox - whether the BBOX should be loose or strict.

     */

    public void setLooseBBox(boolean isLooseBBox) {

        this.looseBBox = isLooseBBox;

    }

    public String getSRID() {

        return this.srid;

    }

    /**

     * Sets a spatial reference system ESPG number, so that the geometry can be properly encoded for

     * {@link EFeature}.

     *

     * @param srid - the code for the spatial reference system.

     */

    public void setSRID(String srid) {

        this.srid = srid;

    }

    /**

     * Get feature type which EMF Queries are encoded for.

     *

     * @return a {@link SimpleFeatureType} instance.

     */

    public SimpleFeatureType getFeatureType() {

        return featureType;

    }

    /**

     * Sets the {@link FeatureType} the encoder is encoding {@link EFeatureFilter} for.

     * <p>

     * This is used in the context for attribute expressions when encoding to

     * {@link EObjectCondition}s.

     * </p>

     *

     * @param featureType - given {@link FeatureType} instance

     */

    public void setFeatureType(SimpleFeatureType featureType) {

        this.featureType = featureType;

    }

    /**

     * Encode given {@link Filter} into an {@link EObjectCondition}.

     *

     * @param filter - the {@link Filter} to be encoded.

     *

     *

     *

     * @throws EFeatureEncoderException If filter type not supported.

     */

    public EObjectCondition encode(Filter filter) throws EFeatureEncoderException {

        try {

            eCondition = null;

            eConditionStack.clear();

            Condition condition = (Condition)filter.accept(this, null);

            if(condition instanceof EObjectCondition) {

                eCondition = condition;

            } else {

                eCondition = new EObjectConditionAdapter(condition);

            }

        } catch (Exception ex) {

            LOGGER.warning("Unable to export filter" + ex);

            throw new EFeatureEncoderException("Problem writing filter: " + filter, ex);

        }

        return new EObjectConditionAdapter(eCondition);

    }

    /**

     * Encode given {@link Expression} into an {@link Condition}.

     *

     * @param expression the {@link Expression} to be encoded.

     *

     * @throws EFeatureEncoderException If filter type not supported.

     */

    public Condition encode(Expression expression) throws EFeatureEncoderException {

        try {

            eCondition = null;

            eConditionStack.clear();

            expression.accept(this, null);

        } catch (Exception ex) {

            LOGGER.warning("Unable to export filter" + ex);

            throw new EFeatureEncoderException("Problem writing expression: " + expression, ex);

        }

        return eCondition;

    }

    // -----------------------------------------------------

    //  FilterVisitor implementation

    // -----------------------------------------------------

    /**

     * Push {@link EObjectCondition#E_FALSE} to {@link EObjectCondition} stack

     * <p>

     *

     * @param filter - the {@link Filter} instance to be visited

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @see {@link FilterVisitor#visit(ExcludeFilter, Object)}

     */

    @Override

    public Condition visit(ExcludeFilter filter, Object extraData) {

        eConditionStack.add(EObjectCondition.E_FALSE);

        return eConditionStack.peek();

    }

    /**

     * Push {@link EObjectCondition#E_TRUE} to {@link EObjectCondition} stack

     * <p>

     *

     * @param filter - the {@link Filter} instance to be visited

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @see {@link FilterVisitor#visit(IncludeFilter, Object)}

     *

     */

    @Override

    public Condition visit(IncludeFilter filter, Object extraData) {

        eConditionStack.add(EObjectCondition.E_TRUE);

        return eConditionStack.peek();

    }

    /**

     * Create EMF query compatible {@link EAttributeValueIsBetween BETWEEN condition} from given

     * {@link PropertyIsBetween BETWEEN filter} and push it to {@link EObjectCondition} stack.

     * <p>

     * Literal values {@link Number}, {@link java.util.Date} and {@link String} are supported. Any

     * other {@link Literal} value will throw an {@link RuntimeException}.

     * </p>

     *

     * @param filter - the {@link Filter} instance to be visited

     * @param extraData - not in use

     *

     * @return a {@link EAttributeValueIsBetween} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     */

    @Override

    public EAttributeValueIsBetween visit(PropertyIsBetween filter, Object extraData)

            throws RuntimeException {

        //

        // Get all expressions

        //

        Expression expr = filter.getExpression();

        Expression lowerbounds = filter.getLowerBoundary();

        Expression upperbounds = filter.getUpperBoundary();

        //

        // Get expression data type

        //

        Class<?> type;

        AttributeDescriptor attType = (AttributeDescriptor) expr.evaluate(featureType);

        if (attType != null) {

            type = attType.getType().getBinding();

        } else {

            //

            // Assume it's a string

            //

            type = String.class;

        }

        //

        // Check if type is not supported

        //

        if (!DataTypes.supports(type)) {

            throw new RuntimeException("Type " + type + " not supported.");

        }

        //

        // For each expression in filter:

        // 1) Build expression recursively and put onto expression stack

        // 2) Cast expression result to expected type

        //

        expr.accept(this, false);

        PropertyName name = toType(eExpressionStack.pop(), PropertyName.class,

                "PropertyIsBetween expression is not a PropertyName");

        lowerbounds.accept(this, type);

        Literal lower = toLiteral(eExpressionStack.pop(),

                "PropertyIsBetween lower bound expression is not a Literal");

        upperbounds.accept(this, type);

        Literal upper = toLiteral(eExpressionStack.pop(),

                "PropertyIsBetween upper bound expression is not a Literal");

        //

        // Get EAttribute instance from definition

        //

        EAttribute eAttribute = eFeatureInfo.eGetAttribute(name.getPropertyName());

        //

        // Found attribute?

        //

        if (eAttribute == null) {

            throw new IllegalArgumentException("EAttribute " + name.getPropertyName()

                    + " not found");

        }

        try {

            //

            // Create EObjectCondition instance and push it to condition stack

            //

            EAttributeValueIsBetween eCondition = new EAttributeValueIsBetween(eAttribute, lower,

                    upper);

            //

            // Push to stack

            //

            eConditionStack.push(eCondition);

            //

            // Finished

            //

            return eCondition;

        } catch (EFeatureEncoderException e) {

            throw new RuntimeException("Failed to create BETWEEN condition", e);

        }

    }

    /**

     * Create EMF query compatible {@link EAttributeValueIsLike LIKE condition} from given

     * {@link PropertyIsLike LIKE filter} and push it to {@link EObjectCondition} stack.

     * <p>

     * Only {@link String} literal values are supported. Any other {@link Literal} value will throw

     * a {@link RuntimeException}.

     * <p>

     * String pattern must comply with {@link Pattern} specification. An invalid pattern will throw

     * a {@link RuntimeException}.

     * </p>

     *

     * @param filter - the LIKE Filter to be visited.

     *

     * @return a {@link EAttributeValueIsLike} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public EAttributeValueIsLike visit(PropertyIsLike filter, Object extraData) {

        // Get LIKE clause information

        //

        // char esc = filter.getEscape().charAt(0);

        // char multi = filter.getWildCard().charAt(0);

        // char single = filter.getSingleChar().charAt(0);

        // boolean matchCase = filter.isMatchingCase();

        // TODO: Verify pattern expression

        // Get expression and literal

        //

        String pattern = filter.getLiteral();

        Expression expr = filter.getExpression();

        // Get expression data type

        //

        Class<?> type;

        AttributeDescriptor attType = (AttributeDescriptor) expr.evaluate(featureType);

        if (attType != null) {

            type = attType.getType().getBinding();

        } else {

            // assume it's a string

            type = String.class;

        }

        // Check if type is not supported

        //

        if (!DataTypes.supports(type)) {

            throw new RuntimeException("Type " + type + " not supported.");

        }

        // Build expression recursively and put onto expression stack

        //

        expr.accept(this, extraData);

        // Cast expression to PropertyName

        //

        PropertyName name = toType(eExpressionStack.pop(), PropertyName.class,

                "PropertyIsLike expression is not a PropertyName");

        // Get EAttribute instance from definition

        //

        EAttribute eAttribute = eFeatureInfo.eGetAttribute(name.getPropertyName());

        // Found attribute?

        //

        if (eAttribute == null) {

            throw new IllegalArgumentException("EAttribute " + name.getPropertyName()

                    + " not found");

        }

        try {

            // Create EObjectCondition instance and push it

            //

            EAttributeValueIsLike eCondition = new EAttributeValueIsLike(eAttribute, pattern);

            // Push to stack

            //

            eConditionStack.push(eCondition);

            // Finished

            //

            return eCondition;

        } catch (EFeatureEncoderException e) {

            throw new RuntimeException("Failed to create LIKE condition", e);

        }

    }

    /**

     * Create EMF Query compatible {@link Not <code>NOT</code> condition} from given Geotools

     * {@link org.opengis.filter.Not NOT filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(org.opengis.filter.Not filter, Object extraData) {

        //

        // Build filter recursively and put onto condition stack

        //

        filter.getFilter().accept(this,extraData);

        //

        // Invert condition

        //

        eCondition = new Not(eConditionStack.pop());

        //

        // Finished

        //

        return eCondition;

    }

    /**

     * Create EMF Query compatible {@link Condition#AND(Condition) AND condition}  from given

     * Geotools {@link org.opengis.filter.And AND filter} and push it to {@link EObjectCondition}

     * stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     */

    @Override

    public Condition visit(org.opengis.filter.And filter, Object extraData) {

        return visit((BinaryLogicOperator) filter, "AND");

    }

    /**

     * Create EMF Query compatible {@link Condition#OR(Condition) OR condition}  from given Geotools

     * {@link org.opengis.filter.Or OR filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(org.opengis.filter.Or filter, Object extraData) {

        return visit((BinaryLogicOperator) filter, "OR");

    }

    /**

     * Common implementation for {@link BinaryLogicOperator binary logic operator} filters. This way

     * they're all handled centrally.

     * <p>

     * This method iterate over all filter children, concatenating them into a single EMF Query

     * {@link Condition logical operator condition} and push it to {@link EObjectCondition} stack.

     * <p>

     * Only {@link Not NOT}, {@link Condition#OR(Condition) OR} and {@link Condition#OR(Condition)

     * AND} operator filters are supported. Any other {@link BinaryLogicOperator binary logic

     * operator} filter instance will throw a {@link RuntimeException}.

     * </p>

     *

     * @param filter - the logic statement.

     * @param extraData - extra filter data. Not modified directly by this method.

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    protected Condition visit(BinaryLogicOperator filter, Object extraData) {

        // Initialize

        //

        Condition eCondition = null;

        // Get name logic operator

        //

        String operator = ((String) extraData).toUpperCase();

        // Get filter iterator

        //

        Iterator<Filter> list = filter.getChildren().iterator();

        // Is inverse operator?

        //

        if ("OR".equals(operator)) {

            while (list.hasNext()) {

                // Build filter recursively and put onto condition stack

                //

                list.next().accept(this, extraData);

                // Initialize?

                //

                if (eCondition == null) {

                    eCondition = eConditionStack.pop();

                } else {

                    eCondition = eCondition.OR(eConditionStack.pop());

                }

            }

        } else if ("AND".equals(operator)) {

            while (list.hasNext()) {

                // Build filter recursively and put onto condition stack

                //

                list.next().accept(this, extraData);

                // Initialize?

                //

                if (eCondition == null) {

                    eCondition = eConditionStack.pop();

                } else {

                    eCondition = eCondition.AND(eConditionStack.pop());

                }

            }

        } else {

            throw new RuntimeException("Binary logical " + "operator " + operator

                    + " filter not supported");

        }

        // No condition created?

        //

        if (eCondition == null) {

            throw new NullPointerException("Binary logical " + "operator " + operator

                    + " filter not supported");

        }

        // Push concatenated condition to stack

        //

        eConditionStack.push(eCondition);

        // Finished

        //

        return eCondition;

    }

    /**

     * Create EMF Query compatible {@link EAttributeValueIsEqual EQ (==) condition}  from given

     * Geotools {@link PropertyIsEqualTo EQ filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     */

    @Override

    public Condition visit(PropertyIsEqualTo filter, Object extraData) {

        return visitBinaryComparisonOperator(filter, PropertyIsEqualTo.NAME);

    }

    /**

     * Create EMF Query compatible {@link EAttributeValueIsGreaterEqual GE (>=) condition}  from

     * given Geotools {@link PropertyIsGreaterThanOrEqualTo GE filter} and push it to

     * {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(PropertyIsGreaterThanOrEqualTo filter, Object extraData) {

        return visitBinaryComparisonOperator(filter, PropertyIsGreaterThanOrEqualTo.NAME);

    }

    /**

     * Create EMF Query compatible {@link EAttributeValueIsGreaterThan GE (>) condition}  from given

     * Geotools {@link PropertyIsGreaterThan GT filter} and push it to {@link EObjectCondition}

     * stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(PropertyIsGreaterThan filter, Object extraData) {

        return visitBinaryComparisonOperator(filter, PropertyIsGreaterThan.NAME);

    }

    /**

     * Create EMF Query compatible {@link EAttributeValueIsLessThan LE (<) condition}  from given

     * Geotools {@link PropertyIsLessThan LT filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(PropertyIsLessThan filter, Object extraData) {

        return visitBinaryComparisonOperator(filter, PropertyIsLessThan.NAME);

    }

    /**

     * Create EMF Query compatible {@link EAttributeValueIsLessEqual LE (<=) condition}  from given

     * Geotools {@link PropertyIsLessThanOrEqualTo LE filter} and push it to

     * {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(PropertyIsLessThanOrEqualTo filter, Object extraData) {

        return visitBinaryComparisonOperator(filter, PropertyIsLessThanOrEqualTo.NAME);

    }

    /**

     * Create EMF Query compatible {@link EAttributeValueIsNotEqual NE (!=) condition }  from given

     * Geotools {@link PropertyIsNotEqualTo NE filter} and push it to {@link EObjectCondition}

     * stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Object visit(PropertyIsNotEqualTo filter, Object extraData) {

        visitBinaryComparisonOperator(filter, PropertyIsNotEqualTo.NAME);

        return extraData;

    }

    /**

     * Common implementation for {@link BinaryComparisonOperator binary comparison operator}

     * filters. This way they're all handled centrally.

     * <p>

     * This method iterate over all filter children, concatenating them into a single EMF Query

     * {@link Condition logical comparison condition} and push it to {@link EObjectCondition} stack.

     * <p>

     * Only {@link EAttributeValueIsEqual EQ (==)}, {@link EAttributeValueIsNotEqual NE (>)},

     * {@link EAttributeValueIsLessThan LT (<)}, {@link EAttributeValueIsLessThan LE (<=)},

     * {@link EAttributeValueIsGreaterThan GT (>)} and {@link EAttributeValueIsLessThan GE (>=)}

     * logical comparison filters are supported. Any other {@link BinaryLogicOperator binary logic

     * operator} filter instance will throw a {@link RuntimeException}.

     * </p>

     *

     * @param filter - the logic statement.

     * @param extraData - extra filter data. Not modified directly by this method.

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    protected Condition visitBinaryComparisonOperator(BinaryComparisonOperator filter,

            Object extraData) throws RuntimeException {

        // LOGGER.finer("exporting SQL ComparisonFilter");

        //

        // Initialize

        //

        Literal value = null;

        String name = null;

        Condition eCondition = null;

        //

        // Get left and right expression

        //

        Expression left = filter.getExpression1();

        Expression right = filter.getExpression2();

        //

        // Detect functions

        //

        if(left instanceof Function || right instanceof Function) {

            throw new IllegalArgumentException("Functions are not supported");           

        }

        //

        // Detect implicit inner join

        //

        if (left instanceof PropertyName && right instanceof PropertyName) {

            throw new IllegalArgumentException("Implicit inner joint predicates not supported");

        }

        // Verify left expression

        //

        if (left instanceof PropertyName) {

            name = ((PropertyName) left).getPropertyName();

        } else if (left instanceof PropertyExistsFunction) {

            name = ((PropertyExistsFunction) left).getParameters().get(0).toString();

        } else if (left instanceof Literal) {

            value = (Literal) left;

        } else {

            throw new IllegalArgumentException("Left argument must be a Literal");

        }

        //

        // Verify right expression

        //

        if (right instanceof PropertyName) {

            name = ((PropertyName) right).getPropertyName();

        } else if (right instanceof PropertyExistsFunction) {

            name = ((PropertyExistsFunction) right).getParameters().get(0).toString();

        } else if (right instanceof Literal) {

            value = (Literal) right;

        } else {

            throw new IllegalArgumentException("Right argument must be a Literal");

        }

        // Get EAttribute instance from definition

        //

        EAttribute eAttribute = eFeatureInfo.eGetAttribute(name);

        // Found attribute?

        //

        if (eAttribute == null) {

            throw new IllegalArgumentException("EAttribute " + name + " not found");

        }

        // Get comparator

        //

        String comparator = (String) extraData;

        try {

            // Create comparator condition

            //

            if (PropertyIsEqualTo.NAME.equals(comparator)) {

                eCondition = new EAttributeValueIsEqual(eAttribute, value);

            } else if (PropertyIsLessThan.NAME.equals(comparator)) {

                eCondition = new EAttributeValueIsEqual(eAttribute, value);

            } else if (PropertyIsLessThanOrEqualTo.NAME.equals(comparator)) {

                eCondition = new EAttributeValueIsEqual(eAttribute, value);

            } else if (PropertyIsGreaterThan.NAME.equals(comparator)) {

                eCondition = new EAttributeValueIsEqual(eAttribute, value);

            } else if (PropertyIsGreaterThanOrEqualTo.NAME.equals(comparator)) {

                eCondition = new EAttributeValueIsEqual(eAttribute, value);

            } else if (PropertyIsNotEqualTo.NAME.equals(comparator)) {

                eCondition = new EAttributeValueIsEqual(eAttribute, value);

            } else {

                throw new IllegalArgumentException("Comparator " + comparator + " not supported");

            }

        } catch (EFeatureEncoderException e) {

            String msg = "Failed to create " + "EObjectCondition (" + comparator + ")";

            LOGGER.warning(msg);

            throw new IllegalArgumentException(msg, e);

        }

        // Push concatenated condition to stack

        //

        eConditionStack.push(eCondition);

        // Finished

        //

        return eCondition;

    }

    /**

     * Create EMF Query compatible {@link EAttributeValueIsNull IS NULL condition}  from given

     * Geotools {@link PropertyIsNull IS NULL filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link EAttributeValueIsNull} instance

     *

     * @throws RuntimeException If one expression is not supported

     *

     */

    @Override

    public EAttributeValueIsNull visit(PropertyIsNull filter, Object extraData)

            throws RuntimeException {

        // LOGGER.finer("exporting NullFilter");

        // Get filter expression

        //

        Expression expr = filter.getExpression();

        // Build expression recursively and put onto expression stack

        //

        expr.accept(this, extraData);

        // Get PropertyName instance

        //

        PropertyName name = toType(eExpressionStack.pop(), PropertyName.class,

                "PropertyIsNull expression is not a PropertyName");

        // Get EAttribute instance from definition

        //

        EAttribute eAttribute = eFeatureInfo.eGetAttribute(name.getPropertyName());

        // Found attribute?

        //

        if (eAttribute == null) {

            throw new IllegalArgumentException("EAttribute " + name.getPropertyName()

                    + " not found");

        }

        // Create EObjectCondition instance and push to stack

        //

        EAttributeValueIsNull eCondition = new EAttributeValueIsNull(eAttribute);

        // Push to stack

        //

        eConditionStack.push(eCondition);

        // Finished

        //

        return eCondition;

    }

    /**

     * Create EMF Query compatible {@link EAttributeValueIsID ID condition}  from given Geotools

     * {@link Id ID filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @param filter - the {@link Id identifier} filter

     *

     * @return a {@link EAttributeValueIsID} instance

     *

     * @throws RuntimeException - if no or more than one {@link Identifier identifier}s are given.

     *

     */

    @Override

    public EAttributeValueIsID visit(Id filter, Object extraData) {

        // Get identifiers

        //

        Set<Identifier> ids = filter.getIdentifiers();

        //

        // LOGGER.finer("Exporting FID=" + ids);

        //

        // Verify that only one identifier is given

        //

        if (ids.isEmpty()) {

            throw new RuntimeException("Id filter " + filter + " has no identifier");

        } else if (ids.size() > 1) {

            throw new RuntimeException("Id filter " + filter + " has more than one identifier");

        }

        //

        // Get ID

        //

        Object id = ids.iterator().next().getID();

        //

        // Is ID invalid?

        //

        if (id == null) {

            throw new NullPointerException("Identifier is null");

        }

        //

        // Get ID EAttribute instance from definition

        //

        EAttribute eAttribute = eFeatureInfo.eIDAttribute();

        try {

            // Create EObjectCondition instance and push it

            //

            EAttributeValueIsID eCondition = new EAttributeValueIsID(eAttribute, id.toString());

            //

            // Push to stack

            //

            eConditionStack.push(eCondition);

            //

            // Finished

            //

            return eCondition;

        } catch (EFeatureEncoderException e) {

            throw new RuntimeException("Failed to create IS ID condition", e);

        }

    }

    /**

     * Create EMF Query compatible {@link EGeometryValueBBox BBOX condition}  from given Geotools

     * {@link BBOX BBOX filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(BBOX filter, Object extraData) {

        return visitBinarySpatialOperator(filter, BBOX.NAME);

    }

    /**

     * Create EMF Query compatible {@link EGeometryValueBeyond BEYOND condition}  from given

     * Geotools {@link Beyond BEYOND filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(Beyond filter, Object extraData) {

        return visitBinarySpatialOperator(filter, Beyond.NAME);

    }

    /**

     * Create EMF Query compatible {@link EGeometryValueContains CONTAINS condition}  from given

     * Geotools {@link Contains CONTAINS filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(Contains filter, Object extraData) {

        return visitBinarySpatialOperator(filter, Contains.NAME);

    }

    /**

     * Create EMF Query compatible {@link EGeometryValueCrosses CROSSES condition}  from given

     * Geotools {@link Crosses CROSSES filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(Crosses filter, Object extraData) {

        return visitBinarySpatialOperator(filter, Crosses.NAME);

    }

    /**

     * Create EMF Query compatible {@link EGeometryValueDisjoint DISJOINT condition}  from given

     * Geotools {@link Disjoint DISJOINT filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(Disjoint filter, Object extraData) {

        return visitBinarySpatialOperator(filter, Disjoint.NAME);

    }

    /**

     * Create EMF Query compatible {@link EGeometryValueDWithin DWITHIN condition}  from given

     * Geotools {@link DWithin DWITHIN filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(DWithin filter, Object extraData) {

        return visitBinarySpatialOperator(filter, DWithin.NAME);

    }

    /**

     * Create EMF Query compatible {@link EGeometryValueEquals EQUALS condition}  from given

     * Geotools {@link Equals EQUALS filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(Equals filter, Object extraData) {

        return visitBinarySpatialOperator(filter, Equals.NAME);

    }

    /**

     * Create EMF Query compatible {@link EGeometryValueIntersects INTERSECTS condition}  from given

     * Geotools {@link Intersects INTERSECTS filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(Intersects filter, Object extraData) {

        return visitBinarySpatialOperator(filter, Intersects.NAME);

    }

    /**

     * Create EMF Query compatible {@link EGeometryValueOverlaps OVERLAPS condition}  from given

     * Geotools {@link Overlaps OVERLAPS filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(Overlaps filter, Object extraData) {

        return visitBinarySpatialOperator(filter, Overlaps.NAME);

    }

    /**

     * Create EMF Query compatible {@link EGeometryValueTouches TOUCHES condition}  from given

     * Geotools {@link Touches TOUCHES filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Object visit(Touches filter, Object extraData) {

        return visitBinarySpatialOperator(filter, Touches.NAME);

    }

    /**

     * Create EMF Query compatible {@link EGeometryValueWithin WITHIN condition}  from given

     * Geotools {@link Within WITHIN filter} and push it to {@link EObjectCondition} stack.

     *

     * @param filter - the filter to visit

     * @param extraData - not in use

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException If one or more expressions are not supported

     *

     */

    @Override

    public Condition visit(Within filter, Object extraData) {

        return visitBinarySpatialOperator(filter, Within.NAME);

    }

    /**

     * Common implementation for {@link BinarySpatialOperator binary spatial operator} filters. This

     * way they're all handled centrally.

     * <p>

     * This method extracts property name, geometry literal and descriptor and evaluates if property

     * name and geometry literal arguments are swapped.

     * </p>

     *

     * @param filter - binary spatial operator statement

     * @param name - operator name

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException - if one or more expressions are not supported

     *

     */

    protected Condition visitBinarySpatialOperator(BinarySpatialOperator filter, String name) {

        // Perform some sanity checks

        //

        if (filter == null) {

            throw new NullPointerException("Filter to be encoded cannot be null");

        }

        // Extract the property name and the geometry literal

        //

        Literal geometry;

        PropertyName property;

        boolean swapped = false;

        BinaryComparisonOperator op = (BinaryComparisonOperator) filter;

        if (op.getExpression1() instanceof PropertyName && op.getExpression2() instanceof Literal) {

            property = (PropertyName) op.getExpression1();

            geometry = (Literal) op.getExpression2();

            swapped = true;

        } else if (op.getExpression2() instanceof PropertyName

                && op.getExpression1() instanceof Literal) {

            property = (PropertyName) op.getExpression2();

            geometry = (Literal) op.getExpression1();

        } else {

            throw new IllegalArgumentException("Can only encode spatial filters that do "

                    + "compare a property name and a geometry");

        }

        // Get EAttribute instance

        //

        EAttribute eAttribute = eFeatureInfo.eGetAttribute(property.getPropertyName());

        // Going through evaluate ensures we get the proper result even

        // if the name has not been specified (convention -> the default geometry)

        AttributeDescriptor descriptor = (AttributeDescriptor) property.evaluate(featureType);

        if (descriptor instanceof GeometryDescriptor) {

            // Forward

            //

            return visitBinarySpatialOperator(filter, name, eAttribute,

                    (GeometryDescriptor) descriptor, geometry, swapped);

        } else if(descriptor == null){

            throw new IllegalArgumentException("Attribute '" +

                    property.getPropertyName() + "' not found in '" +

                    featureType.getTypeName() + "'");

        } else {

            throw new IllegalArgumentException("Attribute '" +

                    property.getPropertyName() + "' is not a geometry in " +

                    featureType.getTypeName() + "'");

        }

    }

    /**

     * Common implementation for {@link BinarySpatialOperator binary spatial operator} filters. This

     * way they're all handled centrally.

     * <p>

     * This method extracts property name, geometry literal and descriptor and evaluates if property

     * name and geometry literal arguments are swapped.

     * </p>

     *

     * @param filter - the binary spatial operator statement

     * @param name - operator name

     * @param property - property name expression

     * @param geometry - geometry literal expression

     * @param swapped - true if geometry literal is left expression (first)

     * @param eAttribute - EAttribute instance

     * @param descriptor - geometry descriptor

     *

     * @return a {@link Condition} instance

     *

     * @throws RuntimeException - if one or more expressions are not supported

     *

     */

    protected Condition visitBinarySpatialOperator(BinarySpatialOperator filter, String name,

            EAttribute eAttribute, GeometryDescriptor descriptor, Literal geometry, boolean swapped) {

        try {

            if (BBOX.NAME.equals(name)) {

                return new EGeometryValueBBox(eAttribute, geometry, swapped);

            } else if (Beyond.NAME.equals(name)) {

                double distance = convert((Beyond) filter, descriptor);

                return new EGeometryValueBeyond(eAttribute, geometry, distance);

            } else if (DWithin.NAME.equals(name)) {

                double distance = convert((DWithin) filter, descriptor);

                return new EGeometryValueDWithin(eAttribute, geometry, distance);