Holger's Java API

## Uses of Interface
com.antelmann.util.Filter

Packages that use Filter
com.antelmann: These are general classes that apply for the framework as a whole.
com.antelmann.calendar: This package contains classes for implementing calendar and time related solutions.
com.antelmann.cddb: This package contains classes to maintain music CD collections and associate CDs with information from a CDDB service.
com.antelmann.db: This package contains generally useful classes for generic database management.
com.antelmann.db.remote: This package contains classes that add remote capacities to the database concept of the super package.
com.antelmann.image: This package contains classes for more easily dealing with images.
com.antelmann.io: This package contains classes that are concerned with input/output operations.
com.antelmann.math: This package contains classes to ease calculations.
com.antelmann.net: The classes in this package are designed to provide convenient access to Internet related functionality.
com.antelmann.net.mail: The classes in this package are designed to ease the handling of emails.
com.antelmann.ooffice: The classes in this package are to be used in conjunction with OpenOffice.
com.antelmann.opengeodb: This package contains classes easing to deal with geological data as provided by http://opengeodb.org/.
com.antelmann.servlet: This package contains classes to help with the implementation of servlets.
com.antelmann.sql: This package contains classes to ease JDBC development and also provides useful SQL-based implementations for com.antelmann.db classes
com.antelmann.util: This package contains generally useful classes that are used throughout the other packages in this framework.
com.antelmann.util.gui: This package contains utility classes for GUI related implementations.
com.antelmann.util.logging: This package contains classes that implement a custom logging for this framework - separate from java.util.logging.
com.antelmann.util.revision: This package contains classes useful for implementing systems that deal with revisions.
com.antelmann.util.table: This package provides useful additions to TableModels and contains classes to ease development with Swing tables.

Uses of Filter in com.antelmann

Methods in com.antelmann with parameters of type Filter
`static Number` `Settings.getNumber(String key, Filter<? super Number> filter, Number defaultValue)`

Uses of Filter in com.antelmann.calendar

Methods in com.antelmann.calendar with parameters of type Filter
`Collection<Alert>` `SQLCalendarDB.getAlerts(Filter<Alert> filter)`
`Collection<Alert>` `FileCalendarDB.getAlerts(Filter<Alert> filter)`
`Collection<Alert>` `CalendarDB.getAlerts(Filter<Alert> filter)`
`Collection<CalendarEntry>` `SQLCalendarDB.getEntries(Filter<CalendarEntry> filter)`
`Collection<CalendarEntry>` `FileCalendarDB.getEntries(Filter<CalendarEntry> filter)`
`Collection<CalendarEntry>` `CalendarDB.getEntries(Filter<CalendarEntry> filter)`

Constructors in com.antelmann.calendar with parameters of type Filter
`SQLCalendarEntryIterator(SQLCalendarDB db, Filter<CalendarEntry> filter)`
`SQLCalendarEntryIterator(SQLCalendarDB db, ResultSet set, Filter<CalendarEntry> filter, boolean closeOnEnd)` the ResultSet as well as the creating Statement are both closed only if `closeOnEnd` is true

Uses of Filter in com.antelmann.cddb

Methods in com.antelmann.cddb with parameters of type Filter
`Set<Composition>` `CompositionDB.getView(Filter<Composition> filter)` returns an unmodifiable view of the embedded compositions

Uses of Filter in com.antelmann.db

Classes in com.antelmann.db that implement Filter
`static class` `DBClassStoreCache.PrefetchedFilter<T>` a special interface supported by the enclosing class store that indicates that only pre-fetched (cached) instances should be returned from a fetch.
`class` `DBReferenceFilter` convenience class that allows to filter references by their reference class
`class` `PropertyEntryFilter<T extends PropertyEntry>` filters on the properties of an entity based on simple equality of key/value pairs.
`class` `UserFilter` a simple user filter that conveniently allows to define acceptance based on rights

Methods in com.antelmann.db that return Filter
`Filter<? super T>` `WrappedDBClassStore.getAccessFilter()`
`Filter<Object>` `UserImpl.getAccessFilter()`
`Filter<? super Stub<?>>` `WrappedDBClassStore.getAccessStubFilter()`

`

`<S extends DBEntry> Filter<S>`

`

`CategoryManager.getCategoryUsageFilterFor(Class<S> type, Object categoryId)`

`Filter<? super DBUpdateEvent>` `DatabaseChangeMonitor.getFilter()`
`Filter<LockEntry>` `LockManager.getFilterFor(DBReference ref)` this may want to be overridden to be more efficient based on the mapping in use
`Filter<? super T>` `PropertyEntryFilter.getInnerFilter()`
`Filter<? super T>` `DBClassStoreCache.PrefetchedFilter.getInnerFilter()`

`protected

`<X> Filter<X>`

`

`WrappedDBClassStore.wrapFilterForProcessing(Filter<? super X> filter, Processor<X,? extends DatabaseException> p)`
This method is only used if `WrappedDBClassStore.setProcessBeforeFiltering(boolean)` is set to true.

Methods in com.antelmann.db that return types with arguments of type Filter

`

`<S extends DBEntry> PatternExtractor<Object,Filter<S>>`

`

`CategoryManager.registerCategoryUse(DBClassStore<S> store, PatternExtractor<Object,Filter<S>> filterCreator)`

Methods in com.antelmann.db with parameters of type Filter

`

`<T extends DBEntry> int`

`

`AbstractDatabase.count(Class<T> c, Filter<? super T> filter)`

`

`<T extends DBEntry> int`

`

`AbstractDatabase.countStubs(Class<T> c, Filter<Stub<?>> filter)`

