Selector class that uses
Algorithm,
Cache and
Comparator
for its work.
The
Algorithm is used for computing a hashvalue for a file.
The
Comparator decides whether to select or not.
The
Cache stores the other value for comparison by the
Comparator
in a persistent manner.
The ModifiedSelector is implemented as a
CoreSelector and uses default
values for all its attributes therefore the simpliest example is
<copy todir="dest">
<filelist dir="src">
<modified/>
</filelist>
</copy>
The same example rewritten as CoreSelector with setting the all values
(same as defaults are) would be
<copy todir="dest">
<filelist dir="src">
<modified update="true"
cache="propertyfile"
algorithm="digest"
comparator="equal">
<param name="cache.cachefile" value="cache.properties"/>
<param name="algorithm.algorithm" value="MD5"/>
</modified>
</filelist>
</copy>
And the same rewritten as CustomSelector would be
<copy todir="dest">
<filelist dir="src">
<custom class="org.apache.tools.ant.type.selectors.ModifiedSelector">
<param name="update" value="true"/>
<param name="cache" value="propertyfile"/>
<param name="algorithm" value="digest"/>
<param name="comparator" value="equal"/>
<param name="cache.cachefile" value="cache.properties"/>
<param name="algorithm.algorithm" value="MD5"/>
</custom>
</filelist>
</copy>
If you want to provide your own interface implementation you can do
that via the *classname attributes. If the classes are not on Ant's core
classpath, you will have to provide the path via nested <classpath>
element, so that the selector can find the classes.
<modified cacheclassname="com.mycompany.MyCache">
<classpath>
<pathelement location="lib/mycompony-antutil.jar"/>
</classpath>
</modified>
All these three examples copy the files from
src to
dest
using the ModifiedSelector. The ModifiedSelector uses the
PropertyfileCache
, the
DigestAlgorithm and the
EqualComparator for its
work. The PropertyfileCache stores key-value-pairs in a simple java
properties file. The filename is
cache.properties. The
update
flag lets the selector update the values in the cache (and on first call
creates the cache). The
DigestAlgorithm computes a hashvalue using the
java.security.MessageDigest class with its MD5-Algorithm and its standard
provider. The new computed hashvalue and the stored one are compared by
the
EqualComparator which returns 'true' (more correct a value not
equals zero (1)) if the values are not the same using simple String
comparison.
A useful scenario for this selector is inside a build environment
for homepage generation (e.g. with
Apache Forrest).
<target name="generate-and-upload-site">
<echo> generate the site using forrest </echo>
<antcall target="site"/>
<echo> upload the changed files </echo>
<ftp server="${ftp.server}" userid="${ftp.user}" password="${ftp.pwd}">
<fileset dir="htdocs/manual">
<modified/>
</fileset>
</ftp>
</target>
Here all
changed files are uploaded to the server. The
ModifiedSelector saves therefore much upload time.
This selector uses reflection for setting the values of its three interfaces
(using org.apache.tools.ant.IntrospectionHelper) therefore no special
'configuration interfaces' has to be implemented by new caches, algorithms or
comparators. All present
setXX methods can be used. E.g. the DigestAlgorithm
can use a specified provider for computing its value. For selecting this
there is a
setProvider(String providername) method. So you can use
a nested
<param name="algorithm.provider" value="MyProvider"/>.
addClasspath
public void addClasspath(Path path)
Add the classpath.
addParam
public void addParam(String key,
Object value)
Support for nested <param> tags.
key
- the key of the parametervalue
- the value of the parameter
addParam
public void addParam(Parameter parameter)
Support for nested <param> tags.
parameter
- the parameter object
configure
public void configure()
Configures this Selector.
Does this work only once per Selector object.
Because some problems while configuring from
Selector
the configuration is done in the following order:- collect the configuration data
- wait for the first isSelected() call
- set the default values
- set values for name pattern '*': update, cache, algorithm, comparator
- set values for name pattern '*.*: cache.cachefile, ...
This configuration algorithm is needed because you don't know
the order of arriving config-data. E.g. if you first set the
cache.cachefilename and after that the cache itself,
the default value for cachefilename is used, because setting the
cache implies creating a new Cache instance - with its defaults.
getAlgorithm
public Algorithm getAlgorithm()
Get the algorithm type to use.
- the enumerated algorithm type
getCache
public Cache getCache()
Get the cache type to use.
- the enumerated cache type
getClassLoader
public ClassLoader getClassLoader()
Returns and initializes the classloader for this class.
getComparator
public Comparator getComparator()
Get the comparator type to use.
- the enumerated comparator type
getDelayUpdate
public boolean getDelayUpdate()
Getter for the delay update
- true if we should delay for performance
getModified
public int getModified()
Getter for the modified count
isSelected
public boolean isSelected(File basedir,
String filename,
File file)
Implementation of BaseExtendSelector.isSelected().
- isSelected in interface FileSelector
- isSelected in interface BaseExtendSelector
basedir
- as described in BaseExtendSelectorfilename
- as described in BaseExtendSelectorfile
- as described in BaseExtendSelector
- as described in BaseExtendSelector
isSelected
public boolean isSelected(Resource resource)
Implementation of ResourceSelector.isSelected().
- isSelected in interface ResourceSelector
resource
- The resource to check
- whether the resource is selected
loadClass
protected Object loadClass(String classname,
String msg,
Class type)
Loads the specified class and initializes an object of that class.
Throws a BuildException using the given message if an error occurs during
loading/instantiation or if the object is not from the given type.
classname
- the classnamemsg
- the message-part for the BuildExceptiontype
- the type to check against
saveCache
protected void saveCache()
save the cache file
setAlgorithmClass
public void setAlgorithmClass(String classname)
Setter for algorithmClass.
setCacheClass
public void setCacheClass(String classname)
Setter for cacheClass.
setClassLoader
public void setClassLoader(ClassLoader loader)
Set the used ClassLoader.
If you invoke this selector by API (e.g. inside some testcases) the selector
will use a different classloader for loading the interface implementations than
the caller. Therefore you will get a ClassCastException if you get the
implementations from the selector and cast them.
loader
- the ClassLoader to use
setComparatorClass
public void setComparatorClass(String classname)
Setter for comparatorClass.
setDelayUpdate
public void setDelayUpdate(boolean delayUpdate)
Setter for the delay update
delayUpdate
- true if we should delay for performance
setModified
public void setModified(int modified)
Setter for the modified count
setSeldirs
public void setSeldirs(boolean seldirs)
Support for seldirs attribute.
setSelres
public void setSelres(boolean newValue)
Support for selres attribute.
setUpdate
public void setUpdate(boolean update)
Support for update attribute.
toString
public String toString()
Override Object.toString().
- toString in interface DataType
- information about this selector
tryToSetAParameter
protected void tryToSetAParameter(Object obj,
String name,
String value)
Try to set a value on an object using reflection.
Helper method for easier access to IntrospectionHelper.setAttribute().
obj
- the object on which the attribute should be setname
- the attributenamevalue
- the new value
useParameter
public void useParameter(Parameter parameter)
Support for nested
tags.
Parameter named
cache,
algorithm,
comparator or
update are mapped to
the respective set-Method.
Parameter which names starts with
cache. or
algorithm. or
comparator. are tried
to set on the appropriate object via its set-methods.
Other parameters are invalid and an BuildException will
be thrown.
parameter
- Key and value as parameter object