001: /*
002:
003: This software is OSI Certified Open Source Software.
004: OSI Certified is a certification mark of the Open Source Initiative.
005:
006: The license (Mozilla version 1.0) can be read at the MMBase site.
007: See http://www.MMBase.org/license
008:
009: */
010: package org.mmbase.util;
011:
012: import java.util.*;
013: import org.mmbase.util.logging.*;
014:
015: /**
016: * Extends and wraps LocalizedString. It extends to look like a 'normal' LocalizedString, but it
017: * overrides 'get' to do token-replacements first.
018: *
019: * This functionality is not in LocalizedString itself, because now you can have different
020: * replacements on the same value set represented by a LocalizedString withouth having to copy
021: * everything every time.
022: *
023: *
024: * @author Michiel Meeuwissen
025: * @version $Id: ReplacingLocalizedString.java,v 1.6 2007/02/24 21:57:50 nklasens Exp $
026: * @since MMBase-1.8
027: */
028: public class ReplacingLocalizedString extends WrappedLocalizedString {
029:
030: private static final Logger log = Logging
031: .getLoggerInstance(ReplacingLocalizedString.class);
032:
033: private List<Map.Entry<String, String>> replacements = new ArrayList<Map.Entry<String, String>>();
034:
035: // just for the contract of Serializable
036: protected ReplacingLocalizedString() {
037:
038: }
039:
040: /**
041: * @param s The wrapped LocalizedString.
042: */
043: public ReplacingLocalizedString(LocalizedString s) {
044: super (s);
045: }
046:
047: public void replaceAll(String regexp, String replacement) {
048: replacements
049: .add(new Entry<String, String>(regexp, replacement));
050: }
051:
052: protected String replace(String input) {
053: String output = input;
054: for (Map.Entry<String, String> entry : replacements) {
055: try {
056: output = output.replaceAll(entry.getKey(), entry
057: .getValue());
058: } catch (Throwable t) {
059: log.warn("Could not replace " + entry + " in " + input
060: + " because " + t);
061: }
062: }
063: return output;
064: }
065:
066: // javadoc inherited
067: public String get(Locale locale) {
068: return replace(super .get(locale));
069: }
070:
071: /**
072: * {@inheritDoc}
073: *
074: * Also takes into account the replacements in the values (but only 'lazily', when actually requested).
075: */
076: public Map<Locale, String> asMap() {
077: final Map<Locale, String> map = super .asMap();
078: return new AbstractMap<Locale, String>() {
079: public Set<Map.Entry<Locale, String>> entrySet() {
080: return new AbstractSet<Map.Entry<Locale, String>>() {
081: public int size() {
082: return map.size();
083: }
084:
085: public Iterator<Map.Entry<Locale, String>> iterator() {
086: final Iterator<Map.Entry<Locale, String>> it = map
087: .entrySet().iterator();
088: return new Iterator<Map.Entry<Locale, String>>() {
089: public boolean hasNext() {
090: return it.hasNext();
091: }
092:
093: public Map.Entry<Locale, String> next() {
094: final Map.Entry<Locale, String> value = it
095: .next();
096: return new Map.Entry<Locale, String>() {
097: public Locale getKey() {
098: return value.getKey();
099: }
100:
101: public String getValue() {
102: return replace(value.getValue());
103: }
104:
105: public String setValue(String v) {
106: throw new UnsupportedOperationException(); // map is umodifiable
107: }
108: };
109: }
110:
111: public void remove() {
112: throw new UnsupportedOperationException(); // map is umodifiable
113: }
114: };
115: }
116: };
117: }
118: };
119: }
120:
121: @SuppressWarnings("unchecked")
122: public Object clone() {
123: ReplacingLocalizedString clone = (ReplacingLocalizedString) super
124: .clone();
125: clone.replacements = (List) ((ArrayList) replacements).clone();
126: return clone;
127:
128: }
129:
130: /**
131: * Utility method for second argument of replaceAll
132: */
133: public static String makeLiteral(String s) {
134: // sometimes, implementing java looks rather idiotic, but honestely, this is correct!
135: s = s.replaceAll("\\\\", "\\\\\\\\");
136: return s.replaceAll("\\$", "\\\\\\$");
137: }
138:
139: public static void main(String argv[]) {
140: ReplacingLocalizedString s = new ReplacingLocalizedString(
141: new LocalizedString("abcd"));
142: s.replaceAll("b", makeLiteral(argv[0]));
143: System.out.println(s.get((Locale) null));
144: }
145:
146: }
|