`int` `WrappedDBClassStore.deleteEntries(Filter<? super T> filter)`
`int` `ReadOnlyStore.deleteEntries(Filter<? super T> filter)`
`int` `ReadOnlyCacheStore.deleteEntries(Filter<? super T> filter)`
`int` `DBClassStoreCache.deleteEntries(Filter<? super T> filter)`
`int` `DBClassStore.deleteEntries(Filter<? super T> filter)` deletes all DBEntry objects that match the given filter; if the filter is null, all resources are deleted.
`int` `CollectionClassStore.deleteEntries(Filter<? super T> filter)`
`int` `ArchiveDBClassStore.deleteEntries(Filter<? super T> filter)`
`int` `AbstractDBClassStore.deleteEntries(Filter<? super T> filter)`
`protected int` `WrappedDBClassStore.deleteEntriesIndividually(Filter<? super T> filter)` deletes all applicable entries by instantiating them and then call `WrappedDBClassStore.deleteEntry(Object)` on each entries.

`static

`<T extends DBEntry> int`

`

`DBUtils.deleteIndividually(DBClassStore<T> store, Filter<? super T> filter)`
deletes all entries that pass the given filter individually

`DBEnumeration<T>` `WrappedDBClassStore.fetch(Filter<? super T> filter)`
`DBEnumeration<T>` `ReadOnlyCacheStore.fetch(Filter<? super T> filter)`
`DBEnumeration<T>` `EnumDBStore.fetch(Filter<? super T> filter)`
`DBEnumeration<T>` `DBClassStoreCache.fetch(Filter<? super T> filter)` adds support for `DBClassStoreCache.PrefetchedFilter`
`DBEnumeration<T>` `DBClassStore.fetch(Filter<? super T> filter)` allows to retrieve the entries of this storage via iteration.
`DBEnumeration<T>` `CollectionClassStore.fetch(Filter<? super T> filter)`
`DBEnumeration<T>` `ArchiveDBClassStore.fetch(Filter<? super T> filter)`
`DBEnumeration<Stub<T>>` `WrappedDBClassStore.fetchStubs(Filter<? super Stub<?>> filter)`
`DBEnumeration<Stub<T>>` `ReadOnlyCacheStore.fetchStubs(Filter<? super Stub<?>> filter)`
`DBEnumeration<Stub<T>>` `DBClassStore.fetchStubs(Filter<? super Stub<?>> filter)` allows to access objects from this store w/o having to instantiate the entire original objects, but instead use Stubs to be able to display the list properly for selection.
`DBEnumeration<Stub<T>>` `CollectionClassStore.fetchStubs(Filter<? super Stub<?>> filter)` the display value of the returned Stub is based on the toString() method of the DBEntry instance
`DBEnumeration<Stub<T>>` `ArchiveDBClassStore.fetchStubs(Filter<? super Stub<?>> filter)`
`DBEnumeration<Stub<T>>` `AbstractDBClassStore.fetchStubs(Filter<? super Stub<?>> filter)`

`static

`<E extends DBEntry> AbstractDBEnumeration<E>`

`

`AbstractDBEnumeration.filter(DBEnumeration<E> i, Filter<? super E> filter)`
remove() is not supported on the returned iterator

`

`<T extends DBEntry> T`

`

`AbstractDatabase.getFirstEntry(Class<T> type, Filter<? super T> filter)`

`static

`<T extends DBEntry> T`

`

`DBUtils.getFirstEntry(DBClassStore<T> store, Filter<? super T> filter)`

`

`<T extends DBEntry> Stub<T>`

`

`AbstractDatabase.getFirstStub(Class<T> type, Filter<Stub<?>> filter)`

`static

`<T extends DBEntry> Stub<T>`

`

`DBUtils.getFirstStub(DBClassStore<T> store, Filter<? super Stub<?>> filter)`

`

`<T extends DBEntry> T`

`

`AbstractDatabase.getRandomEntry(Class<T> type, Filter<? super T> filter)`

`static

`<T extends DBEntry> T`

`

`DBUtils.getRandomEntry(DBClassStore<T> store, Filter<? super T> filter)`

`static

`<T extends DBEntry> void`

`

`DBUtils.handle(DBClassStore<T> store, Handler<? super T,?> handler, Filter<? super T> filter, Monitor monitor, boolean useCommitNotAbort)`

`static

`<T extends DBEntry> Iterable<T>`

`

`DBUtils.iterate(DBClassStore<T> store, Filter<? super T> filter)`

`

`<T extends DBEntry> ArrayList<T>`

`

`AbstractDatabase.listEntries(Class<T> c, Filter<? super T> filter)`
This method will begin and abort a transaction if none is active at the time.

`

`<T extends DBEntry> ArrayList<T>`

`

`AbstractDatabase.listEntries(Class<T> type, Filter<? super T> filter, int maxEntries)`

`static

`<T extends DBEntry> ArrayList<T>`

`

`DBUtils.listEntries(DBClassStore<T> store, Filter<? super T> filter)`

`static

`<T extends DBEntry> ArrayList<T>`

`

`DBUtils.listEntries(DBClassStore<T> store, Filter<? super T> filter, int maxEntries)`

`

`<T extends DBEntry> ArrayList<Stub<T>>`

`

`AbstractDatabase.listStubs(Class<T> c, Filter<? super Stub<?>> filter)`
This method will begin and abort a transaction if none is active at the time.

`static

`<T extends DBEntry> ArrayList<Stub<T>>`

`

`DBUtils.listStubs(DBClassStore<T> store, Filter<? super Stub<?>> filter)`

`static

`<T extends DBEntry> ArrayList<Stub<T>>`

`

`DBUtils.listStubs(DBClassStore<T> store, Filter<? super Stub<?>> filter, int maxEntries)`

`ArrayList<User>` `AbstractUserLoginStore.listUsers(Filter<? super User> filter)`
`static ArrayList<User>` `AbstractUserLoginStore.listUsers(UserLoginStore uls, Filter<? super User> filter)` it may be more efficient to achieve this via an embedded DBClassStore if applicable

`

`<T extends DBEntry> Hashtable<Object,T>`

`

`AbstractDatabase.mapEntries(Class<T> c, Filter<? super T> filter)`
returns a Hashtable mapping the ID to its DBEntry of those that apply to the given filter.

`static

`<T extends DBEntry> Hashtable<Object,T>`

`

`DBUtils.mapEntries(Collection<T> entries, Filter<? super T> filter)`

`static

`<T extends DBEntry> Hashtable<Object,T>`

`

`DBUtils.mapEntries(DBClassStore<T> store, Filter<? super T> filter)`

`static

`<T extends DBEntry,P> Hashtable<Object,P>`

`

`DBUtils.mapEntries(DBClassStore<T> store, PatternExtractor<? super T,P> pe, Filter<? super T> filter)`

`

`<T extends DBEntry> Hashtable<Object,Stub<T>>`

`

`AbstractDatabase.mapStubs(Class<T> c, Filter<? super Stub<?>> filter)`
returns a Hashtable mapping the ID to its Stub of those that apply to the given filter.

`static

`<T extends DBEntry> Hashtable<Object,Stub<T>>`

`

`DBUtils.mapStubs(Collection<Stub<T>> stubs, Filter<? super Stub<T>> filter)`

`static

`<T extends DBEntry> Hashtable<Object,Stub<T>>`

`

`DBUtils.mapStubs(DBClassStore<T> store, Filter<? super Stub<?>> filter)`

`int` `ArchivedStore.moveToArchive(Filter<? super T> filter)` requires transactional context on both stores
`int` `ArchiveDBClassStore.moveToArchive(Filter<? super T> filter)`
`void` `WrappedDBClassStore.setAccessFilter(Filter<? super T> accessFilter)` allows to provide a filter that will limit access to the content of the store in regards to all read and write operations.
`void` `UserImpl.setAccessFilter(Filter<Object> accessFilter)` allows to customize the way `UserImpl.hasAccess(Object)` works.
`void` `WrappedDBClassStore.setAccessStubFilter(Filter<? super Stub<?>> accessStubFilter)` allows to not only filter entries themselves but also their respective stubs if applicable
`void` `EntryAnalyzer.setData(DBClassStore<T> store, Filter<? super T> filter)`
`void` `DatabaseChangeMonitor.setFilter(Filter<? super DBUpdateEvent> filter)`
`void` `PropertyEntryFilter.setInnerFilter(Filter<? super T> filter)`
`void` `DBClassStoreCache.PrefetchedFilter.setInnerFilter(Filter<? super T> filter)`
`int` `WrappedDBClassStore.size(Filter<? super T> filter)`
`int` `ReadOnlyCacheStore.size(Filter<? super T> filter)`
`int` `DBClassStore.size(Filter<? super T> filter)` returns the total number of T elements in this store based on the given filter (which may be null)
`int` `CollectionClassStore.size(Filter<? super T> filter)`
`int` `ArchiveDBClassStore.size(Filter<? super T> filter)`
`int` `AbstractDBClassStore.size(Filter<? super T> filter)`

`static

`<T extends DBEntry,E extends Exception> void`

`

`DBUtils.updateAll(DBClassStore<T> store, Processor<T,E> handler, Filter<? super T> filter)`

`static

`<T extends DBEntry,E extends Exception> void`

`

`DBUtils.updateAll(DBClassStore<T> store, Processor<T,E> handler, Filter<? super T> filter, Monitor mon)`

`protected

`<X> Filter<X>`

`

`WrappedDBClassStore.wrapFilterForProcessing(Filter<? super X> filter, Processor<X,? extends DatabaseException> p)`
This method is only used if `WrappedDBClassStore.setProcessBeforeFiltering(boolean)` is set to true.

Method parameters in com.antelmann.db with type arguments of type Filter

`

`<S extends DBEntry> PatternExtractor<Object,Filter<S>>`

`

`CategoryManager.registerCategoryUse(DBClassStore<S> store, PatternExtractor<Object,Filter<S>> filterCreator)`

Constructors in com.antelmann.db with parameters of type Filter
`DBClassStoreCache.PrefetchedFilter(Filter<? super T> innerFilter)`
`EntryAnalyzer(DBClassStore<T> store, Filter<? super T> filter)`
`EntryAnalyzer(Iterable<T> data, Filter<? super T> filter)`
`ReadOnlyCacheStore(DBClassStore<T> store, Filter<? super T> filter)`

Uses of Filter in com.antelmann.db.remote

Classes in com.antelmann.db.remote that implement Filter
`class` `RemoteDBChangeFilter` allows to set certain filter options for the delivery of change notification on the server from the client

Methods in com.antelmann.db.remote that return Filter
`Filter<? super DBUpdateEvent>` `RemoteDBChangeNotifier.getFilter()`

Methods in com.antelmann.db.remote with parameters of type Filter
`void` `RemoteDBChangeNotifier.setFilter(Filter<? super DBUpdateEvent> filter)` allows to set a filter, so that not every event may be propagated to the server

Constructors in com.antelmann.db.remote with parameters of type Filter
`RemoteDBChangeNotifier(NetConnection con, Filter<? super DBUpdateEvent> filter)`
`RemoteDBChangeNotifier(String databaseName, String server, int port, Filter<? super DBUpdateEvent> filter)`

Uses of Filter in com.antelmann.image

Methods in com.antelmann.image that return Filter
`Filter<Image>` `JImagePanel.getImageImportFilter()`
`Filter<URL>` `JImagePanel.getUrlImportFilter()`

Methods in com.antelmann.image with parameters of type Filter
`void` `ImageURLEntrySQLStore.refreshThumbnails(int maxWidthHeight, Filter<? super T> filter, Monitor mon)`
`void` `ImageEntryManager.refreshThumbnails(int maxWidthHeight, Filter<? super T> filter, Monitor mon)` filter and monitor are optional and may be null
`void` `JImagePanel.setImageImportFilter(Filter<Image> imageFilter)` allows to set a filter that is applied when importing an image through either drag and drop or pasting
`void` `JImagePanel.setUrlImportFilter(Filter<URL> urlImportFilter)`

Uses of Filter in com.antelmann.io

Classes in com.antelmann.io that implement Filter
`class` `ExtensionFileFilter` ExtensionFileFilter is a flexible multi-purpose FileFilter.

Fields in com.antelmann.io declared as Filter
`static Filter<File>` `MyFile.DIRECTORIES_ONLY`
`static Filter<File>` `MyFile.FILES_ONLY`

Methods in com.antelmann.io that return Filter
`static Filter<File>` `MyFile.asFilter(FileFilter filter)`

Methods in com.antelmann.io with parameters of type Filter
`static FileFilter` `MyFile.asFileFilter(Filter<? super File> filter)`
`int` `FileClassStore.deleteEntries(Filter<? super T> filter)`
`DBEnumeration<T>` `FileClassStore.fetch(Filter<? super T> filter)`
`DBEnumeration<Stub<T>>` `FileClassStore.fetchStubs(Filter<? super Stub<?>> filter)`
`Iterator<MyFile>` `MyFile.iterateFilesInTree(Filter<? super File> filter)`
`MyFile[]` `MyFile.listFilesInTree(Filter<? super MyFile> filter)`
`int` `FileClassStore.size(Filter<? super T> filter)`

Uses of Filter in com.antelmann.math

Classes in com.antelmann.math that implement Filter
`class` `NumberStringFilter<T extends Number & Comparable<? super T>>` compiles a filter from an input string that supports numbers and ranges in the form: '<1, 3, 5, 7-9, 11, 20-30, >=50'.
`static class` `NumberStringFilter.DecimalFilter`
`static class` `NumberStringFilter.DoubleFilter`
`static class` `NumberStringFilter.IntFilter`
`static class` `NumberStringFilter.LongFilter`

Methods in com.antelmann.math that return Filter
`Filter<? super T>` `TimeDataGrid.getFilter()`
`Filter<? super T>` `ObjectAnalyzer.getFilter()`
`Filter<? super T>` `DataMatrix.getFilter()`

Methods in com.antelmann.math with parameters of type Filter

`static

`<T extends DBEntry> void`

`

`DataMatrix.loadMatrix(DataMatrix<T> matrix, DBClassStore<? extends T> store, Filter<? super T> filter, Monitor mon)`
min, max of the given logger must be set explicitly

`void` `TimeDataGrid.setFilter(Filter<? super T> filter)`
`void` `ObjectAnalyzer.setFilter(Filter<? super T> filter)`
`void` `DataMatrix.setFilter(Filter<? super T> filter)`

Constructors in com.antelmann.math with parameters of type Filter
`DataMatrix(DataParser<? super T> parser, Filter<? super T> filter)`
`ObjectAnalyzer(Iterable<T> data, Filter<? super T> filter)`
`TimeDataGrid(TimeDataParser<? super T> parser, Filter<? super T> filter)`

Uses of Filter in com.antelmann.net

Methods in com.antelmann.net that return Filter
`Filter<String>` `SSLHelper.getHostnameFilter()`
`Filter<SSLSession>` `SSLHelper.getSessionFilter()`

Methods in com.antelmann.net with parameters of type Filter
`Enumeration<ServerLogEntry>` `ServerLogFile.getServerLogEntryEnumerator(Filter<ServerLogEntry> filter)`
`Enumeration<ServerLogEntry>` `ServerLog.getServerLogEntryEnumerator(Filter<ServerLogEntry> filter)` returns an Enumeration of all ServerLogEntry objects that are accepted by the given filter or all ServerLogEntries if the filter is null.
`Map<String,Integer>` `ServerLogAnalyzer.refererDomainCount(Filter<ServerLogEntry> filter)` returns a map with the key elements being Strings denoting the referer domain name and the mapped value (an Integer) denoting the count.
`Map<String,Integer>` `ServerLogAnalyzer.refererHostCount(Filter<ServerLogEntry> filter)` returns a map with the key elements being Strings denoting the referer host name and the mapped value (an Integer) denoting the count.
`void` `SSLHelper.setHostnameFilter(Filter<String> hostnameFilter)`
`void` `SSLHelper.setSessionFilter(Filter<SSLSession> sessionFilter)`

Constructors in com.antelmann.net with parameters of type Filter
`ServerLogFile.ServerLogEntryEnumerator(Filter<ServerLogEntry> filter)`
`SSLHelper(Filter<String> hostnameFilter)`
`SSLHelper(Filter<String> hostnameFilter, Filter<SSLSession> sessionFilter)`
`SSLHelper(Filter<String> hostnameFilter, Filter<SSLSession> sessionFilter)`

Uses of Filter in com.antelmann.net.mail

Methods in com.antelmann.net.mail that return Filter
`Filter<javax.mail.Message>` `IMAPBackup.getMessageFilter()`

Methods in com.antelmann.net.mail with parameters of type Filter
`static void` `IMAPBackup.backupToDB(javax.mail.Store imapStore, DBClassStore<MessageEntry> dbstore, Filter<javax.mail.Message> filter, File logFile)`
`static void` `IMAPBackup.backupToDir(javax.mail.Store imapStore, File targetBaseDir, Filter<javax.mail.Message> filter, boolean zip, boolean useCounter)`
`void` `IMAPBackup.setMessageFilter(Filter<javax.mail.Message> filter)`

Uses of Filter in com.antelmann.ooffice

Methods in com.antelmann.ooffice with parameters of type Filter
`Iterator<Cell>` `OOCalc.findTextCells(int sheet, Filter<? super Cell> filter)`

Uses of Filter in com.antelmann.opengeodb

Classes in com.antelmann.opengeodb that implement Filter
`class` `GeoLocationFilter`

Uses of Filter in com.antelmann.servlet

Fields in com.antelmann.servlet declared as Filter
`protected Filter<String>` `UserAuthenticationFilter.ipFilter`

Methods in com.antelmann.servlet that return Filter
`Filter<? super User>` `UserAuthenticationFilter.getUserFilter()`

Methods in com.antelmann.servlet with parameters of type Filter
`static User` `ServletUtils.authenticate(javax.servlet.http.HttpServletRequest req, Iterable<User> users, Filter<? super User> filter)` returns true only if any of the given users match the authorization scheme from the given request
`static User` `ServletUtils.authenticate(javax.servlet.ServletRequest req, UserLoginStore uls, Filter<? super User> filter)` implements authentication via BasicAuth
`static User` `ServletUtils.getUserFromHeader(UserLoginStore uls, javax.servlet.ServletRequest request, String userKey, String pwdKey, boolean hashedPassword, Filter<? super User> filter)`
`static User` `ServletUtils.getUserFromParams(UserLoginStore uls, javax.servlet.ServletRequest request, String userKey, String pwdKey, boolean hashedPassword, Filter<? super User> filter)`
`void` `UserAuthenticationFilter.setIpFilter(Filter<String> ipFilter)`
`void` `UserAuthenticationFilter.setUserFilter(Filter<? super User> userFilter)`

Constructors in com.antelmann.servlet with parameters of type Filter
`UserAuthenticationFilter(UserLoginStore uls, Filter<? super User> userFilter)`

Uses of Filter in com.antelmann.sql

Subinterfaces of Filter in com.antelmann.sql
`interface` `SQLComboFilterSupported<T>` denotes filters that are supported by `SQLComboFilter`

Classes in com.antelmann.sql that implement Filter
`class` `FullTextSearchFilter<T>` used in context with a `BaseRowMapper` to support full text search in tables
`class` `PreparedStatementEntryFilter<T>` a special filter that directly works off a PreparedStatement; only suitable for pre-filtering from the database, unless an internalFilter is set in addition.
`static class` `SQLColumnInfo.UpdateFilter`
`class` `SQLComboFilter<T>` allows to flexibly combine multiple different filter that all can be effectively applied to a `BaseRowMapper`.
`class` `SQLDirectQueryEntryFilter<T>` a special filter that directly works off a SQL query String; only suitable for pre-filtering from the database, unless an internalFilter is set in addition.
`class` `SQLFetchSizeFilter<T>` allows to specify the intended fetch size to be used for the query when executing a fetch on a store
`class` `SQLMapFilter<T>` a special filter that can be used to easily pre-filter Resources via restrictions used in a ConnectionHelper (to fetch them from a DBClassStore).
`class` `SQLStubFilter` a special filter that can be used to easily pre-filter Stubs via restrictions used in a ConnectionHelper (to fetch them from a DBClassStore).
`class` `TopicMapFilter<T>` a special filter that works very similar to an `SQLMapFilter`, but one instance can be applied to different stores with different mappings - based on the topics.

Fields in com.antelmann.sql declared as Filter
`protected Filter<? super T>` `PreparedStatementEntryFilter.internalFilter`

Methods in com.antelmann.sql that return Filter
`Filter<?>[]` `SQLComboFilter.getAllFilters()` returns all filters that this instance is using in some combined fashion

`

`<S extends DBEntry> Filter<S>`

`

`CategoryStore.getCategoryUsageFilterFor(Class<S> type, Object categoryId)`

`Filter<? super Stub<?>>` `ForeignKeyMappingInfo.getForeignKeyFilter(String column)` returns a filter that limits the allowed choices for the foreign key column; may be null
`Filter<? super Stub<?>>` `DefaultMappingInfo.getForeignKeyFilter(String column)`
`Filter<? super T>` `TopicMapFilter.getInnerFilter()` returns the internal filter that applies in this instance's accept() method
`Filter<? super Stub<?>>` `SQLStubFilter.getInnerFilter()`
`Filter<? super T>` `SQLMapFilter.getInnerFilter()` returns the internal filter that applies in this instance's accept() method
`Filter<? super T>` `SQLDirectQueryEntryFilter.getInnerFilter()`
`Filter<? super T>` `SQLComboFilter.getInnerFilter()`
`Filter<? super T>` `PreparedStatementEntryFilter.getInnerFilter()`
`Filter<? super T>` `FullTextSearchFilter.getInnerFilter()`
`Filter<? super T>` `BaseRowMapper.getPreStoreFilter()`
`Filter<? super Stub<?>>` `DefaultMappingInfo.setForeinKeyFilter(String column, Filter<? super Stub<?>> filter)`
`Filter<T>` `SQLFetchSizeFilter.unwrap()`

Methods in com.antelmann.sql that return types with arguments of type Filter

`static

`<T extends DBEntry> PatternExtractor<Object,Filter<T>>`

`

`CategoryStore.createStandardExtractor(DBClassStore<T> store)`

`static

`<T extends DBEntry> PatternExtractor<Object,Filter<T>>`

`

`CategoryStore.createStandardExtractor(String categoryIdColumn, Class<T> type)`

`

`<S extends DBEntry> PatternExtractor<Object,Filter<S>>`

`

`CategoryStore.registerCategoryUse(DBClassStore<S> store, PatternExtractor<Object,Filter<S>> filterCreator)`

Methods in com.antelmann.sql with parameters of type Filter
`protected void` `SQLComboFilter.addFilterStatement(Connection con, String table, Filter<?> filter, StringBuilder sb, ArrayList<Object> params)`
`boolean` `SQLComboFilter.contains(Filter<?> filter)`
`int` `SQLColumnInfoStore.deleteEntries(Filter<? super T> filter)`
`int` `JDBCRowStore.deleteEntries(Filter<? super T> filter)` supports SQLMapFilter for more effective deletion.
`int` `DetailRowStore.deleteEntries(Filter<? super T> filter)` Deprecated.
`DBEnumeration<T>` `JDBCRowStore.fetch(Filter<? super T> filter)` Depending of the capabilities of the mapper in use, this method can support various special filters.
`DBEnumeration<Stub<T>>` `JDBCRowStore.fetchStubs(Filter<? super Stub<?>> filter)` This implementation supports SQLStubFilter and SQLDirectQueryEntryFilter objects; but otherwise, it doesn't filter in any more intelligent way than leaving the filtering to the AbstractIterator.
`HashMap<Object,Integer>` `ConnectionHelper.getDistinctValuesWithCount(String table, Map<String,?> fieldRestrictions, Filter<Integer> numberFilter, String... columnField)` returns all distinct values of the given column from the given table with their count based on a group by statement.
`protected List<T>` `CategoryStore.getList(Filter<? super T> filter)`

`

`<T extends DBEntry> T`

`

`SQLDatabase.getRandomEntry(Class<T> type, Filter<? super T> filter)`

