001
014
015 package com.liferay.portal.util;
016
017 import com.liferay.portal.kernel.io.unsync.UnsyncStringReader;
018 import com.liferay.portal.kernel.io.unsync.UnsyncStringWriter;
019 import com.liferay.portal.kernel.json.JSONObject;
020 import com.liferay.portal.kernel.language.LanguageUtil;
021 import com.liferay.portal.kernel.log.Log;
022 import com.liferay.portal.kernel.log.LogFactoryUtil;
023 import com.liferay.portal.kernel.util.LocaleUtil;
024 import com.liferay.portal.kernel.util.Localization;
025 import com.liferay.portal.kernel.util.ParamUtil;
026 import com.liferay.portal.kernel.util.PortalClassLoaderUtil;
027 import com.liferay.portal.kernel.util.PrefsParamUtil;
028 import com.liferay.portal.kernel.util.StringPool;
029 import com.liferay.portal.kernel.util.StringUtil;
030 import com.liferay.portal.kernel.util.Tuple;
031 import com.liferay.portal.kernel.util.Validator;
032
033 import java.util.HashMap;
034 import java.util.Locale;
035 import java.util.Map;
036
037 import javax.portlet.PortletPreferences;
038 import javax.portlet.PortletRequest;
039
040 import javax.xml.stream.XMLInputFactory;
041 import javax.xml.stream.XMLOutputFactory;
042 import javax.xml.stream.XMLStreamConstants;
043 import javax.xml.stream.XMLStreamException;
044 import javax.xml.stream.XMLStreamReader;
045 import javax.xml.stream.XMLStreamWriter;
046
047 import org.apache.commons.collections.map.ReferenceMap;
048
049
057 public class LocalizationImpl implements Localization {
058
059 public Object deserialize(JSONObject jsonObject) {
060 Locale[] locales = LanguageUtil.getAvailableLocales();
061
062 Map<Locale, String> map = new HashMap<Locale, String>();
063
064 for (Locale locale : locales) {
065 String languageId = LocaleUtil.toLanguageId(locale);
066
067 String value = jsonObject.getString(languageId);
068
069 if (Validator.isNotNull(value)) {
070 map.put(locale, value);
071 }
072 }
073
074 return map;
075 }
076
077 public String[] getAvailableLocales(String xml) {
078 String attributeValue = _getRootAttribute(
079 xml, _AVAILABLE_LOCALES, StringPool.BLANK);
080
081 return StringUtil.split(attributeValue);
082 }
083
084 public String getDefaultLocale(String xml) {
085 String defaultLanguageId = LocaleUtil.toLanguageId(
086 LocaleUtil.getDefault());
087
088 return _getRootAttribute(xml, _DEFAULT_LOCALE, defaultLanguageId);
089 }
090
091 public String getLocalization(String xml, String requestedLanguageId) {
092 return getLocalization(xml, requestedLanguageId, true);
093 }
094
095 public String getLocalization(
096 String xml, String requestedLanguageId, boolean useDefault) {
097
098 String value = _getCachedValue(xml, requestedLanguageId, useDefault);
099
100 if (value != null) {
101 return value;
102 }
103 else {
104 value = StringPool.BLANK;
105 }
106
107 String systemDefaultLanguageId = LocaleUtil.toLanguageId(
108 LocaleUtil.getDefault());
109
110 String priorityLanguageId = null;
111
112 Locale requestedLocale = LocaleUtil.fromLanguageId(requestedLanguageId);
113
114 if (useDefault && LanguageUtil.isDuplicateLanguageCode(
115 requestedLocale.getLanguage())) {
116
117 Locale priorityLocale = LanguageUtil.getLocale(
118 requestedLocale.getLanguage());
119
120 if (!requestedLanguageId.equals(priorityLanguageId)) {
121 priorityLanguageId = LocaleUtil.toLanguageId(priorityLocale);
122 }
123 }
124
125 if (!Validator.isXml(xml)) {
126 if (useDefault ||
127 requestedLanguageId.equals(systemDefaultLanguageId)) {
128
129 value = xml;
130 }
131
132 _setCachedValue(xml, requestedLanguageId, useDefault, value);
133
134 return value;
135 }
136
137 XMLStreamReader xmlStreamReader = null;
138
139 ClassLoader portalClassLoader = PortalClassLoaderUtil.getClassLoader();
140
141 Thread currentThread = Thread.currentThread();
142
143 ClassLoader contextClassLoader = currentThread.getContextClassLoader();
144
145 try {
146 if (contextClassLoader != portalClassLoader) {
147 currentThread.setContextClassLoader(portalClassLoader);
148 }
149
150 XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
151
152 xmlStreamReader = xmlInputFactory.createXMLStreamReader(
153 new UnsyncStringReader(xml));
154
155 String defaultLanguageId = StringPool.BLANK;
156
157
158
159 if (xmlStreamReader.hasNext()) {
160 xmlStreamReader.nextTag();
161
162 defaultLanguageId = xmlStreamReader.getAttributeValue(
163 null, _DEFAULT_LOCALE);
164
165 if (Validator.isNull(defaultLanguageId)) {
166 defaultLanguageId = systemDefaultLanguageId;
167 }
168 }
169
170
171
172 String defaultValue = StringPool.BLANK;
173 String priorityValue = StringPool.BLANK;
174
175 while (xmlStreamReader.hasNext()) {
176 int event = xmlStreamReader.next();
177
178 if (event == XMLStreamConstants.START_ELEMENT) {
179 String languageId = xmlStreamReader.getAttributeValue(
180 null, _LANGUAGE_ID);
181
182 if (Validator.isNull(languageId)) {
183 languageId = defaultLanguageId;
184 }
185
186 if (languageId.equals(defaultLanguageId) ||
187 languageId.equals(priorityLanguageId) ||
188 languageId.equals(requestedLanguageId)) {
189
190 String text = xmlStreamReader.getElementText();
191
192 if (languageId.equals(defaultLanguageId)) {
193 defaultValue = text;
194 }
195
196 if (languageId.equals(priorityLanguageId)) {
197 priorityValue = text;
198 }
199
200 if (languageId.equals(requestedLanguageId)) {
201 value = text;
202 }
203
204 if (Validator.isNotNull(value)) {
205 break;
206 }
207 }
208 }
209 else if (event == XMLStreamConstants.END_DOCUMENT) {
210 break;
211 }
212 }
213
214 if (useDefault && Validator.isNotNull(priorityLanguageId) &&
215 Validator.isNull(value) && Validator.isNotNull(priorityValue)) {
216
217 value = priorityValue;
218 }
219
220 if (useDefault && Validator.isNull(value)) {
221 value = defaultValue;
222 }
223 }
224 catch (Exception e) {
225 if (_log.isWarnEnabled()) {
226 _log.warn(e, e);
227 }
228 }
229 finally {
230 if (contextClassLoader != portalClassLoader) {
231 currentThread.setContextClassLoader(contextClassLoader);
232 }
233
234 if (xmlStreamReader != null) {
235 try {
236 xmlStreamReader.close();
237 }
238 catch (Exception e) {
239 }
240 }
241 }
242
243 _setCachedValue(xml, requestedLanguageId, useDefault, value);
244
245 return value;
246 }
247
248 public Map<Locale, String> getLocalizationMap(
249 PortletPreferences preferences, String parameter) {
250
251 Locale[] locales = LanguageUtil.getAvailableLocales();
252
253 Map<Locale, String> map = new HashMap<Locale, String>();
254
255 for (Locale locale : locales) {
256 String languageId = LocaleUtil.toLanguageId(locale);
257
258 String localeParameter = parameter.concat(
259 StringPool.UNDERLINE).concat(languageId);
260
261 map.put(
262 locale,
263 preferences.getValue(localeParameter, StringPool.BLANK));
264 }
265
266 return map;
267 }
268
269 public Map<Locale, String> getLocalizationMap(
270 PortletRequest portletRequest, String parameter) {
271
272 Locale[] locales = LanguageUtil.getAvailableLocales();
273
274 Map<Locale, String> map = new HashMap<Locale, String>();
275
276 for (Locale locale : locales) {
277 String languageId = LocaleUtil.toLanguageId(locale);
278
279 String localeParameter = parameter.concat(
280 StringPool.UNDERLINE).concat(languageId);
281
282 map.put(
283 locale, ParamUtil.getString(portletRequest, localeParameter));
284 }
285
286 return map;
287 }
288
289 public Map<Locale, String> getLocalizationMap(String xml) {
290 Locale[] locales = LanguageUtil.getAvailableLocales();
291
292 Map<Locale, String> map = new HashMap<Locale, String>();
293
294 for (Locale locale : locales) {
295 String languageId = LocaleUtil.toLanguageId(locale);
296
297 map.put(locale, getLocalization(xml, languageId, false));
298 }
299
300 return map;
301 }
302
303 public String getLocalizationXmlFromPreferences(
304 PortletPreferences preferences, PortletRequest portletRequest,
305 String parameter) {
306
307 String xml = StringPool.BLANK;
308
309 Locale[] locales = LanguageUtil.getAvailableLocales();
310 Locale defaultLocale = LocaleUtil.getDefault();
311 String defaultLanguageId = LocaleUtil.toLanguageId(defaultLocale);
312
313 for (Locale locale : locales) {
314 String languageId = LocaleUtil.toLanguageId(locale);
315
316 String localParameter =
317 parameter + StringPool.UNDERLINE + languageId;
318
319 String value = PrefsParamUtil.getString(
320 preferences, portletRequest, localParameter);
321
322 if (Validator.isNotNull(value)) {
323 xml = updateLocalization(xml, parameter, value, languageId);
324 }
325 }
326
327 if (Validator.isNull(getLocalization(xml, defaultLanguageId))) {
328 String oldValue = PrefsParamUtil.getString(
329 preferences, portletRequest, parameter);
330
331 if (Validator.isNotNull(oldValue)) {
332 xml = updateLocalization(xml, parameter, oldValue);
333 }
334 }
335
336 return xml;
337 }
338
339 public Map<Locale, String> getLocalizedParameter(
340 PortletRequest portletRequest, String parameter) {
341
342 return getLocalizationMap(portletRequest, parameter);
343 }
344
345 public String getPreferencesKey(String key, String languageId) {
346 String defaultLanguageId = LocaleUtil.toLanguageId(
347 LocaleUtil.getDefault());
348
349 if (!languageId.equals(defaultLanguageId)) {
350 key += StringPool.UNDERLINE + languageId;
351 }
352
353 return key;
354 }
355
356 public String getPreferencesValue(
357 PortletPreferences preferences, String key, String languageId) {
358
359 return getPreferencesValue(preferences, key, languageId, true);
360 }
361
362 public String getPreferencesValue(
363 PortletPreferences preferences, String key, String languageId,
364 boolean useDefault) {
365
366 String localizedKey = getPreferencesKey(key, languageId);
367
368 String value = preferences.getValue(localizedKey, StringPool.BLANK);
369
370 if (useDefault && Validator.isNull(value)) {
371 value = preferences.getValue(key, StringPool.BLANK);
372 }
373
374 return value;
375 }
376
377 public String[] getPreferencesValues(
378 PortletPreferences preferences, String key, String languageId) {
379
380 return getPreferencesValues(preferences, key, languageId, true);
381 }
382
383 public String[] getPreferencesValues(
384 PortletPreferences preferences, String key, String languageId,
385 boolean useDefault) {
386
387 String localizedKey = getPreferencesKey(key, languageId);
388
389 String[] values = preferences.getValues(localizedKey, new String[0]);
390
391 if (useDefault && Validator.isNull(values)) {
392 values = preferences.getValues(key, new String[0]);
393 }
394
395 return values;
396 }
397
398 public String removeLocalization(
399 String xml, String key, String requestedLanguageId) {
400
401 return removeLocalization(xml, key, requestedLanguageId, false);
402 }
403
404 public String removeLocalization(
405 String xml, String key, String requestedLanguageId, boolean cdata) {
406
407 return removeLocalization(xml, key, requestedLanguageId, cdata, true);
408 }
409
410 public String removeLocalization(
411 String xml, String key, String requestedLanguageId, boolean cdata,
412 boolean localized) {
413
414 if (Validator.isNull(xml)) {
415 return StringPool.BLANK;
416 }
417
418 xml = _sanitizeXML(xml);
419
420 String systemDefaultLanguageId = LocaleUtil.toLanguageId(
421 LocaleUtil.getDefault());
422
423 XMLStreamReader xmlStreamReader = null;
424 XMLStreamWriter xmlStreamWriter = null;
425
426 ClassLoader portalClassLoader = PortalClassLoaderUtil.getClassLoader();
427
428 Thread currentThread = Thread.currentThread();
429
430 ClassLoader contextClassLoader = currentThread.getContextClassLoader();
431
432 try {
433 if (contextClassLoader != portalClassLoader) {
434 currentThread.setContextClassLoader(portalClassLoader);
435 }
436
437 XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
438
439 xmlStreamReader = xmlInputFactory.createXMLStreamReader(
440 new UnsyncStringReader(xml));
441
442 String availableLocales = StringPool.BLANK;
443 String defaultLanguageId = StringPool.BLANK;
444
445
446
447 if (xmlStreamReader.hasNext()) {
448 xmlStreamReader.nextTag();
449
450 availableLocales = xmlStreamReader.getAttributeValue(
451 null, _AVAILABLE_LOCALES);
452 defaultLanguageId = xmlStreamReader.getAttributeValue(
453 null, _DEFAULT_LOCALE);
454
455 if (Validator.isNull(defaultLanguageId)) {
456 defaultLanguageId = systemDefaultLanguageId;
457 }
458 }
459
460 if ((availableLocales != null) &&
461 (availableLocales.indexOf(requestedLanguageId) != -1)) {
462
463 availableLocales = StringUtil.remove(
464 availableLocales, requestedLanguageId, StringPool.COMMA);
465
466 UnsyncStringWriter unsyncStringWriter =
467 new UnsyncStringWriter();
468
469 XMLOutputFactory xmlOutputFactory =
470 XMLOutputFactory.newInstance();
471
472 xmlStreamWriter = xmlOutputFactory.createXMLStreamWriter(
473 unsyncStringWriter);
474
475 xmlStreamWriter.writeStartDocument();
476 xmlStreamWriter.writeStartElement(_ROOT);
477
478 if (localized) {
479 xmlStreamWriter.writeAttribute(
480 _AVAILABLE_LOCALES, availableLocales);
481 xmlStreamWriter.writeAttribute(
482 _DEFAULT_LOCALE, defaultLanguageId);
483 }
484
485 _copyNonExempt(
486 xmlStreamReader, xmlStreamWriter, requestedLanguageId,
487 defaultLanguageId, cdata);
488
489 xmlStreamWriter.writeEndElement();
490 xmlStreamWriter.writeEndDocument();
491
492 xmlStreamWriter.close();
493 xmlStreamWriter = null;
494
495 xml = unsyncStringWriter.toString();
496 }
497 }
498 catch (Exception e) {
499 if (_log.isWarnEnabled()) {
500 _log.warn(e, e);
501 }
502 }
503 finally {
504 if (contextClassLoader != portalClassLoader) {
505 currentThread.setContextClassLoader(contextClassLoader);
506 }
507
508 if (xmlStreamReader != null) {
509 try {
510 xmlStreamReader.close();
511 }
512 catch (Exception e) {
513 }
514 }
515
516 if (xmlStreamWriter != null) {
517 try {
518 xmlStreamWriter.close();
519 }
520 catch (Exception e) {
521 }
522 }
523 }
524
525 return xml;
526 }
527
528 public void setLocalizedPreferencesValues (
529 PortletRequest portletRequest, PortletPreferences preferences,
530 String parameter)
531 throws Exception {
532
533 Map<Locale, String> map = getLocalizationMap(
534 portletRequest, parameter);
535
536 for (Map.Entry<Locale, String> entry : map.entrySet()) {
537 String languageId = LocaleUtil.toLanguageId(entry.getKey());
538 String value = entry.getValue();
539
540 setPreferencesValue(preferences, parameter, languageId, value);
541 }
542 }
543
544 public void setPreferencesValue(
545 PortletPreferences preferences, String key, String languageId,
546 String value)
547 throws Exception {
548
549 preferences.setValue(getPreferencesKey(key, languageId), value);
550 }
551
552 public void setPreferencesValues(
553 PortletPreferences preferences, String key, String languageId,
554 String[] values)
555 throws Exception {
556
557 preferences.setValues(getPreferencesKey(key, languageId), values);
558 }
559
560 public String updateLocalization(String xml, String key, String value) {
561 String defaultLanguageId = LocaleUtil.toLanguageId(
562 LocaleUtil.getDefault());
563
564 return updateLocalization(
565 xml, key, value, defaultLanguageId, defaultLanguageId);
566 }
567
568 public String updateLocalization(
569 String xml, String key, String value, String requestedLanguageId) {
570
571 String defaultLanguageId = LocaleUtil.toLanguageId(
572 LocaleUtil.getDefault());
573
574 return updateLocalization(
575 xml, key, value, requestedLanguageId, defaultLanguageId);
576 }
577
578 public String updateLocalization(
579 String xml, String key, String value, String requestedLanguageId,
580 String defaultLanguageId) {
581
582 return updateLocalization(
583 xml, key, value, requestedLanguageId, defaultLanguageId, false);
584 }
585
586 public String updateLocalization(
587 String xml, String key, String value, String requestedLanguageId,
588 String defaultLanguageId, boolean cdata) {
589
590 return updateLocalization(
591 xml, key, value, requestedLanguageId, defaultLanguageId, cdata,
592 true);
593 }
594
595 public String updateLocalization(
596 String xml, String key, String value, String requestedLanguageId,
597 String defaultLanguageId, boolean cdata, boolean localized) {
598
599 xml = _sanitizeXML(xml);
600
601 XMLStreamReader xmlStreamReader = null;
602 XMLStreamWriter xmlStreamWriter = null;
603
604 ClassLoader portalClassLoader = PortalClassLoaderUtil.getClassLoader();
605
606 Thread currentThread = Thread.currentThread();
607
608 ClassLoader contextClassLoader = currentThread.getContextClassLoader();
609
610 try {
611 if (contextClassLoader != portalClassLoader) {
612 currentThread.setContextClassLoader(portalClassLoader);
613 }
614
615 XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
616
617 xmlStreamReader = xmlInputFactory.createXMLStreamReader(
618 new UnsyncStringReader(xml));
619
620 String availableLocales = StringPool.BLANK;
621
622
623
624 if (xmlStreamReader.hasNext()) {
625 xmlStreamReader.nextTag();
626
627 availableLocales = xmlStreamReader.getAttributeValue(
628 null, _AVAILABLE_LOCALES);
629
630 if (Validator.isNull(availableLocales)) {
631 availableLocales = defaultLanguageId;
632 }
633
634 if (availableLocales.indexOf(requestedLanguageId) == -1) {
635 availableLocales = StringUtil.add(
636 availableLocales, requestedLanguageId,
637 StringPool.COMMA);
638 }
639 }
640
641 UnsyncStringWriter unsyncStringWriter = new UnsyncStringWriter();
642
643 XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance();
644
645 xmlStreamWriter = xmlOutputFactory.createXMLStreamWriter(
646 unsyncStringWriter);
647
648 xmlStreamWriter.writeStartDocument();
649 xmlStreamWriter.writeStartElement(_ROOT);
650
651 if (localized) {
652 xmlStreamWriter.writeAttribute(
653 _AVAILABLE_LOCALES, availableLocales);
654 xmlStreamWriter.writeAttribute(
655 _DEFAULT_LOCALE, defaultLanguageId);
656 }
657
658 _copyNonExempt(
659 xmlStreamReader, xmlStreamWriter, requestedLanguageId,
660 defaultLanguageId, cdata);
661
662 xmlStreamWriter.writeStartElement(key);
663
664 if (localized) {
665 xmlStreamWriter.writeAttribute(
666 _LANGUAGE_ID, requestedLanguageId);
667 }
668
669 if (cdata) {
670 xmlStreamWriter.writeCData(value);
671 }
672 else {
673 xmlStreamWriter.writeCharacters(value);
674 }
675
676 xmlStreamWriter.writeEndElement();
677 xmlStreamWriter.writeEndElement();
678 xmlStreamWriter.writeEndDocument();
679
680 xmlStreamWriter.close();
681 xmlStreamWriter = null;
682
683 xml = unsyncStringWriter.toString();
684 }
685 catch (Exception e) {
686 if (_log.isWarnEnabled()) {
687 _log.warn(e, e);
688 }
689 }
690 finally {
691 if (contextClassLoader != portalClassLoader) {
692 currentThread.setContextClassLoader(contextClassLoader);
693 }
694
695 if (xmlStreamReader != null) {
696 try {
697 xmlStreamReader.close();
698 }
699 catch (Exception e) {
700 }
701 }
702
703 if (xmlStreamWriter != null) {
704 try {
705 xmlStreamWriter.close();
706 }
707 catch (Exception e) {
708 }
709 }
710 }
711
712 return xml;
713 }
714
715 private void _copyNonExempt(
716 XMLStreamReader xmlStreamReader, XMLStreamWriter xmlStreamWriter,
717 String exemptLanguageId, String defaultLanguageId, boolean cdata)
718 throws XMLStreamException {
719
720 while (xmlStreamReader.hasNext()) {
721 int event = xmlStreamReader.next();
722
723 if (event == XMLStreamConstants.START_ELEMENT) {
724 String languageId = xmlStreamReader.getAttributeValue(
725 null, _LANGUAGE_ID);
726
727 if (Validator.isNull(languageId)) {
728 languageId = defaultLanguageId;
729 }
730
731 if (!languageId.equals(exemptLanguageId)) {
732 xmlStreamWriter.writeStartElement(
733 xmlStreamReader.getLocalName());
734 xmlStreamWriter.writeAttribute(_LANGUAGE_ID, languageId);
735
736 while (xmlStreamReader.hasNext()) {
737 event = xmlStreamReader.next();
738
739 if ((event == XMLStreamConstants.CHARACTERS) ||
740 (event == XMLStreamConstants.CDATA)) {
741
742 String text = xmlStreamReader.getText();
743
744 if (cdata) {
745 xmlStreamWriter.writeCData(text);
746 }
747 else {
748 xmlStreamWriter.writeCharacters(
749 xmlStreamReader.getText());
750 }
751
752 break;
753 }
754 else if (event == XMLStreamConstants.END_ELEMENT) {
755 break;
756 }
757 }
758
759 xmlStreamWriter.writeEndElement();
760 }
761 }
762 else if (event == XMLStreamConstants.END_DOCUMENT) {
763 break;
764 }
765 }
766 }
767
768 private String _getCachedValue(
769 String xml, String requestedLanguageId, boolean useDefault) {
770
771 String value = null;
772
773 Map<Tuple, String> valueMap = _cache.get(xml);
774
775 if (valueMap != null) {
776 Tuple subkey = new Tuple(useDefault, requestedLanguageId);
777
778 value = valueMap.get(subkey);
779 }
780
781 return value;
782 }
783
784 private String _getRootAttribute(
785 String xml, String name, String defaultValue) {
786
787 String value = null;
788
789 XMLStreamReader xmlStreamReader = null;
790
791 ClassLoader portalClassLoader = PortalClassLoaderUtil.getClassLoader();
792
793 Thread currentThread = Thread.currentThread();
794
795 ClassLoader contextClassLoader = currentThread.getContextClassLoader();
796
797 try {
798 if (contextClassLoader != portalClassLoader) {
799 currentThread.setContextClassLoader(portalClassLoader);
800 }
801
802 XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
803
804 xmlStreamReader = xmlInputFactory.createXMLStreamReader(
805 new UnsyncStringReader(xml));
806
807 if (xmlStreamReader.hasNext()) {
808 xmlStreamReader.nextTag();
809
810 value = xmlStreamReader.getAttributeValue(null, name);
811 }
812 }
813 catch (Exception e) {
814 if (_log.isWarnEnabled()) {
815 _log.warn(e, e);
816 }
817 }
818 finally {
819 if (contextClassLoader != portalClassLoader) {
820 currentThread.setContextClassLoader(contextClassLoader);
821 }
822
823 if (xmlStreamReader != null) {
824 try {
825 xmlStreamReader.close();
826 }
827 catch (Exception e) {
828 }
829 }
830 }
831
832 if (Validator.isNull(value)) {
833 value = defaultValue;
834 }
835
836 return value;
837 }
838
839 private String _sanitizeXML(String xml) {
840 if (Validator.isNull(xml) || (xml.indexOf("<root") == -1)) {
841 xml = _EMPTY_ROOT_NODE;
842 }
843
844 return xml;
845 }
846
847 private void _setCachedValue(
848 String xml, String requestedLanguageId, boolean useDefault,
849 String value) {
850
851 if (Validator.isNotNull(xml) && !xml.equals(_EMPTY_ROOT_NODE)) {
852 synchronized (_cache) {
853 Map<Tuple, String> map = _cache.get(xml);
854
855 if (map == null) {
856 map = new HashMap<Tuple, String>();
857 }
858
859 Tuple subkey = new Tuple(useDefault, requestedLanguageId);
860
861 map.put(subkey, value);
862
863 _cache.put(xml, map);
864 }
865 }
866 }
867
868 private static final String _AVAILABLE_LOCALES = "available-locales";
869
870 private static final String _DEFAULT_LOCALE = "default-locale";
871
872 private static final String _EMPTY_ROOT_NODE = "<root />";
873
874 private static final String _LANGUAGE_ID = "language-id";
875
876 private static final String _ROOT = "root";
877
878 private static Log _log = LogFactoryUtil.getLog(LocalizationImpl.class);
879
880 private Map<String, Map<Tuple, String>> _cache = new ReferenceMap(
881 ReferenceMap.SOFT, ReferenceMap.HARD);
882
883 }