Getter for the used {@link TextSymbolizerWrapper}.

<p>Currently only one {@link TextSymbolizer} is supported in editing, so just the first is used.</p>

@return the used {@link TextSymbolizer}.
199885
public TextSymbolizerWrapper getTextSymbolizersWrapper() {
        for( SymbolizerWrapper symbolizerWrapper : symbolizersWrapperList ) {
            if (symbolizerWrapper.isTextSymbolizer()) {
                return (TextSymbolizerWrapper) symbolizerWrapper;
            }
        }
        return null;
    }
1109717
public JsonSerializer<T> getSerializer() {
        if ( null == serializer ) {
            serializer = (JsonSerializer<T>) newSerializer();
        }
        return serializer;
    }
610260
public void removeTextSymbolizersWrapper() {
        List<SymbolizerWrapper> removeSW = new ArrayList<SymbolizerWrapper>();
        List<Symbolizer> removeS = new ArrayList<Symbolizer>();

        List<Symbolizer> symbolizers = rule.symbolizers();
        for( SymbolizerWrapper symbolizerWrapper : symbolizersWrapperList ) {
            if (symbolizerWrapper.isTextSymbolizer()) {
                Symbolizer symbolizer = symbolizerWrapper.getSymbolizer();
                removeSW.add(symbolizerWrapper);
                removeS.add(symbolizer);
            }
        }

        symbolizersWrapperList.removeAll(removeSW);
        symbolizers.removeAll(removeS);
    }
665419
<T> WABTracker<T> getTracker(BundleTrackerCustomizer<T> wabTrackerCustomizer) {
        try {
            //we are interested in WABs that are starting (could be lazy activation)
            //or already active
            int mask = Bundle.STARTING | Bundle.ACTIVE;
            return new WABTracker<T>(ctx, mask, wabTrackerCustomizer);
        } catch (Exception e) {
            // If this goes wrong FFDC and log the error as we won't be able to be used
            Tr.error(tc, "bundle.tracker.init.fail");
        }
        return null;
    }
804610
protected final Injector getInjector() {
        if (injector != null) {
            throw new IllegalStateException("Injector already created.");
        }
        try {
            injector = createInjector();
        }
        catch (Exception e) {
            LOG.error("Failed to created injector", e);
            throw new ProvisionException("Failed to create injector", e);
        }
        return injector;
    }
628141
private Writer getWriters(ScriptWrapper script) {
		Writer delegatee = this.writers;
		Writer writer = script.getWriter();
		if (writer != null) {
			// Use the script specific writer in addition to the std one
			MultipleWriters scriptWriters = new MultipleWriters();
			scriptWriters.addWriter(writer);
			scriptWriters.addWriter(writers);
			delegatee = scriptWriters;
		}
		return new ScriptWriter(script, delegatee, outputListeners);
	}
76059
public static LineSymbolizer lineSymbolizerFromRule( Rule rule ) {
        List<Symbolizer> symbolizers = rule.symbolizers();
        LineSymbolizer lineSymbolizer = null;
        for( Symbolizer symbolizer : symbolizers ) {
            if (symbolizer instanceof LineSymbolizer) {
                lineSymbolizer = (LineSymbolizer) symbolizer;
                break;
            }
        }
        if (lineSymbolizer == null) {
            throw new IllegalArgumentException();
        }
        return lineSymbolizer;
    }
176940
public final Parser<WithSource<T>> withSource() {
    return new Parser<WithSource<T>>() {
      @Override boolean apply(ParseContext ctxt) {
        int begin = ctxt.getIndex();
        if (!Parser.this.apply(ctxt)) {
          return false;
        }
        String source = ctxt.source.subSequence(begin, ctxt.getIndex()).toString();
        @SuppressWarnings("unchecked")
        WithSource<T> withSource = new WithSource<T>((T) ctxt.result, source);
        ctxt.result = withSource;
        return true;
      }
      @Override public String toString() {
        return Parser.this.toString();
      }
    };
  }