`ResultSet` `WrappedObjectRowMapper.getResultSet(Filter<? super T> filter)`
`ResultSet` `ObjectRowMapper.getResultSet(Filter<? super T> filter)` constructs the ResultSet used for fetching entries that corresponds closest to the filter; note that the filter may be null, in which case the select statement should return all rows.
`ResultSet` `BaseRowMapper.getResultSet(Filter<? super T> filter)` if no special filter for more effectively obtaining a ResultSet can be used (or if the filter is null), `getAll()` is called.
`ArrayList<RowItem>` `ConnectionHelper.getRowItems(ResultSet rs, String idField, Filter<? super RowItem> filter)` filter may be null; the table name is obtained from the idField column
`ArrayList<RowItem>` `ConnectionHelper.getRowItems(String tableName, ResultSet rs, String idField, Filter<? super RowItem> filter)` allows to specify a tableName explicitly for the returned RowItem objects Note that the given ResultSet must still be closed after calling this method!
`ArrayList<RowItem>` `ConnectionHelper.getRowItems(String tableName, String idField, Filter<? super RowItem> filter)` filter may be null
`ResultSet` `WrappedObjectRowMapper.getStubResultSet(Filter<? super Stub<?>> filter)`
`ResultSet` `ObjectRowMapper.getStubResultSet(Filter<? super Stub<?>> filter)` creates and returns the ResultSet used for fetching stubs that corresponds closest to the filter for extracting Stub entries.
`ResultSet` `BaseRowMapper.getStubResultSet(Filter<? super Stub<?>> filter)` supports the same functionality as `BaseRowMapper.getResultSet(Filter)`; additional support for `SQLStubFilter`
`protected static boolean` `SQLComboFilter.hasConditions(Filter<?> filter)`
`static void` `MySQLLog.logStackTraceOnQuery(Connection con, File logFile, Filter<com.mysql.jdbc.profiler.ProfilerEvent> filter)`
`Filter<? super Stub<?>>` `DefaultMappingInfo.setForeinKeyFilter(String column, Filter<? super Stub<?>> filter)`
`void` `SQLStubFilter.setInnerFilter(Filter<? super Stub<?>> internalFilter)`
`void` `TopicMapFilter.setInnerFilter(Filter<? super T> internalFilter)`
`void` `SQLMapFilter.setInnerFilter(Filter<? super T> internalFilter)`
`void` `SQLDirectQueryEntryFilter.setInnerFilter(Filter<? super T> internalFilter)`
`void` `SQLComboFilter.setInnerFilter(Filter<? super T> filter)`
`void` `PreparedStatementEntryFilter.setInnerFilter(Filter<? super T> filter)`
`void` `FullTextSearchFilter.setInnerFilter(Filter<? super T> filter)`
`void` `BaseRowMapper.setPreStoreFilter(Filter<? super T> filter)` allows to specify a filter that is used before each update/insert
`int` `JDBCRowStore.size(Filter<? super T> filter)` supports special performance optimization for SQLMapFilter and some other.

Method parameters in com.antelmann.sql with type arguments of type Filter

`

`<S extends DBEntry> PatternExtractor<Object,Filter<S>>`

`

`CategoryStore.registerCategoryUse(DBClassStore<S> store, PatternExtractor<Object,Filter<S>> filterCreator)`

Constructors in com.antelmann.sql with parameters of type Filter
`FullTextSearchFilter(Filter<? super T> internalFilter, String[] pattern, String... restrictToColumns)`
`PreparedStatementEntryFilter(Connection con, String sql, Filter<? super T> internalFilter, Object... parameters)`
`PreparedStatementEntryFilter(PreparedStatement pst, Filter<? super T> internalFilter)` when only using this constructor, reInitialize() will throw an IllegalStateException, as the PreparedStatement cannot be regenerated just by itself.
`SQLDirectQueryEntryFilter(String sql, Filter<? super T> internalFilter)`
`SQLFetchSizeFilter(Filter<T> filter, int fetchSize)`
`SQLMapFilter(Map<String,Object> sqlFilterMap, Filter<? super T> internalFilter, String... orderByColumns)` the given map is directly used as the embedded map
`SQLStubFilter(Map<String,Object> sqlFilter, Filter<Stub<?>> internalFilter, String... orderByColumns)`
`TopicMapFilter(Map<Object,Object> sqlFilterMap, Filter<? super T> internalFilter, Object... orderByColumns)` if a column is to be sorted descending, put a minus sign before the column name

Uses of Filter in com.antelmann.util

Subinterfaces of Filter in com.antelmann.util
`interface` `CascadingFilter<T>` a filter that relies on another embedded filter for further filtering (which in turn may yet be another CascadingFilter)
`interface` `VerboseFilter<T>` a special filter that will provide a message if this instance doesn't accept an element.

Classes in com.antelmann.util that implement Filter
`class` `ComboFilter<T>` a special filter that allows to combine different filters.
`class` `MethodFilter<T>` a special filter that can filter objects based on the return values of methods that take no parameters and return something but void.
`class` `OffsetFilter<T>` a filter that specifies to a supporting implementation that not all results are desired, but only those starting at a given offset and limited to a given limit.
`class` `RandomFilter` a special filter that randomly accepts Objects based on given odds.
`class` `Range<T extends Comparable<? super T>>` provides a generic wrapper for lower- and upperbounds for a comparable object.
`static class` `VerboseFilter.Adapter<T>`

Fields in com.antelmann.util declared as Filter
`static Filter<Object>` `Filter.EXCLUDE_ALL_FILTER`
`static Filter<Enabled>` `Enabled.FILTER`
`static Filter<Object>` `Filter.INCLUDE_ALL_FILTER`

Methods in com.antelmann.util that return Filter
`Filter<? super E>` `AbstractIterator.getFilter()`
`Filter<? super T>` `ComboFilter.getFilter1()`
`Filter<? super T>` `ComboFilter.getFilter2()`
`Filter<Object>` `RandomFilter.getInnerFilter()`
`Filter<? super T>` `OffsetFilter.getInnerFilter()`
`Filter<? super T>` `CascadingFilter.getInnerFilter()`

