1:
37:
38: package ;
39:
40: import ;
41: import ;
42: import ;
43: import ;
44: import ;
45:
46: import ;
47:
48: import ;
49:
50:
55: public class NodeWriter {
56:
57:
58: private final Preferences prefs;
59:
60:
61: private final BufferedWriter bw;
62:
63:
67: private boolean subtree;
68:
69:
72: public NodeWriter(Preferences prefs, Writer w) {
73: this.prefs = prefs;
74: if (w instanceof BufferedWriter) {
75: this.bw = (BufferedWriter) w;
76: } else {
77: this.bw = new BufferedWriter(w);
78: }
79: }
80:
81:
85: public NodeWriter(Preferences prefs, OutputStream os) {
86: this(prefs, new OutputStreamWriter(os));
87: }
88:
89:
92: public void writePrefsTree() throws BackingStoreException, IOException {
93: subtree = true;
94: writeHeader();
95: writePreferences();
96: bw.flush();
97: }
98:
99:
102: public void writePrefs() throws BackingStoreException, IOException {
103: subtree = false;
104: writeHeader();
105: writePreferences();
106: bw.flush();
107: }
108:
109:
112: private void writeHeader() throws BackingStoreException, IOException {
113: bw.write("<?xml version=\"1.0\"?>");
114: bw.newLine();
115: bw.newLine();
116: bw.write("<!-- GNU Classpath java.util.prefs Preferences ");
117:
118: if (prefs.isUserNode()) {
119: bw.write("user");
120: } else {
121: bw.write("system");
122: }
123:
124:
125: if (prefs.parent() == null) {
126: bw.write(" root");
127: }
128:
129: if (subtree) {
130: bw.write(" tree");
131: } else {
132: bw.write(" node");
133: }
134:
135:
136: if (prefs.parent() != null) {
137: bw.newLine();
138: bw.write(" '");
139: bw.write(prefs.absolutePath());
140: bw.write('\'');
141: bw.newLine();
142: }
143: bw.write(" -->");
144: bw.newLine();
145: bw.newLine();
146: }
147:
148:
151: private void writePreferences() throws BackingStoreException, IOException {
152: bw.write("<preferences>");
153: bw.newLine();
154: writeRoot();
155: bw.write("</preferences>");
156: bw.newLine();
157: }
158:
159: private void writeRoot() throws BackingStoreException, IOException {
160: bw.write(" <root type=\"");
161: if (prefs.isUserNode()) {
162: bw.write("user");
163: } else {
164: bw.write("system");
165: }
166: bw.write("\"/>");
167:
168: writeRootMap();
169: writeNode();
170:
171: bw.write(" </root>");
172: bw.newLine();
173: }
174:
175: private void writeRootMap() throws BackingStoreException, IOException {
176:
177: if(prefs.parent() == null && prefs.keys().length > 0) {
178: bw.newLine();
179: writeMap(prefs, 2);
180: } else {
181: bw.write("<map/>");
182: bw.newLine();
183: }
184: }
185:
186:
192: private int writeParents() throws IOException {
193: int parents;
194: String path = prefs.absolutePath();
195: int lastslash = path.lastIndexOf("/");
196: if (lastslash > 0) {
197: path = path.substring(1, lastslash);
198: StringTokenizer st = new StringTokenizer(path);
199: parents = st.countTokens();
200:
201: System.out.println("path: " + path);
202: System.out.println("parents: " + parents);
203:
204: for (int i=0; i<parents; i++) {
205: String name = st.nextToken();
206: indent(i+2);
207: bw.write("<node name=\"" + name + "\">");
208: bw.write("<map/>");
209: bw.write("</node>");
210: bw.newLine();
211: }
212: } else {
213: parents = 0;
214: }
215:
216: return parents;
217: }
218:
219: private void writeCloseParents(int parents) throws IOException {
220: while(parents > 0) {
221: indent(parents+1);
222: bw.write("</node>");
223: bw.newLine();
224: parents--;
225: }
226: }
227:
228: private void writeNode() throws BackingStoreException, IOException {
229: int parents = writeParents();
230:
231: int indent;
232: if (prefs.parent() == null) {
233: indent = parents+1;
234: } else {
235: indent = parents+2;
236: }
237: writeNode(prefs, indent);
238: writeCloseParents(parents);
239: }
240:
241: private void writeNode(Preferences node, int indent)
242: throws BackingStoreException, IOException
243: {
244:
245: if (node.parent() != null) {
246: indent(indent);
247: bw.write("<node name=\"" + node.name() + "\">");
248: if (node.keys().length > 0) {
249: bw.newLine();
250: }
251: writeMap(node, indent+1);
252: }
253:
254: if (subtree) {
255: String[] children = node.childrenNames();
256: for (int i=0; i<children.length; i++) {
257: Preferences child = node.node(children[i]);
258: writeNode(child, indent+1);
259: }
260: }
261:
262:
263: if (node.parent() != null) {
264: indent(indent);
265: bw.write("</node>");
266: bw.newLine();
267: }
268: }
269:
270: private void writeMap(Preferences node, int indent)
271: throws BackingStoreException, IOException
272: {
273:
274: StringBuffer indentBuffer = new StringBuffer(2*indent);
275: for (int i=0; i < indent; i++)
276: indentBuffer.append(" ");
277: String indentString = indentBuffer.toString();
278:
279: if (node.keys().length > 0) {
280: bw.write(indentString);
281: bw.write("<map>");
282: bw.newLine();
283: writeEntries(node, indentString + " ");
284: bw.write(indentString);
285: bw.write("</map>");
286: } else {
287: bw.write("<map/>");
288: }
289: bw.newLine();
290: }
291:
292: private void writeEntries(Preferences node, String indent)
293: throws BackingStoreException, IOException
294: {
295: String[] keys = node.keys();
296: for(int i = 0; i < keys.length; i++) {
297: String value = node.get(keys[i], null);
298: if (value == null) {
299: throw new BackingStoreException("null value for key '"
300: + keys[i] + "'");
301: }
302:
303: bw.write(indent);
304: bw.write("<entry key=\"" + keys[i] + "\""
305: + " value=\"" + value + "\"/>");
306: bw.newLine();
307: }
308: }
309:
310: private void indent(int x) throws IOException {
311: for (int i=0; i<x; i++) {
312: bw.write(" ");
313: }
314: }
315: }