1109101
public Iterator<E> iterator() {
        final Iterator<? extends E> itr = core.iterator();
        return new Iterator<E>() {
            private E last;
            public boolean hasNext() {
                return itr.hasNext();
            }

            public E next() {
                return last=itr.next();
            }

            public void remove() {
                CopyOnWriteList.this.remove(last);
            }
        };
    }
911710
public synchronized HTMLEditorKit.Parser getParser() {
        if (parser == null) {
            try {
                Class<?> c = Class.forName("javax.swing.text.html.parser.ParserDelegator");
                parser = (HTMLEditorKit.Parser) c.newInstance();
            } catch (Exception e) {
            }
        }
        return parser;
    }
206078
public Iterator<Tuple> getUsed()
    {
    if( usedChanged_)
      {
      // Order to prefer reuse of larger tuples first. By preferring "intact" tuples over post-reduction singletons,
      // we hope to minimize reoccurrence of once-only tuples.
      Collections.sort( used_, tupleSizeDescending_);
      usedChanged_ = false;
      }
    
    return used_.iterator();
    }
494355
public static PointSymbolizer pointSymbolizerFromRule( Rule rule ) {
        List<Symbolizer> symbolizers = rule.symbolizers();
        PointSymbolizer pointSymbolizer = null;
        for( Symbolizer symbolizer : symbolizers ) {
            if (symbolizer instanceof PointSymbolizer) {
                pointSymbolizer = (PointSymbolizer) symbolizer;
                break;
            }
        }
        if (pointSymbolizer == null) {
            throw new IllegalArgumentException();
        }
        return pointSymbolizer;
    }
199962
public static NlsTemplateResolver getTemplateResolver() {

    if (templateResolver == null) {
      synchronized (NlsAccess.class) {
        if (templateResolver == null) {
          DefaultNlsTemplateResolver resolver = new DefaultNlsTemplateResolver();
          resolver.initialize();
        }
      }
    }
    return templateResolver;
  }
730399
public WikiStyleRenderer getWikiStyleRenderer() {
        if (wikiStyleRenderer != null) {
            return wikiStyleRenderer;
        }
        wikiStyleRenderer = (WikiStyleRenderer) ContainerManager.getComponent("wikiStyleRenderer");
        return wikiStyleRenderer;
    }
964454
public boolean getBracketedToken(char start, char end, TextProvider textProvider)
    {
        clearLastToken(textProvider);
        clearLeadingSpaces(textProvider);
        mark(textProvider);
        if (m_debug)
			debug("testing " + start + " " + end,textProvider);
        StringBuilder sb = new StringBuilder();
        char c = getNextChar(textProvider);

        if (c != start)
        {
            reset(textProvider);
            return false;
        }
        int brackets = 0;

        while (true)
        {
            if (c == start) brackets++;
            if (c == end) brackets--;
            sb.append(c);
            if (brackets < 1) break;
            c = getNextChar(textProvider);
            if (c == 0)
            {
            	reset(textProvider);
				return false;
            }
        }
        unmark(textProvider);
        String s = sb.toString().trim();
        if (s.length() == 0) return false;
        textProvider.setLastToken(s);
        debug(textProvider);
        return true;
    }
421396
public static NameProvider getNameProvider() {
        NameProvider nameProvider = cNameProvider.get();
        if (nameProvider == null) {
            nameProvider = getDefaultNameProvider();
            if (!cNameProvider.compareAndSet(null, nameProvider)) {
                nameProvider = cNameProvider.get();
            }
        }
        return nameProvider;
    }
185991
public  synchronized AnnotationHelper getAnnotationHelper () {

        if (aHelper == null) {
            this.aHelper = new AnnotationHelper(wApp);    
    
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) {
                logger.logp (Level.FINE, CLASS_NAME, "getAnnotationHelper",
                     "created new annotation helper instance --> [" + this.aHelper + "]");
            }
        }
        
        return aHelper;
    }