Developing a new data source
Understanding the data source backup paradigm
The base class
IlvMapDataSource includes a fallback mechanism to allow map reprojection and export even when associated source data (file, network path, database connection...) is not available at the time the map needs to be manipulated. For that mechanism to operate, a subclass of
IlvMapDataSource must override the method
isSourceDataAvailable and perform appropriate checks on related data availability.
If this method returns false, the IlvMapDataSource tries to perform operations on the map (change of coordinate system, export) from the current map objects instead of reading them from the original source data. Note that this may lead to loss of precision or even data as this is the expected behavior when chaining-up several non-invertible projections.
Another way to force the use of a backup data source is by setting a flag using the method
setForceUsingBackupDataSource. This will result in much faster operations (such as reprojection) as the source data is not read back from its original format. However, as mentioned above, this leads to potential precision or data loss.
Should you need to access these backup data sources of a given data source directly, you can do so by calling
getBackupDataSources. It returns an array of data sources of the class
IlvGraphicLayerDataSource.
The source code for the Map Builder demonstration, which contains all of the code described in this section, can be found at
<installdir> /jviews-maps/samples/mapbuilder/index.html.
Renderer management
Unless you need specific rendering, you should use the base
IlvMapDataSource class renderer management, which either finds the renderer associated with the
IlvMapReusableFeatureIterator or creates a new
IlvDefaultFeatureRenderer.
Layer management
By default, the base
IlvMapDataSource class layer manager creates a map layer when needed, and connects it to the manager (by creating an
IlvManagerLayer).
Usually, the only layer management method you have to rewrite is the
initInsertionLayer method, when you need to create a tiled layer instead of a standard
IlvManagerLayer:
protected void initInsertionLayer(IlvMapLayer layer) {
layer.insert(new IlvTiledLayer(new IlvRect(), null,
IlvTileController.FREE));
}
If you want your data source to manage more than a single map layer you may have to write more complex layer management code, or create a subclass of the
IlvHierarchicalDataSource.
Data tiling
It you have a data format or readers that support
tiles, you may have to create the tiles and tile loaders in a specific
start method. Here is an example used in the shapefile data source:
public void start() throws Exception
{
// construct a tiled shape tile loader
IlvShapeFileTileLoader tileLoader = new IlvShapeFileTileLoader(shp, dbf,shx,
idx);
tileLoader.setCoordinateSystem(getCoordinateSystem());
tileLoader.setFeatureRenderer(getFeatureRenderer());
// create a threaded tile loader to load the shape data on a background thread.
IlvTiledLayer tiledLayer = (IlvTiledLayer)getInsertionLayer().
getManagerLayer();
IlvThreadedTileLoader threadedLoader = new IlvThreadedTileLoader(tileLoader,
true);
tiledLayer.setTileLoader(threadedLoader);
...
// for each tile known by the tile loader
for (int i = ...) {
for (int j = ...) {
// Compute projected tile bounds, ie the bounds of the tile in the manager
coordinates
IlvRect r = IlvMapUtil.computeTransformedBounds(...);
Point2D.Double ul = new Point2D.Double(r.getX(), r.getY());
Point2D.Double lr = new Point2D.Double(r.getX() + r.getWidth(), r.getY()
+ r.getHeight());
tiledLayer.getTileController().addTile(new IlvMapFreeTile(ul, lr,
tiledLayer.getTileController(), i, j));
}
}
}
Feature management
The
IlvMapReusableFeatureIterator is a subinterface of
IlvMapFeatureIterator. It adds to the base interface the capability to restart the iteration more than once. This is necessary when, for example, projection parameters have changed and the data source needs to render all the graphic objects again. This is also used for load-on-demand or save/reload mechanisms.
You can transform a feature iterator (such as for readers written for a previous version of
JViews Maps) into a reusable feature iterator by using the
IlvMapDelegateFeatureIterator abstract class. For example, the code below uses the feature iterator returned by an
IlvMapLoader:
String fileName="some file name";
public IlvMapReusableFeatureIterator getFeatureIterator() {
return new IlvMapDelegateFeatureIterator() {
public void restart() {
IlvMapLoader loader = new IlvMapLoader(null);
try {
setDelegate(loader.makeFeatureIterator(fileName));
} catch (IOException e) {
e.printStackTrace();
}
}
};
}
Copyright © 2018, Rogue Wave Software, Inc. All Rights Reserved.