`static

`<T> Filter<T>`

`

`Misc.reverseFilter(Filter<T> filter)`
returns an inversed filter to the given one

`Filter<T>` `VerboseFilter.Adapter.unwrap()`
`Filter<? super T>` `OffsetFilter.unwrap()`

Methods in com.antelmann.util with parameters of type Filter

`static

`<T> ComboFilter<T>`

`

`ComboFilter.create(Filter<? super T> f1, Filter<? super T> f2, BooleanOperator operator)`

`static

`<T> ComboFilter<T>`

`

`ComboFilter.create(Filter<? super T> f1, Filter<? super T> f2, BooleanOperator operator)`

`int` `Country.Store.deleteEntries(Filter<? super Country> filter)`

`static

`<T,P> HashSet<P>`

`

`Sets.distinctValues(Collection<T> col, PatternExtractor<? super T,P> extractor, Filter<? super T> filter)`

`static

`<T> ArrayList<T>`

`

`Sets.extract(Collection<T> col, Filter<? super T> filter)`
returns a new Collection that will only contain those elements that passed the filter; the given col remains untouched.

`static String` `VerboseFilter.Adapter.extractMessage(Filter<?> filter, Object entry)` convenience method to easily extract a rejection message from any filter
`static String` `VerboseFilter.Adapter.extractMessage(Filter<?> filter, Object entry, String defaultMessage)` convenience method to easily extract a rejection message from any filter
`DBEnumeration<Country>` `Country.Store.fetch(Filter<? super Country> filter)`
`DBEnumeration<Stub<Country>>` `Country.Store.fetchStubs(Filter<? super Stub<?>> filter)`

`static

`<T> ArrayList<T>`

`

`Sets.filter(Collection<T> col, Filter<? super T> filter)`
filters all objects out of the given col that are not accepted by the filter; the dropout is returned as a separate Collection.

`static

`<F> AbstractIterator<F>`

`

`AbstractIterator.filter(Enumeration<F> e, Filter<? super F> filter)`

`static

`<F> AbstractIterator<F>`

`

`AbstractIterator.filter(Iterator<F> i, Filter<? super F> filter)`
remove() is not supported on the returned iterator

`static Country[]` `Country.getCountries(Filter<Country> filter)`

`static

`<T,P> HashMap<P,ArrayList<T>>`

`

`Sets.groupBy(Collection<T> col, PatternExtractor<? super T,P> extractor, Filter<? super T> filter)`
splits the given collection into many, where the extractor is the discriminator

`static ArrayList<Media>` `PrintUtilities.listMedia(PrintService ps, Filter<Media> filter)`

`static

`<T,P> HashMap<P,T>`

`

`Sets.map(Collection<T> col, PatternExtractor<? super T,P> extractor, Filter<? super T> filter)`
if a single pattern is extracted more than once from the collection, simply the last occurrence is mapped to that pattern

`static

`<T> ComboFilter<T>`

`

`ComboFilter.negate(Filter<? super T> filter)`
see `Misc.reverseFilter(Filter)`

`static

`<T> Filter<T>`

`

`Misc.reverseFilter(Filter<T> filter)`
returns an inversed filter to the given one

`void` `AbstractIterator.setFilter(Filter<? super E> filter)` if a non-null filter is set, only those elements that pass the filter will be returned by `next()`.
`void` `ComboFilter.setFilter1(Filter<? super T> f1)`
`void` `ComboFilter.setFilter2(Filter<? super T> f2)`
`void` `OffsetFilter.setInnerFilter(Filter<? super T> filter)`
`void` `CascadingFilter.setInnerFilter(Filter<? super T> filter)`
`void` `RandomFilter.setInnerFilter(Filter<Object> filter)`
`int` `Country.Store.size(Filter<? super Country> filter)`
`static Object` `InterfaceWrapper.wrapObject(ClassLoader cl, Object object, InterfaceMonitor monitor, Filter<? super Method> wrapReturnValuesFilter, Class<?>... interfacesToObserve)` returns an object that - apart from implementing the given interfaces - monitors each call to the object through the interfaces.
`static Object` `InterfaceWrapper.wrapObject(Object obj, InterfaceMonitor mon, Filter<? super Method> wrapReturnValuesFilter, Class<?>... interfacesToObserve)` uses the ClassLoader from the given object (first parameter)

Constructors in com.antelmann.util with parameters of type Filter
`ComboFilter(Filter<? super T> f1, Filter<? super T> f2, BooleanOperator operator)`
`ComboFilter(Filter<? super T> f1, Filter<? super T> f2, BooleanOperator operator)`
`OffsetFilter(int limit, Filter<? super T> innerFilter)`
`OffsetFilter(int offset, int limit, Filter<? super T> innerFilter)`
`VerboseFilter.Adapter(Filter<T> filter)`
`VerboseFilter.Adapter(Filter<T> filter, PatternExtractor<? super T,String> messageExtractor)`

Uses of Filter in com.antelmann.util.gui

Classes in com.antelmann.util.gui that implement Filter
`class` `DialogFilter<T>` a special filter that will accept a given entry via dialog response
`class` `DocumentAdapter` a convenience implementation that makes it easier to implement a DocumentListener if you want to perform a certain task in all cases.

Methods in com.antelmann.util.gui that return Filter
`Filter<? super Category<?>>` `JCategoryField.getFilter()`
`Filter<? super User>` `MyAbstractAction.getUserAccessFilter()`

Methods in com.antelmann.util.gui with parameters of type Filter
`static void` `DocumentTextFilter.applyFilter(JTextComponent c, Filter<String> filter)`
`static String` `FormHelper.enterMessage(Component parent, String title, int rows, int columns, boolean resizable, int optionType, Filter<String> filter, String initialValue)` opens a dialog allowing to enter a multi-line message
`static Number` `FormHelper.enterNumber(Component parent, String title, Object message, NumberFormat format, Filter<? super Number> filter, Object initialValue)`
`static String` `FormHelper.enterString(Component parent, String title, Object message, Filter<String> filter, Object initialValue)`
`static Category<?>` `CategoryNode.selectCategory(TreeNode categoryRoot, Object context, Category<?> defaultCategory, String title, Component parent, Filter<? super Category<?>> filter, TreeCellRenderer renderer)`
`void` `JCategoryField.setFilter(Filter<? super Category<?>> filter)`
`void` `MyAbstractAction.setUserAccessFilter(Filter<? super User> userAccessFilter)` allows to specify a filter for users that is checked when `MyAbstractAction.checkAccess(User)` is called if set to a non-null value

