How to use org.geotools.styling

  @Override
  public void visit(ChannelSelection cs) {
    if (cs.getGrayChannel() != null) {
      cs.getGrayChannel().accept(this);
    }
    final SelectedChannelType[] rgbChannels = cs.getRGBChannels();
    for (SelectedChannelType ch : rgbChannels) {
      if (ch != null) ch.accept(this);
    }
  }
});

/**
 * Convenience method to wrap a UserStyle in a StyledLayerDescriptor object.
 *
 * <p>This method wraps the UserStyle in a NamedLayer, and wraps the result in a
 * StyledLayerDescriptor.
 *
 * @param style The UserStyle.
 * @return The StyledLayerDescriptor.
 */
public static StyledLayerDescriptor sld(Style style) {
  StyledLayerDescriptor sld = styleFactory.createStyledLayerDescriptor();
  NamedLayer layer = styleFactory.createNamedLayer();
  layer.setName(style.getName());
  sld.addStyledLayer(layer);
  layer.addStyle(style);
  return sld;
}

/**
 * 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;
}

  LineSymbolizer ls = styleFactory.createLineSymbolizer();
  ls.setStroke(
      styleFactory.createStroke(
          filterFactory.literal(color), filterFactory.literal(2)));
  PolygonSymbolizer ps = styleFactory.createPolygonSymbolizer();
  ps.setFill(styleFactory.createFill(filterFactory.literal(color)));
  RasterSymbolizer rs = styleFactory.createRasterSymbolizer();
  sym = rs;
} else {
  Mark mark = styleFactory.createMark();
  mark.setFill(styleFactory.createFill(filterFactory.literal(color)));
  PointSymbolizer ps = styleFactory.createPointSymbolizer();
  ps.setGraphic(styleFactory.createDefaultGraphic());
  ps.getGraphic().graphicalSymbols().add(mark);
Rule r = styleFactory.createRule();
r.symbolizers().add(sym);
FeatureTypeStyle fts = styleFactory.createFeatureTypeStyle();
fts.rules().add(r);
Style s = styleFactory.createStyle();
s.featureTypeStyles().add(fts);
UserLayer l = styleFactory.createUserLayer();
l.userStyles().add(s);

@Test
public void testSEStyleWithRelativePathProtocol() throws IOException {
  StyleInfo si = getCatalog().getStyleByName("relative_protocol");
  assertNotNull(si);
  Style style = si.getStyle();
  PolygonSymbolizer ps =
      (PolygonSymbolizer)
          style.featureTypeStyles().get(0).rules().get(0).symbolizers().get(0);
  ExternalGraphic eg =
      (ExternalGraphic) ps.getFill().getGraphicFill().graphicalSymbols().get(0);
  URI uri = eg.getOnlineResource().getLinkage();
  assertNotNull(uri);
  File actual = URLs.urlToFile(uri.toURL()).getCanonicalFile();
  assertEquals(rockFillSymbolFile, actual);
}

  @Override
  public Void answer() throws Throwable {
    Object[] args = getCurrentArguments();
    InputStream is = (InputStream) args[1];
    byte[] input = IOUtils.toByteArray(is);
    SLDParser parser =
        new SLDParser(CommonFactoryFinder.getStyleFactory());
    parser.setInput(new ByteArrayInputStream(input));
    StyledLayerDescriptor sld = parser.parseSLD();
    NamedLayer nl = (NamedLayer) sld.getStyledLayers()[0];
    assertEquals("foo", nl.getName());
    Style style = nl.getStyles()[0];
    assertEquals(
        "A raster style",
        style.getDescription().getTitle().toString());
    assertEquals(1, style.featureTypeStyles().size());
    FeatureTypeStyle fts = style.featureTypeStyles().get(0);
    assertEquals(1, fts.rules().size());
    assertThat(
        fts.rules().get(0).symbolizers().get(0),
        instanceOf(RasterSymbolizer.class));
    // make sure it's valid
    SLDValidator validator = new SLDValidator();
    List errors =
        validator.validateSLD(new ByteArrayInputStream(input));
    assertEquals(0, errors.size());
    return null;
  }
});

StyledLayerDescriptor parse10(
    Object input, ResourceLocator resourceLocator, EntityResolver entityResolver)
    throws IOException {
  Reader reader = null;
  try {
    // we need to close the reader if we grab one, but if it's a file it has
    // to stay as such to allow relative resource resolution during the parse
    if (!(input instanceof File)) {
      reader = toReader(input);
      input = reader;
    }
    SLDParser p = createSld10Parser(input, resourceLocator, entityResolver);
    StyledLayerDescriptor sld = p.parseSLD();
    if (sld.getStyledLayers().length == 0) {
      // most likely a style that is not a valid sld, try to actually parse out a
      // style and then wrap it in an sld
      Style[] style = p.readDOM();
      if (style.length > 0) {
        NamedLayer l = styleFactory.createNamedLayer();
        l.addStyle(style[0]);
        sld.addStyledLayer(l);
      }
    }
    return sld;
  } finally {
    IOUtils.closeQuietly(reader);
  }
}

/**
 * Visit the SLD
 *
 * <p>Visit each layer. Construct temporary stores for inline features and remote OWS layers.
 * After visiting a layer, visit each style in that layer. In cases where the styled layer
 * references multiple layers, such as a named layer referencing a layer group, or remote OWS
 * user layer exposing multiple layers, visit each style for each of these sublayers instead.
 *
 * @param sld The sld the visitor is applied to
 * @throws UnsupportedOperationException, If the sld uses features not supported by GeoServer,
 *     such as if an OWS service other than WFS is specified for a UserLayer
 * @throws IllegalStateException If the sld is somehow invalid, such as if there is a NamedLayer
 *     without a name
 * @throws ServiceException if there was a problem accessing a remote OWS service
 * @throws UncheckedIOException if there is an underlying {@link IOException} when reading
 *     {@link Style} objects from the catalog
 */
