1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   * 
13   */
14  
15  package com.liferay.portal.util;
16  
17  import com.liferay.portal.kernel.log.Log;
18  import com.liferay.portal.kernel.log.LogFactoryUtil;
19  import com.liferay.portal.kernel.util.StringPool;
20  import com.liferay.portal.kernel.xml.Element;
21  import com.liferay.portal.kernel.xml.Namespace;
22  
23  import java.util.Map;
24  import java.util.concurrent.ConcurrentHashMap;
25  
26  import javax.xml.namespace.QName;
27  
28  /**
29   * <a href="QNameUtil.java.html"><b><i>View Source</i></b></a>
30   *
31   * @author Brian Wing Shun Chan
32   */
33  public class QNameUtil {
34  
35      public static final String PUBLIC_RENDER_PARAMETER_NAMESPACE = "p_r_p_";
36  
37      public static final String REMOVE_PUBLIC_RENDER_PARAMETER_NAMESPACE =
38          "r_p_r_p";
39  
40      public static String getKey(QName qName) {
41          return getKey(qName.getNamespaceURI(), qName.getLocalPart());
42      }
43  
44      public static String getKey(String uri, String localPart) {
45          StringBuilder sb = new StringBuilder();
46  
47          sb.append(uri);
48          sb.append(_KEY_SEPARATOR);
49          sb.append(localPart);
50  
51          return sb.toString();
52      }
53  
54      public static String getPublicRenderParameterIdentifier(
55          String publicRenderParameterName) {
56  
57          return _instance._getPublicRenderParameterIdentifier(
58              publicRenderParameterName);
59      }
60  
61      public static String getPublicRenderParameterName(QName qName) {
62          return _instance._getPublicRenderParameterName(qName);
63      }
64  
65      public static QName getQName(String publicRenderParameterName) {
66          return _instance._getQName(publicRenderParameterName);
67      }
68  
69      public static QName getQName(
70          Element qNameEl, Element nameEl, String defaultNamespace) {
71  
72          if ((qNameEl == null) && (nameEl == null)) {
73              _log.error("both qname and name elements are null");
74  
75              return null;
76          }
77  
78          if (qNameEl == null) {
79              return new QName(defaultNamespace, nameEl.getTextTrim());
80          }
81  
82          String localPart = qNameEl.getTextTrim();
83  
84          int pos = localPart.indexOf(StringPool.COLON);
85  
86          if (pos == -1) {
87              if (_log.isDebugEnabled()) {
88                  _log.debug("qname " + localPart + " does not have a prefix");
89              }
90  
91              return new QName(localPart);
92          }
93  
94          String prefix = localPart.substring(0, pos);
95  
96          Namespace namespace = qNameEl.getNamespaceForPrefix(prefix);
97  
98          if (namespace == null) {
99              if (_log.isWarnEnabled()) {
100                 _log.warn(
101                     "qname " + localPart + " does not have a valid namespace");
102             }
103 
104             return null;
105         }
106 
107         String uri = namespace.getURI();
108 
109         localPart = localPart.substring(prefix.length() + 1);
110 
111         return new QName(uri, localPart, prefix);
112     }
113 
114     public static String getRemovePublicRenderParameterName(QName qName) {
115         return _instance._getRemovePublicRenderParameterName(qName);
116     }
117 
118     public static void setPublicRenderParameterIdentifier(
119         String publicRenderParameterName, String identifier) {
120 
121         _instance._setPublicRenderParameterIdentifier(
122             publicRenderParameterName, identifier);
123     }
124 
125     private QNameUtil() {
126         _qNames = new ConcurrentHashMap<String, QName>();
127         _identifiers = new ConcurrentHashMap<String, String>();
128     }
129 
130     private String _getPublicRenderParameterIdentifier(
131         String publicRenderParameterName) {
132 
133         if (!publicRenderParameterName.startsWith(
134                 PUBLIC_RENDER_PARAMETER_NAMESPACE) &&
135             !publicRenderParameterName.startsWith(
136                 REMOVE_PUBLIC_RENDER_PARAMETER_NAMESPACE)) {
137 
138             return null;
139         }
140 
141         return _identifiers.get(publicRenderParameterName);
142     }
143 
144     private String _getPublicRenderParameterName(QName qName) {
145         StringBuilder sb = new StringBuilder();
146 
147         sb.append(PUBLIC_RENDER_PARAMETER_NAMESPACE);
148         sb.append(qName.getNamespaceURI().hashCode());
149         sb.append(StringPool.UNDERLINE);
150         sb.append(qName.getLocalPart());
151 
152         String publicRenderParameterName = sb.toString();
153 
154         if (!_qNames.containsKey(publicRenderParameterName)) {
155             _qNames.put(publicRenderParameterName, qName);
156         }
157 
158         return publicRenderParameterName;
159     }
160 
161     private QName _getQName(String publicRenderParameterName) {
162         if (!publicRenderParameterName.startsWith(
163                 PUBLIC_RENDER_PARAMETER_NAMESPACE) &&
164             !publicRenderParameterName.startsWith(
165                 REMOVE_PUBLIC_RENDER_PARAMETER_NAMESPACE)) {
166 
167             return null;
168         }
169 
170         return _qNames.get(publicRenderParameterName);
171     }
172 
173     private String _getRemovePublicRenderParameterName(QName qName) {
174         StringBuilder sb = new StringBuilder();
175 
176         sb.append(REMOVE_PUBLIC_RENDER_PARAMETER_NAMESPACE);
177         sb.append(qName.getNamespaceURI().hashCode());
178         sb.append(StringPool.UNDERLINE);
179         sb.append(qName.getLocalPart());
180 
181         String removePublicRenderParameterName = sb.toString();
182 
183         if (!_qNames.containsKey(removePublicRenderParameterName)) {
184             _qNames.put(removePublicRenderParameterName, qName);
185         }
186 
187         return removePublicRenderParameterName;
188     }
189 
190     private void _setPublicRenderParameterIdentifier(
191         String publicRenderParameterName, String identifier) {
192 
193         _identifiers.put(publicRenderParameterName, identifier);
194     }
195 
196     private static final String _KEY_SEPARATOR = "_KEY_";
197 
198     private static Log _log = LogFactoryUtil.getLog(QNameUtil.class);
199 
200     private static QNameUtil _instance = new QNameUtil();
201 
202     private Map<String, QName> _qNames;
203     private Map<String, String> _identifiers;
204 
205 }