Constructors in com.antelmann.util.gui with parameters of type Filter
`DocumentTextFilter(Filter<String> filter)`
`DocumentTextFilter(Filter<String> filter, boolean beepOnError)`

Uses of Filter in com.antelmann.util.logging

Subinterfaces of Filter in com.antelmann.util.logging
`interface` `LogWriter` The LogWriter interface defines objects that can be used as a handler for the Logger class.

Classes in com.antelmann.util.logging that implement Filter
`class` `AbstractExceptionWriter` an abstract class to handle exceptions that occur in a LogEntry.
`class` `AbstractLogWriter<T>` provides filtering capabilities for a LogWriter.
`class` `AppendableLogWriter` writes to a given Appendable (PrintStream, StringBuffer, etc) using a String
`class` `AsynchLogWriter` allows to operate any LogWriter asynchronously.
`class` `BinaryFileLog` A LogWriter that logs the entries synchronously serialized to a file.
`class` `ConsoleLog` ConsoleLog prints abbreviated log messages to the console using `System.out.println()`.
`class` `EmailWriter` uses email to send each LogEntry object over the Internet.
`class` `ExceptionDialogWriter` shows a dialog upon each Throwable encountered.
`class` `FileLog` writes entries to a file without continuously holding a lock on the file.
`class` `JDBCLogWriter` JDBCLogWriter provides a LogWriter that writes to a java.sql.Connection.
`class` `JTextAreaLog` a more efficient visible log as it uses JTextArea methods to append the text
`class` `JTextComponentLog` JTextComponentLog writes abbreviated log messages into a given JTextComponent synchronously.
`class` `LevelFilter` filters LogEntry objects by their level using the natural order of Level objects
`class` `LogFile` LogFile provides great convenience for logging information from a program into a file.
`class` `Logger` Logger somewhat leans on the functionality of the java.util.logging functionality of J2SE 1.4, but it's not quite the same (and was implemented before J2SE 1.4).
`class` `LoggerCache` provides a simple mechanism to cache LogEntries from a Logger
`class` `LoggerWriter` provides a writer that propagates the LogEntries to another logger
`class` `LogNetPropagator` can be registered to listen logging events and then propagates them as serialized byte arrays over its NetConnectionServer.
`class` `SocketWriter` simply used to write serialized LogEntry objects via network
`class` `StackTraceFileWriter` writes full stack trace of entries that log an exception to a given file.
`class` `XMLLogWriter` writes LogEntry objects formatted as XML to either a PrintStream or PrintWriter.

Fields in com.antelmann.util.logging declared as Filter
`protected Filter<? super LogEntry>` `AbstractLogWriter.filter` may be null (in which case all LogEntry objects are written)
`static Filter<LogEntry>` `LevelFilter.MORE_THAN_FINE_LEVEL_FILTER` accepts LogEntry objects that compare to more than the FINE level.
`static Filter<LogEntry>` `LevelFilter.NO_FINE_LEVEL_FILTER` accepts LogEntry objects that exclude the levels FINE, FINER, FINEST.

Methods in com.antelmann.util.logging that return Filter
`Filter<? super LogEntry>` `LoggerCache.getFilter()`
`Filter<? super LogEntry>` `Logger.getFilter()` returns null by default
`Filter<? super LogEntry>` `AbstractLogWriter.getLogFilter()`

Methods in com.antelmann.util.logging with parameters of type Filter
`void` `LoggerCache.setFilter(Filter<? super LogEntry> filter)`
`void` `Logger.setFilter(Filter<? super LogEntry> filter)`
`void` `AbstractLogWriter.setLogFilter(Filter<? super LogEntry> filter)`

Constructors in com.antelmann.util.logging with parameters of type Filter
`AbstractLogWriter(LogEntryFormatter<T> formatter, Filter<? super LogEntry> filter)`

Uses of Filter in com.antelmann.util.revision

Methods in com.antelmann.util.revision with parameters of type Filter
`Enumeration<Revision>` `Revisable.getRevisions(Filter<? super Revision> filter)` optionally allows to access revisions that were performed on this instance
`Enumeration<Revision>` `DefaultRevisable.getRevisions(Filter<? super Revision> filter)`

Uses of Filter in com.antelmann.util.table

Classes in com.antelmann.util.table that implement Filter
`class` `SimpleTableRowFilter` implements a simple filter based on a search string searchPattern.

Methods in com.antelmann.util.table that return Filter
`Filter<? super TableRow>` `FilteredTableModel.getFilter()` filter may be null
`Filter<? super String>` `FormattedCellEditor.getStringFilter()`

Methods in com.antelmann.util.table with parameters of type Filter
`void` `FilteredTableModel.setFilter(Filter<? super TableRow> filter)` this method must also be called whenever the filter itself changes its behaviour; the filter itself may be null
`void` `FormattedCellEditor.setStringFilter(Filter<? super String> stringFilter)` `VerboseFilter` are honored

Constructors in com.antelmann.util.table with parameters of type Filter
`FilteredTableModel(TableModel model, Filter<? super TableRow> filter)`
`FormattedCellEditor(Filter<? super String> stringFilter)` uses `FormattedCellRenderer.ToStringFormat`
`FormattedCellRenderer.ToStringFormat(Filter<? super String> filter)`
`FormattedCellRenderer.ToStringFormat(Filter<? super String> filter, boolean useDetailedHtmlStringIfAvailable)`

(c) Holger Antelmann since 2001- all rights reserved (contact: info@antelmann.com)
see www.antelmann.com/developer for further details and available downloads