Namespaces


1   /*
2    * Copyright 2001-2004 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.axis.wsdl.toJava;
17  
18  import org.apache.axis.utils.JavaUtils;
19  
20  import java.io.File  ;
21  import java.util.HashMap  ;
22  import java.util.Iterator  ;
23  import java.util.Map  ;
24  import java.util.StringTokenizer  ;
25  import java.util.Vector  ;
26  
27  /**
28   * This class is essentially a HashMap of <namespace, package name> pairs with
29   * a few extra wizzbangs.
30   */
31  public class Namespaces extends HashMap   {
32  
33      /** Field root */
34      private String   root;
35  
36      /** Field defaultPackage */
37      private String   defaultPackage = null;
38  
39      /** Toknens in a namespace that are treated as package name part separators. */
40      private static final char[] pkgSeparators = {'.', ':'};
41  
42      /** Field javaPkgSeparator */
43      private static final char javaPkgSeparator = pkgSeparators[0];
44      
45      /** Field pkg2Namespaces : reverse mapping of Namespaces */
46      private Map   pkg2NamespacesMap = new HashMap  ();
47  
48      /**
49       * Method normalizePackageName
50       * 
51       * @param pkg       
52       * @param separator 
53       * @return 
54       */
55      private static String   normalizePackageName(String   pkg, char separator) {
56  
57          for (int i = 0; i < pkgSeparators.length; i++) {
58              pkg = pkg.replace(pkgSeparators[i], separator);
59          }
60  
61          return pkg;
62      }
63  
64      /**
65       * Instantiate a Namespaces object whose packages will all reside under root.
66       * 
67       * @param root 
68       */
69      public Namespaces(String   root) {
70  
71          super();
72  
73          this.root = root;
74      }    // ctor
75  
76      /**
77       * Instantiate a clone of an existing Namespaces object.
78       * 
79       * @param clone 
80       */
81      private Namespaces(Namespaces clone) {
82  
83          super(clone);
84  
85          this.root = clone.root;
86          this.defaultPackage = clone.defaultPackage;
87      }    // ctor
88  
89      /**
90       * Instantiate a clone of this Namespaces object.
91       * 
92       * @return 
93       */
94      public Object   clone() {
95          return new Namespaces(this);
96      }    // clone
97  
98      /**
99       * Get the package name for the given namespace.  If there is no entry in the HashMap for
100      * this namespace, create one.
101      * 
102      * @param key 
103      * @return 
104      */
105     public String   getCreate(String   key) {
106         return getCreate(key, true);
107     }    // getCreate
108 
109     /**
110      * Get the package name for the given namespace.  If there is no entry in the HashMap for
111      * this namespace, create one if create flag is on, return <tt>null</tt> otherwise.
112      * 
113      * @param key    
114      * @param create 
115      * @return 
116      */
117     String   getCreate(String   key, boolean create) {
118 
119         if (defaultPackage != null) {
120             put(key, defaultPackage);
121             return defaultPackage;
122         }
123 
124         String   value = (String  ) super.get(key);
125 
126         if ((value == null) && create) {
127             value = normalizePackageName((String  ) Utils.makePackageName(key),
128                     javaPkgSeparator);
129 
130             put(key, value);
131         }
132 
133         return (String  ) value;
134     }    // getCreate
135 
136     /**
137      * Get the package name in directory format (dots replaced by slashes).  If the package name
138      * doesn't exist in the HashMap, return "".
139      * 
140      * @param key 
141      * @return 
142      */
143     public String   getAsDir(String   key) {
144 
145         if (defaultPackage != null) {
146             return toDir(defaultPackage);
147         }
148 
149         String   pkg = (String  ) get(key);
150 
151         return toDir(pkg);
152     }    // getAsDir
153 
154     /**
155      * Return the given package name in directory format (dots replaced by slashes).  If pkg is null,
156      * "" is returned.
157      * 
158      * @param pkg 
159      * @return 
160      */
161     public String   toDir(String   pkg) {
162 
163         String   dir = null;
164 
165         if (pkg != null) {
166             pkg = normalizePackageName(pkg, File.separatorChar);
167         }
168 
169         if (root == null) {
170             dir = pkg;
171         } else {
172             dir = root + File.separatorChar + pkg;
173         }
174 
175         return (dir == null)
176                 ? ""
177                 : dir + File.separatorChar;
178     }    // toDir
179 
180     /**
181      * Like HashMap's putAll, this adds the given map's contents to this map.  But it
182      * also makes sure the value strings are javified.
183      * 
184      * @param map 
185      */
186     public void putAll(Map   map) {
187 
188         Iterator   i = map.entrySet().iterator();
189 
190         while (i.hasNext()) {
191             Map.Entry   entry = (Map.Entry  ) i.next();
192             Object   key = entry.getKey();
193             String   pkg = (String  ) entry.getValue();
194 
195             pkg = javify(pkg);
196 
197             put(key, pkg);
198         }
199     }    // putAll
200 
201     /**
202      * Make sure each package name doesn't conflict with a Java keyword.
203      * Ie., org.apache.import.test becomes org.apache.import_.test.
204      * 
205      * @param pkg 
206      * @return 
207      */
208     private String   javify(String   pkg) {
209 
210         StringTokenizer   st = new StringTokenizer  (pkg, ".");
211 
212         pkg = "";
213 
214         while (st.hasMoreTokens()) {
215             String   token = st.nextToken();
216 
217             if (JavaUtils.isJavaKeyword(token)) {
218                 token = JavaUtils.makeNonJavaKeyword(token);
219             }
220 
221             pkg = pkg + token;
222 
223             if (st.hasMoreTokens()) {
224                 pkg = pkg + '.';
225             }
226         }
227 
228         return pkg;
229     }    // javify
230 
231     /**
232      * Make a directory for the given package under root.
233      * 
234      * @param pkg 
235      */
236     public void mkdir(String   pkg) {
237 
238         String   pkgDirString = toDir(pkg);
239         File   packageDir = new File  (pkgDirString);
240 
241         packageDir.mkdirs();
242     }    // mkdir
243 
244     /**
245      * Set a package name that overrides the namespace map
246      * 
247      * @param defaultPackage a java package name (e.g. com.foo)
248      */
249     public void setDefaultPackage(String   defaultPackage) {
250         this.defaultPackage = defaultPackage;
251     }
252     
253     public Object   put(Object   key, Object   value) {
254         // Store pakcage->namespaces vector mapping
255         Vector   v = null;
256         if (!pkg2NamespacesMap.containsKey(value)) {
257             v = new Vector  ();                       
258         } else {
259             v = (Vector  )pkg2NamespacesMap.get(value);
260         }
261         // NOT need to add an input key (namespace value) to v (package vector) 
262         if (!v.contains(key)) { 
263             v.add(key); 
264         }
265         pkg2NamespacesMap.put(value, v);
266          
267         return super.put(key, value);
268     }
269     
270     public Map   getPkg2NamespacesMap() {
271         return pkg2NamespacesMap;
272     }
273 }    // class Namespaces
274
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags