/** * Reset builder to provided original stroke. * * @param stroke */ public UserLayerBuilder reset(UserLayer other) { if (other == null) { return unset(); } inlineFeatureDataStore = other.getInlineFeatureDatastore(); inlineFeatureType = other.getInlineFeatureType(); remoteOWS.reset(other.getRemoteOWS()); featureTypeConstraint.clear(); for (FeatureTypeConstraint ftc : other.getLayerFeatureConstraints()) { featureTypeConstraint.add(new FeatureTypeConstraintBuilder(this).reset(ftc)); } userStyles.clear(); for (Style style : other.getUserStyles()) { userStyles.add(new StyleBuilder(this).reset(style)); } unset = false; return this; }
} else if (childName.equalsIgnoreCase("UserStyle")) { Style user = parseStyle(child); layer.addUserStyle(user); } else if (childName.equalsIgnoreCase("Name")) { String layerName = getFirstChildValue(child); layer.setName(layerName); if (LOGGER.isLoggable(Level.INFO)) LOGGER.info("layer name: " + layer.getName()); } else if (childName.equalsIgnoreCase("RemoteOWS")) { RemoteOWS remoteOws = parseRemoteOWS(child); layer.setRemoteOWS(remoteOws); } else if (childName.equalsIgnoreCase("LayerFeatureConstraints")) { layer.setLayerFeatureConstraints(parseLayerFeatureConstraints(child));
public UserLayer build() { if (unset) { return null; } UserLayer layer = sf.createUserLayer(); layer.setRemoteOWS(remoteOWS.build()); layer.setInlineFeatureDatastore(inlineFeatureDataStore); layer.setInlineFeatureType(inlineFeatureType); if (featureTypeConstraint.size() > 0) { FeatureTypeConstraint[] constraints = new FeatureTypeConstraint[featureTypeConstraint.size()]; for (int i = 0; i < constraints.length; i++) { constraints[i] = featureTypeConstraint.get(i).build(); } layer.setLayerFeatureConstraints(constraints); } for (StyleBuilder sb : userStyles) { layer.addUserStyle(sb.build()); } return layer; }
RemoteOWS service = ul.getRemoteOWS(); if (!service.getService().equalsIgnoreCase("WFS")) throw new UnsupportedOperationException( throw new IllegalStateException( "OnlineResource for remote WFS not specified in SLD"); final FeatureTypeConstraint[] featureConstraints = ul.getLayerFeatureConstraints(); if (featureConstraints == null || featureConstraints.length == 0) throw new IllegalStateException( Style[] layerStyles = ul.getUserStyles();
if (ul.getInlineFeatureType().getCoordinateReferenceSystem() == null) { LOGGER.warning( "No CRS set on inline features default geometry. Assuming the requestor has their inlinefeatures in the boundingbox CRS."); SimpleFeatureType currFt = ul.getInlineFeatureType(); Query q = new Query(currFt.getTypeName(), Filter.INCLUDE); FeatureReader<SimpleFeatureType, SimpleFeature> ilReader; DataStore inlineFeatureDatastore = ul.getInlineFeatureDatastore(); ilReader = inlineFeatureDatastore.getFeatureReader(q, Transaction.AUTO_COMMIT); CoordinateReferenceSystem crs = DataStore inlineFeatureDatastore = ul.getInlineFeatureDatastore(); String typeName = inlineFeatureDatastore.getTypeNames()[0]; featureSource = inlineFeatureDatastore.getFeatureSource(typeName);
@Override public void visit(UserLayer layer) { if (null == layer.getName()) { throw new ServiceException("A UserLayer or NamedLayer without layer name was passed"); if (layer.getRemoteOWS() != null) { List<LayerInfo> layers = getRemoteLayersFromUserLayer(layer); visitUserLayerRemoteOWS(layer); } else if (layer.getInlineFeatureDatastore() != null) { try { setLayerState(getInlineFeatureLayer(layer, fallbackCrs), layer);
public void visit(UserLayer layer) { UserLayer copy = null; Style[] style = layer.getUserStyles(); int length = style.length; Style[] styleCopy = new Style[length]; for (int i = 0; i < length; i++) { if (style[i] != null) { style[i].accept(this); styleCopy[i] = (Style) pages.pop(); } } FeatureTypeConstraint[] lfc = layer.getLayerFeatureConstraints(); FeatureTypeConstraint[] lfcCopy = new FeatureTypeConstraint[lfc.length]; length = lfc.length; for (int i = 0; i < length; i++) { if (lfc[i] != null) { lfc[i].accept(this); lfcCopy[i] = (FeatureTypeConstraint) pages.pop(); } } copy = sf.createUserLayer(); copy.setName(layer.getName()); copy.setUserStyles(styleCopy); copy.setLayerFeatureConstraints(lfcCopy); if (STRICT && !copy.equals(layer)) { throw new IllegalStateException("Was unable to duplicate provided UserLayer:" + layer); } pages.push(copy); }
public void visit(UserLayer layer) { Style[] style = layer.getUserStyles(); int length = style.length; Style[] styleCopy = new Style[length]; FeatureTypeConstraint[] lfc = layer.getLayerFeatureConstraints(); FeatureTypeConstraint[] lfcCopy = new FeatureTypeConstraint[lfc.length]; copy.setName(layer.getName()); copy.setUserStyles(styleCopy); copy.setLayerFeatureConstraints(lfcCopy); copy.setInlineFeatureDatastore(layer.getInlineFeatureDatastore()); copy.setInlineFeatureType(layer.getInlineFeatureType());
/** * Convenience method to pull a UserSyle from a StyledLayerDescriptor. * * <p>This method will return the first UserStyle it encounters in the StyledLayerDescriptor * tree. * * @param sld The StyledLayerDescriptor object. * @return The UserStyle, or <code>null</code> if no such style could be found. */ public static Style style(StyledLayerDescriptor sld) { for (int i = 0; i < sld.getStyledLayers().length; i++) { Style[] styles = null; if (sld.getStyledLayers()[i] instanceof NamedLayer) { NamedLayer layer = (NamedLayer) sld.getStyledLayers()[i]; styles = layer.getStyles(); } else if (sld.getStyledLayers()[i] instanceof UserLayer) { UserLayer layer = (UserLayer) sld.getStyledLayers()[i]; styles = layer.getUserStyles(); } if (styles != null) { for (int j = 0; j < styles.length; j++) { if (!(styles[j] instanceof NamedStyle)) { return styles[j]; } } } } return null; }
String typeName = userLayer.getInlineFeatureType().getTypeName(); try { SimpleFeatureSource featureSource = userLayer.getInlineFeatureDatastore().getFeatureSource(typeName); lastRow = -1; DataStore dataStore = DataUtilities.dataStore(collection); userLayer.setInlineFeatureDatastore(dataStore); userLayer.setInlineFeatureType(newFeatureType);
@Override public void visit(UserLayer layer) { for (Style s : layer.getUserStyles()) { s.accept(this); } for (FeatureTypeConstraint ftc : layer.getLayerFeatureConstraints()) { ftc.accept(this); } }
/** * @param child * @param layer */ private void parseInlineFeature(Node root, UserLayer layer) { try { SLDInlineFeatureParser inparser = new SLDInlineFeatureParser(root); layer.setInlineFeatureDatastore(inparser.dataStore); layer.setInlineFeatureType(inparser.featureType); } catch (Exception e) { throw (IllegalArgumentException) new IllegalArgumentException().initCause(e); } }
public String toXML(Style style) { if (style == null) { return null; } UserLayer layer = sf.createUserLayer(); layer.setLayerFeatureConstraints(new FeatureTypeConstraint[] { null }); layer.setName(featureType.getTypeName()); layer.addUserStyle(style); StyledLayerDescriptor sld = sf.createStyledLayerDescriptor(); sld.addStyledLayer(layer); try { SLDTransformer styleTransform = new SLDTransformer(); return styleTransform.transform(sld); } catch (TransformerException te) { LOGGER.log(Level.FINE, te.getMessage(), te); } return null; } }
SimpleFeatureType featureType = userLayer.getInlineFeatureType(); String typeName = userLayer.getInlineFeatureType().getTypeName(); try { SimpleFeatureSource featureSource = userLayer.getInlineFeatureDatastore().getFeatureSource(typeName); lastRow = -1; DataStore dataStore = DataUtilities.dataStore(collection); userLayer.setInlineFeatureDatastore(dataStore);
"background")); userLayer.setInlineFeatureType(featureType); userLayer.setInlineFeatureDatastore(DataUtilities.dataStore(fc)); userLayer.setName("background"); userLayer.userStyles().add(style); sld.layers().add(userLayer); } catch (FactoryException e) {
/** * Checks to see if SLD contains inline features. * * @param sld the sld * @return true, if sld contains inline features */ public static boolean containsInLineFeatures(StyledLayerDescriptor sld) { if (sld != null) { for (StyledLayer layer : sld.layers()) { if (layer instanceof UserLayer) { UserLayer userLayer = (UserLayer) layer; if (userLayer.getInlineFeatureDatastore() != null) { return true; } } } } return false; }
if(sl instanceof UserLayer && ((((UserLayer) sl)).getRemoteOWS() != null)) { && ((((UserLayer) sl)).getInlineFeatureDatastore() != null)) {
@Override public void visitUserLayerRemoteOWS(UserLayer ul) { currLayer = null; final FeatureTypeConstraint[] featureConstraints = ul.getLayerFeatureConstraints(); if (request.getFilter() == null) { request.setFilter(new ArrayList()); } for (int i = 0; i < featureConstraints.length; i++) { // make sure the layer is there String name = featureConstraints[i].getFeatureTypeName(); // grab the filter Filter filter = featureConstraints[i].getFilter(); if (filter == null) { filter = Filter.INCLUDE; } request.getFilter().add(filter); } }
/** * Sets the inline features. * * @param userLayer the user layer */ public void setInlineFeatures(UserLayer userLayer) { if (userLayer != null) { String crsCode = ""; SimpleFeatureType inlineFeatureType = userLayer.getInlineFeatureType(); if (inlineFeatureType != null) { crsCode = CoordManager.getInstance() .getCRSCode(inlineFeatureType.getCoordinateReferenceSystem()); } setPopulating(true); crsComboBox.setSelectValueKey(crsCode); setPopulating(false); model.populate(userLayer); } }
/** @param userLayer */ private void updateRemoteOWS(UserLayer userLayer) { RemoteOWS remoteOWS = new RemoteOWSImpl(); String service = fieldConfigVisitor.getText(FieldIdEnum.REMOTE_OWS_SERVICE); remoteOWS.setService(service); String onlineResource = fieldConfigVisitor.getText(FieldIdEnum.REMOTE_OWS_ONLINERESOURCE); remoteOWS.setOnlineResource(onlineResource); userLayer.setRemoteOWS(remoteOWS); }