import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Creates the expression.
 *
 * @param functionName the function name
 * @param argumentList the argument list
 * @return the expression
 */
/*
 * (non-Javadoc)
 * 
 * @see com.sldeditor.filter.v2.function.FunctionNameInterface#createExpression(org.opengis.filter.capability.FunctionName, java.util.List)
 */
@Override
public Expression createExpression(FunctionName functionName, List<Expression> argumentList) {
    if (functionName == null) {
        return null;
    }

    Literal fallback = null;
    Function function = functionFactory.function(functionName.getFunctionName(), argumentList,
            fallback);

    return function;
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Sets the offset in a symbolizer.
 * 
 * @param symbolizer the symbolizer.
 * @param text the text representing the offsets in the CSV form.
 */
@SuppressWarnings({"rawtypes", "unchecked"})
public static void setOffset( Symbolizer symbolizer, String text ) {
    if (text.indexOf(',') == -1) {
        return;
    }
    String[] split = text.split(",");
    if (split.length != 2) {
        return;
    }
    double xOffset = Double.parseDouble(split[0]);
    double yOffset = Double.parseDouble(split[1]);

    Expression geometry = symbolizer.getGeometry();
    if (geometry != null) {
        if (geometry instanceof FilterFunction_offset) {
            FilterFunction_offset offsetFunction = (FilterFunction_offset) geometry;
            List parameters = offsetFunction.getParameters();
            parameters.set(1, ff.literal(xOffset));
            parameters.set(2, ff.literal(yOffset));
        }
    } else {
        Function function = ff.function("offset", ff.property("the_geom"), ff.literal(xOffset), ff.literal(yOffset));
        symbolizer.setGeometry(function);
    }
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public void classiferExample() {
    SimpleFeatureCollection collection = null;
    SimpleFeature feature = null;
    // classiferExample start
    FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
    Function classify = ff.function("Quantile", ff.property("name"), ff.literal(2));
    
    Classifier groups = (Classifier) classify.evaluate(collection);
    // classiferExample end
    // classiferExample2 start
    groups.setTitle(0, "Group A");
    groups.setTitle(1, "Group B");
    // classiferExample2 end
    
    // classiferExample3 start
    // groups is a classifier with "Group A" and "Group B"
    Function sort = ff.function("classify", ff.property("name"), ff.literal(groups));
    int slot = (Integer) sort.evaluate(feature);
    
    System.out.println(groups.getTitle(slot)); // ie. "Group A"
    // classiferExample3 end
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
@Override
public Object visit(Function function, Object extraData) throws RuntimeException {
    helper.out = out;
    try {
        encodingFunction = true;
        boolean encoded = helper.visitFunction(function, extraData);
        encodingFunction = false;
        
        if(encoded) {
           return extraData; 
        } else {
            return super.visit(function, extraData);
        }
    } catch(IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Maps a function to its native db equivalent
 * 
 * @param function
 * @return
 */
public String getFunctionName(Function function) {
    if(function instanceof FilterFunction_strLength) {
        return "char_length";
    } else if(function instanceof FilterFunction_strToLowerCase) {
        return "lower";
    } else if(function instanceof FilterFunction_strToUpperCase) {
        return "upper";
    } else if(function instanceof FilterFunction_abs ||
            function instanceof FilterFunction_abs_2 ||
            function instanceof FilterFunction_abs_3 ||
            function instanceof FilterFunction_abs_4) {
        return "abs";
    }
    return function.getName();
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Creates the expression.
 *
 * @param envVar the env var
 * @return the expression
 */
@Override
public Expression createExpression(EnvVar envVar) {
    if (envVar == null) {
        return null;
    }

    Function function = ff.function("env", ff.literal(envVar.getName()));

    return function;
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Creates the expression.
 *
 * @param functionName the function name
 * @return the expression
 */
@Override
public Expression createExpression(FunctionName functionName) {
    if (functionName == null) {
        return null;
    }

    List<Expression> parameters = null;
    Literal fallback = null;
    Function function = functionFactory.function(functionName.getFunctionName(), parameters,
            fallback);

    return function;
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Gets the expression.
 *
 * @param factory the factory
 * @return the expression
 */
public ProcessFunction getExpression(FunctionFactory factory) {
    List<Expression> overallParameterList = new ArrayList<Expression>();

    for (ProcessFunctionParameterValue value : valueList) {
        List<Expression> parameterList = new ArrayList<Expression>();
        parameterList.add(ff.literal(value.name));

        boolean setValue = true;
        if (value.optional) {
            setValue = value.included;
        }

        if (setValue) {
            if (value.objectValue != null) {
                Expression expression = value.objectValue.getExpression();
                if (expression != null) {
                    parameterList.add(expression);
                }
            }
        }

        if (setValue) {
            Function function = factory.function(PARAMETER, parameterList, null);

            overallParameterList.add(function);
        }
    }

    if (this.selectedFunction.getFunctionName() == null) {
        return null;
    }
    Function processFunction = factory.function(this.selectedFunction.getFunctionName(),
            overallParameterList, null);

    return (ProcessFunction) processFunction;
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public ClassifiedStyleCreator() {
Set<Function> funcs = CommonFactoryFinder.getFunctions(GeoTools
	.getDefaultHints());
ArrayList<String> fNames = new ArrayList<String>();
for (Function func : funcs) {
    if (func instanceof ClassificationFunction) {
	classifiers.add(func);
	fNames.add(func.getName());
    }
}
setPalette(DEFAULT_PALETTE);
setNumberOfClasses(DEFAULT_NUMBER_OF_CLASSES);
setClassifier(DEFAULT_CLASSIFIER);
   }
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public void setClassifier(String name) {
for (Function f : classifiers) {
    if (f.getName().equalsIgnoreCase(name)) {
	setClassifier(f);
	return;
    }
}
   }
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public List<String> getFunctionNames() {
ArrayList<String> ret = new ArrayList<String>();

for (Function f : classifiers) {
    ret.add(f.getName());

}
return ret;
   }
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Ritorna una function usando il nome
 */
@Override
public Function function(Name name, List<Expression> args, Literal fallback) {
	if( SnapFunction.NAME.getFunctionName().equals(name)){
           return new SnapFunction( args, fallback );
       }
	else if( Fluxomizer.NAME.getFunctionName().equals(name) ){
		return new Fluxomizer(args, fallback);
	}
       return null; // we do not implement that function
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public Function function(Name name, List<Expression> args, Literal fallback) {
    if(new NameImpl("first").equals(name)){
        return new AbstractFunction( FIRST, args, fallback ){
            public Geometry evaluate(Object object) {
                Geometry geom = eval(object, 0, Geometry.class );
                Coordinate coordinate = geom.getCoordinate();
                return geom.getFactory().createPoint(coordinate);
            }
        };
    }
    return null; // we do not implement that function
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public void classiferQuantile() {
    SimpleFeatureCollection collection = null;
    SimpleFeature feature = null;
    // classiferQuantile start
    FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
    Function classify = ff.function("Quantile", ff.property("zone"), ff.literal(2));
    
    // Zones assigned by a municipal board do not have an intrinsic numerical
    // meaning making them suitable for display using:
    // - qualitative palette where each zone would have the same visual impact
    Classifier groups = (Classifier) classify.evaluate(collection);
    // classiferQuantile end
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public void classiferEqualInterval() {
    SimpleFeatureCollection collection = null;
    SimpleFeature feature = null;
    // classiferEqualInterval start
    FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
    Function classify = ff.function("EqualInterval", ff.property("height"), ff.literal(5));
    
    // this will create a nice smooth series of intervals suitable for presentation
    // with:
    // - sequential color palette to make each height blend smoothly into the next
    // - diverging color palettes if you want to make higher and lower areas stand out more
    Classifier height = (Classifier) classify.evaluate(collection);
    // classiferEqualInterval end
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
void colorBrewerExample(SimpleFeatureCollection featureCollection) {
    // colorBrewerExample start
    // STEP 0 Set up Color Brewer
    ColorBrewer brewer = ColorBrewer.instance();
    
    // STEP 1 - call a classifier function to summarise your content
    FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
    PropertyName propteryExpression = ff.property("height");
    
    // classify into five categories
    Function classify = ff.function("Quantile", propteryExpression, ff.literal(5));
    Classifier groups = (Classifier) classify.evaluate(featureCollection);
    
    // STEP 2 - look up a predefined palette from color brewer
    String paletteName = "GrBu";
    Color[] colors = brewer.getPalette(paletteName).getColors(5);
    
    // STEP 3 - ask StyleGenerator to make a set of rules for the Classifier
    // assigning features the correct color based on height
    FeatureTypeStyle style = StyleGenerator.createFeatureTypeStyle(
            groups,
            propteryExpression,
            colors,
            "Generated FeatureTypeStyle for GreeBlue",
            featureCollection.getSchema().getGeometryDescriptor(),
            StyleGenerator.ELSEMODE_IGNORE,
            0.95,
            null);
    // colorBrewerExample end
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
@Override
  public Object visit( Function expression, Object data ) {
if (expression instanceof Sha1SyncFilterFunction) {
	m_sha1SyncFilterFunction = (Sha1SyncFilterFunction) expression;
	found = true;
}
return super.visit(expression, data);
  }
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
@Override
public Object visit(
		final Function expression,
		final Object data ) {
	return new ExtractGeometryFilterVisitorResult(
			infinity(),
			null);
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
@Override
public Object visit(
		final Function expression,
		final Object data ) {
	// used force full range if the expression contains a time
	// property...which is correct?
	return new TemporalConstraints();
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
private boolean containsTime(
		final Function function ) {
	boolean yes = false;
	for (final Expression expression : function.getParameters()) {
		yes |= expressionContainsTime(expression);
	}
	return yes;
}