001 //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/graphics/sld/FeatureTypeStyle.java $ 002 /*---------------------------------------------------------------------------- 003 This file is part of deegree, http://deegree.org/ 004 Copyright (C) 2001-2009 by: 005 Department of Geography, University of Bonn 006 and 007 lat/lon GmbH 008 009 This library is free software; you can redistribute it and/or modify it under 010 the terms of the GNU Lesser General Public License as published by the Free 011 Software Foundation; either version 2.1 of the License, or (at your option) 012 any later version. 013 This library is distributed in the hope that it will be useful, but WITHOUT 014 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 015 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 016 details. 017 You should have received a copy of the GNU Lesser General Public License 018 along with this library; if not, write to the Free Software Foundation, Inc., 019 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 020 021 Contact information: 022 023 lat/lon GmbH 024 Aennchenstr. 19, 53177 Bonn 025 Germany 026 http://lat-lon.de/ 027 028 Department of Geography, University of Bonn 029 Prof. Dr. Klaus Greve 030 Postfach 1147, 53001 Bonn 031 Germany 032 http://www.geographie.uni-bonn.de/deegree/ 033 034 e-mail: info@deegree.org 035 ----------------------------------------------------------------------------*/ 036 package org.deegree.graphics.sld; 037 038 import static org.deegree.framework.xml.XMLTools.escape; 039 040 import java.util.ArrayList; 041 import java.util.List; 042 043 import org.deegree.framework.xml.Marshallable; 044 045 /** 046 * The FeatureTypeStyle defines the styling that is to be applied to a single feature type of a 047 * layer). This element may also be externally re-used outside of the scope of WMSes and layers. 048 * <p> 049 * </p> 050 * The FeatureTypeStyle element identifies that explicit separation in SLD between the handling of 051 * layers and the handling of features of specific feature types. The layer concept is unique to WMS 052 * and SLD, but features are used more generally, such as in WFS and GML, so this explicit 053 * separation is important. 054 * <p> 055 * ---------------------------------------------------------------------- 056 * </p> 057 * 058 * @author <a href="mailto:k.lupp@web.de">Katharina Lupp</a> 059 * @version $Revision: 18195 $ $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $ 060 */ 061 public class FeatureTypeStyle implements Marshallable { 062 private List<Rule> rules = null; 063 064 private List<String> semanticTypeIdentifier = null; 065 066 private String abstract_ = null; 067 068 private String featureTypeName = null; 069 070 private String name = null; 071 072 private String title = null; 073 074 /** 075 * default constructor 076 */ 077 FeatureTypeStyle() { 078 semanticTypeIdentifier = new ArrayList<String>(); 079 rules = new ArrayList<Rule>(); 080 } 081 082 /** 083 * constructor initializing the class with the <FeatureTypeStyle> 084 * @param name 085 * @param title 086 * @param abstract_ 087 * @param featureTypeName 088 * @param semanticTypeIdentifier 089 * @param rules 090 */ 091 FeatureTypeStyle( String name, String title, String abstract_, String featureTypeName, 092 String[] semanticTypeIdentifier, Rule[] rules ) { 093 this(); 094 setName( name ); 095 setTitle( title ); 096 setAbstract( abstract_ ); 097 setFeatureTypeName( featureTypeName ); 098 setSemanticTypeIdentifier( semanticTypeIdentifier ); 099 setRules( rules ); 100 } 101 102 /** 103 * The Name element does not have an explicit use at present, though it conceivably might be 104 * used to reference a feature style in some feature-style library. 105 * 106 * @return name 107 * 108 */ 109 public String getName() { 110 return name; 111 } 112 113 /** 114 * The Name element does not have an explicit use at present, though it conceivably might be 115 * used to reference a feature style in some feature-style library. Sets the <Name> o 116 * 117 * @param name 118 * the name 119 * 120 */ 121 public void setName( String name ) { 122 this.name = name; 123 } 124 125 /** 126 * human-readable information about the style 127 * 128 * @return the title of the FeatureTypeStyle 129 * 130 */ 131 public String getTitle() { 132 return title; 133 } 134 135 /** 136 * sets the <Title> 137 * 138 * @param title 139 * the title of the FeatureTypeStyle 140 * 141 */ 142 public void setTitle( String title ) { 143 this.title = title; 144 } 145 146 /** 147 * human-readable information about the style 148 * 149 * @return an abstract of the FeatureTypeStyle 150 */ 151 public String getAbstract() { 152 return abstract_; 153 } 154 155 /** 156 * sets <Abstract> 157 * 158 * @param abstract_ 159 * an abstract of the FeatureTypeStyle 160 */ 161 public void setAbstract( String abstract_ ) { 162 this.abstract_ = abstract_; 163 } 164 165 /** 166 * returns the name of the affected feature type 167 * 168 * @return the name of the FeatureTypeStyle as String 169 * 170 */ 171 public String getFeatureTypeName() { 172 return featureTypeName; 173 } 174 175 /** 176 * sets the name of the affected feature type 177 * 178 * @param featureTypeName 179 * the name of the FeatureTypeStyle 180 * 181 */ 182 public void setFeatureTypeName( String featureTypeName ) { 183 this.featureTypeName = featureTypeName; 184 } 185 186 /** 187 * The SemanticTypeIdentifier is experimental and is intended to be used to identify what the 188 * feature style is suitable to be used for using community- controlled name(s). For example, a 189 * single style may be suitable to use with many different feature types. The syntax of the 190 * SemanticTypeIdentifier string is undefined, but the strings generic:line, generic:polygon, 191 * generic:point, generic:text, generic:raster, and generic:any are reserved to indicate that a 192 * FeatureTypeStyle may be used with any feature type with the corresponding default geometry 193 * type (i.e., no feature properties are referenced in the feature-type style). 194 * 195 * @return the SemanticTypeIdentifiers from the FeatureTypeStyle as String-Array 196 * 197 */ 198 public String[] getSemanticTypeIdentifier() { 199 return semanticTypeIdentifier.toArray( new String[semanticTypeIdentifier.size()] ); 200 } 201 202 /** 203 * Sets the SemanticTypeIdentifiers. 204 * 205 * @param semanticTypeIdentifiers 206 * SemanticTypeIdentifiers for the FeatureTypeStyle 207 */ 208 public void setSemanticTypeIdentifier( String[] semanticTypeIdentifiers ) { 209 semanticTypeIdentifier.clear(); 210 211 if ( semanticTypeIdentifiers != null ) { 212 for ( int i = 0; i < semanticTypeIdentifiers.length; i++ ) { 213 semanticTypeIdentifier.add( semanticTypeIdentifiers[i] ); 214 } 215 } 216 } 217 218 /** 219 * adds the <SemanticTypeIdentifier> 220 * 221 * @param semanticTypeIdentifier 222 * SemanticTypeIdentifier to add 223 */ 224 public void addSemanticTypeIdentifier( String semanticTypeIdentifier ) { 225 this.semanticTypeIdentifier.add( semanticTypeIdentifier ); 226 } 227 228 /** 229 * Removes an <SemanticTypeIdentifier>. 230 * 231 * @param semanticTypeIdentifier 232 * SemanticTypeIdentifier to remove 233 */ 234 public void removeSemanticTypeIdentifier( String semanticTypeIdentifier ) { 235 this.semanticTypeIdentifier.remove( this.semanticTypeIdentifier.indexOf( semanticTypeIdentifier ) ); 236 } 237 238 /** 239 * Rules are used to group rendering instructions by feature-property conditions and map scales. 240 * Rule definitions are placed immediately inside of feature-style definitions. 241 * 242 * @return the rules of the FeatureTypeStyle as Array 243 * 244 */ 245 public Rule[] getRules() { 246 return rules.toArray( new Rule[rules.size()] ); 247 } 248 249 /** 250 * sets the <Rules> 251 * 252 * @param rules 253 * the rules of the FeatureTypeStyle as Array 254 */ 255 public void setRules( Rule[] rules ) { 256 this.rules.clear(); 257 258 if ( rules != null ) { 259 for ( int i = 0; i < rules.length; i++ ) { 260 this.rules.add( rules[i] ); 261 } 262 } 263 } 264 265 /** 266 * adds the <Rules> 267 * 268 * @param rule 269 * a rule 270 */ 271 public void addRule( Rule rule ) { 272 rules.add( rule ); 273 } 274 275 /** 276 * removes a rule 277 * 278 * @param rule 279 * a rule 280 */ 281 public void removeRule( Rule rule ) { 282 rules.remove( rules.indexOf( rule ) ); 283 } 284 285 /** 286 * exports the content of the FeatureTypeStyle as XML formated String 287 * 288 * @return xml representation of the FeatureTypeStyle 289 */ 290 public String exportAsXML() { 291 292 StringBuffer sb = new StringBuffer( 1000 ); 293 sb.append( "<FeatureTypeStyle>" ); 294 if ( name != null && !name.equals( "" ) ) { 295 sb.append( "<Name>" ).append( escape( name ) ).append( "</Name>" ); 296 } 297 if ( title != null && !title.equals( "" ) ) { 298 sb.append( "<Title>" ).append( escape( title ) ).append( "</Title>" ); 299 } 300 if ( abstract_ != null && !abstract_.equals( "" ) ) { 301 sb.append( "<Abstract>" ).append( escape( abstract_ ) ).append( "</Abstract>" ); 302 } 303 if ( featureTypeName != null && !featureTypeName.equals( "" ) ) { 304 sb.append( "<FeatureTypeName>" ).append( escape( featureTypeName ) ).append( "</FeatureTypeName>" ); 305 } 306 for ( int i = 0; i < semanticTypeIdentifier.size(); i++ ) { 307 sb.append( "<SemanticTypeIdentifier>" ).append( escape( semanticTypeIdentifier.get( i ) ) ).append( 308 "</SemanticTypeIdentifier>" ); 309 } 310 for ( int i = 0; i < rules.size(); i++ ) { 311 sb.append( ( (Marshallable) rules.get( i ) ).exportAsXML() ); 312 } 313 sb.append( "</FeatureTypeStyle>" ); 314 315 return sb.toString(); 316 } 317 }