@Override
public void visit(StyledLayerDescriptor sld) {
  if (sld.getStyledLayers().length == 0) {
    throw new IllegalStateException("SLD document contains no layers");
  }
  super.visit(sld);
}

public StyleWrappingStyleInfoImpl(Style style) {
  super();
  this.style = style;
  setName(style.getName());
}

@Override
public void visit(NamedLayer layer) {
  if (null == layer.getName()) {
    throw new ServiceException("A UserLayer or NamedLayer without layer name was passed");
  }
  setLayerState(visitNamedLayerInternal(layer), layer);
  if (!handleLayerGroup()) {
    super.visit(layer);
  }
  handleNoStyles();
  clearLayerState();
}

  @Override
  public StyleInfo visitNamedStyleInternal(NamedStyle namedStyle) {
    String styleName = namedStyle.getName();
    StyleInfo s = catalog.getStyleByName(styleName);
    if (renamedStyles.get(styleName) != null) {
      needsRename = true;
      if (doRename) {
        namedStyle.setName(renamedStyles.get(styleName));
      }
    }
    return s;
  }
}

  @Override
  public void visit(Mark mark) {
    assertEquals(
        "ttf://Webdings",
        mark.getExternalMark()
            .getOnlineResource()
            .getLinkage()
            .toASCIIString());
  }
});

  public static List<Exception> validate(Catalog catalog, StyledLayerDescriptor sld) {
    SLDNamedLayerValidator validator = new SLDNamedLayerValidator(catalog, null);
    sld.accept(validator);
    return validator.getValidationErrors();
  }
}

@Override
public PublishedInfo visitNamedLayerInternal(StyledLayer namedLayer) {
  PublishedInfo p = catalog.getLayerGroupByName(namedLayer.getName());
  if (p == null) {
    p = catalog.getLayerByName(namedLayer.getName());
    if (p == null) {
      throw new ServiceException(
          "No layer or layer group with name \"" + namedLayer.getName() + "\"");
    }
  }
  return p;
}

@Override
public StyleInfo visitNamedStyleInternal(NamedStyle namedStyle) {
  StyleInfo s = catalog.getStyleByName(namedStyle.getName());
  if (s == null) {
    validationErrors.add(
        new Exception(
            "No style named '" + namedStyle.getName() + "' found in the catalog"));
  }
  return s;
}

@Override
public void visit(Style style) {
  styleCount++;
  if (style instanceof NamedStyle) {
    visitNamedStyleInternal((NamedStyle) style);
  } else {
    visitUserStyleInternal(style);
  }
  super.visit(style);
}

  @Override
  protected URL makeRelativeURL(String uri, String query) {
    if (SystemUtils.IS_OS_WINDOWS && uri.contains("\\")) {
      uri = uri.replace('\\', '/');
    }
    return super.makeRelativeURL(uri, query);
  }
}

@Override
public void encode(
    StyledLayerDescriptor sld, Version version, boolean pretty, OutputStream output)
    throws IOException {
  Properties props = new Properties();
  for (Symbolizer sym : SLD.symbolizers(Styles.style(sld))) {
    if (sym instanceof PointSymbolizer) {
      props.put("type", "point");
    } else if (sym instanceof LineSymbolizer) {
      props.put("type", "line");
    } else if (sym instanceof PolygonSymbolizer) {
      props.put("type", "polygon");
    } else if (sym instanceof RasterSymbolizer) {
      props.put("type", "raster");
    }
  }
  props.store(output, null);
}

@Test
public void testSEStyleWithRelativePath() throws IOException {
  StyleInfo si = getCatalog().getStyleByName("relative");
  assertNotNull(si);
  Style style = si.getStyle();
  PolygonSymbolizer ps =
      (PolygonSymbolizer)
          style.featureTypeStyles().get(0).rules().get(0).symbolizers().get(0);
  ExternalGraphic eg =
      (ExternalGraphic) ps.getFill().getGraphicFill().graphicalSymbols().get(0);
  URI uri = eg.getOnlineResource().getLinkage();
  assertNotNull(uri);
  File actual = URLs.urlToFile(uri.toURL()).getCanonicalFile();
  assertEquals(rockFillSymbolFile, actual);
}

@Override
public StyleInfo visitNamedStyleInternal(NamedStyle namedStyle) {
  StyleInfo s = catalog.getStyleByName(namedStyle.getName());
  layers.add((LayerInfo) info);
  styles.add(s);
  return s;
}