/*
* GeoTools - The Open Source Java GIS Toolkit
* http://geotools.org
*
* (C) 2003-2008, Open Source Geospatial Foundation (OSGeo)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*/
package org.geotools.data;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.geotools.data.DataAccessFactory.Param;
import org.geotools.parameter.DefaultParameterDescriptor;
import org.geotools.parameter.DefaultParameterDescriptorGroup;
import org.geotools.parameter.FloatParameter;
import org.geotools.parameter.Parameter;
import org.opengis.parameter.ParameterDescriptorGroup;
import org.opengis.parameter.ParameterValue;
/**
* A best of toolkit for DataStoreFactory implementors.
* <p>
* Will also allow me to mess with the interface API without breaking every
* last DataStoreFactorySpi out there.
* </p>
* <p>
* The default implementations often hinge around the use of
* getParameterInfo and the correct use of Param by your subclass.
* </p>
* <p>
* You still have to implement a few methods:
* </p>
* <pre><code>
* public DataSourceMetadataEnity createMetadata( Map params ) throws IOException {
* String host = (String) HOST.lookUp(params);
* String user = (String) USER.lookUp(params);
* Integer port = (Integer) PORT.lookUp(params);
* String database = (String) DATABASE.lookUp(params);
*
* String description = "Connection to "+getDisplayName()+" on "+host+" as "+user ;
* return new DataSourceMetadataEnity( host+":"+port, database, description );
* }</code></pre>
*
* @author Jody Garnett, Refractions Research
*
*
* @source $URL$
*/
public abstract class AbstractDataStoreFactory implements DataStoreFactorySpi {
/** Default Implementation abuses the naming convention.
* <p>
* Will return <code>Foo</code> for
* <code>org.geotools.data.foo.FooFactory</code>.
* </p>
* @return return display name based on class name
*/
public String getDisplayName() {
String name = this.getClass().getName();
name = name.substring( name.lastIndexOf('.') );
if( name.endsWith("Factory")){
name = name.substring(0, name.length()-7);
} else if( name.endsWith("FactorySpi")){
name = name.substring(0, name.length()-10);
}
return name;
}
/**
* Default implementation verifies the Map against the Param information.
* <p>
* It will ensure that:
* <ul>
* <li>params is not null
* <li>Everything is of the correct type (or upcovertable
* to the correct type without Error)
* <li>Required Parameters are present
* </ul>
* </p>
* <p>
* <p>
* Why would you ever want to override this method?
* If you want to check that a expected file exists and is a directory.
* </p>
* Overrride:
* <pre><code>
* public boolean canProcess( Map params ) {
* if( !super.canProcess( params ) ){
* return false; // was not in agreement with getParametersInfo
* }
* // example check
* File file = (File) DIRECTORY.lookup( params ); // DIRECTORY is a param
* return file.exists() && file.isDirectory();
* }
* </code></pre>
* @param params
* @return true if params is in agreement with getParametersInfo, override for additional checks.
*/
public boolean canProcess( Map params ) {
if (params == null) {
return false;
}
Param arrayParameters[] = getParametersInfo();
for (int i = 0; i < arrayParameters.length; i++) {
Param param = arrayParameters[i];
Object value;
if( !params.containsKey( param.key ) ){
if( param.required ){
return false; // missing required key!
} else {
continue;
}
}
try {
value = param.lookUp( params );
} catch (IOException e) {
// could not upconvert/parse to expected type!
// even if this parameter is not required
// we are going to refuse to process
// these params
return false;
}
if( value == null ){
if (param.required) {
return (false);
}
} else {
if ( !param.type.isInstance( value )){
return false; // value was not of the required type
}
if( param.metadata != null ){
// check metadata
if( param.metadata.containsKey(Param.OPTIONS)){
List<Object> options = (List<Object>) param.metadata.get(Param.OPTIONS);
if( options != null && !options.contains(value) ){
return false; // invalid option
}
}
}
}
}
return true;
}
/**
* Defaults to true, only a few datastores need to check for drivers.
*
* @return <code>true</code>, override to check for drivers etc...
*/
public boolean isAvailable() {
return true;
}
public ParameterDescriptorGroup getParameters(){
Param params[] = getParametersInfo();
DefaultParameterDescriptor parameters[] = new DefaultParameterDescriptor[ params.length ];
for( int i=0; i<params.length; i++ ){
Param param = params[i];
parameters[i] = new ParamDescriptor( params[i] );
}
Map properties = new HashMap();
properties.put( "name", getDisplayName() );
properties.put( "remarks", getDescription() );
return new DefaultParameterDescriptorGroup(properties, parameters);
}
/**
* Returns the implementation hints. The default implementation returns en empty map.
*/
public Map<java.awt.RenderingHints.Key, ?> getImplementationHints() {
return Collections.EMPTY_MAP;
}
}
class ParamDescriptor extends DefaultParameterDescriptor {
private static final long serialVersionUID = 1L;
Param param;
public ParamDescriptor(Param param) {
super( DefaultParameterDescriptor.create(param.key, param.description, param.type, param.sample, param.required ));
this.param = param;
}
public ParameterValue createValue() {
if (Double.TYPE.equals( getValueClass())) {
return new FloatParameter(this){
protected Object valueOf(String text) throws IOException {
return param.handle( text );
}
};
}
return new Parameter(this){
protected Object valueOf(String text) throws IOException {
return param.handle( text );
}
};
}
};