appl/ext/XuluConfig.java

package appl.ext;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

import org.geotools.io.DefaultFileFilter;

/**
 * Simple Property store, which is loaded at each Xulu start and saved at each
 * Xulu exit. Every class or plugin can store and retrieve configuration
 * information easy through a static method. To keep the property file readable
 * and to avoid conflicts with other plugins please prefix the key-name with a
 * unique name, which identifies your class, followed by a dot and the property.
 * This is important for correct display in a User-GUI (which could be
 * implemented). <br>
 * <br>
 * Keyformat: <code>domain.property</code> <br>
 * Example key: <code>DiscoveryService.className</code> <br>
 * <br>
 * There could be no double entries.But you can save multiple values to one key
 * using the {@link #setMultiProperty(String, String[]) setMultiProperty}
 * method. <br>
 * <b>These values are internally separated with ';', so see that you don't use
 * ';' in your values of {@link #setMultiProperty(String, String[]) Multi
 * Properties}</b> <br>
 * <br>
 * First the settings of the file "DefaultProperties" are loaded. After that the
 * values are possibly overwritten by the loading of the file "XuluProperties"
 * in which is intended to store a actual user configuration.
 * <b>"DefaultPropoerties" should never be modified by the user.</b> The
 * programmer should store all default values there. <br>
 * <br>
 * The user may change values through the {@link ConfigurationEditorGUI}.
 *
 * @see ConfigurationEditorGUI
 * @see ConfigurationEditorEngine
 * @author Dominik Appl
 */
public class XuluConfig {

        private final String delimiter = ";";

        // File for default values
        File defaultFile = new File("DefaultProperties");

        // File in which the props are stored
        File file = new File("XuluProperties");

        Properties propStore = null;

        private static XuluConfig instance = null;

        private XuluConfig() {
          this(null);
        }

        private XuluConfig(File rootDir) {
                if ( rootDir != null && rootDir.isDirectory() ) {
                  defaultFile = new File(rootDir, defaultFile.getName());
                  file        = new File(rootDir, file.getName());
                }
                // try to read defaults
                Properties defaults = new Properties();
                try {
                        defaults.load(new FileInputStream(defaultFile));
                } catch (Exception e) {
                        System.out
                                        .println("Warning: defaults could not be loaded from file '"
                                                        + defaultFile + "'");
                        System.out.println(e.getMessage());
                }
                propStore = new Properties(defaults);
                if (file.exists())
                        load();
                else
                        store();
        }

        public static XuluConfig getXuluConfig() {
          return getXuluConfig(null);
        }

        public static XuluConfig getXuluConfig(File rootDir) {
                if (instance == null)
                        instance = new XuluConfig(rootDir);
                return instance;
        }

        /**
         * Saves the configuration to the file system
         */
        public void store() {
                try {
                        propStore.store(new FileOutputStream(file),
                                        "Stored properties of the Xulu modelling platform");
                } catch (FileNotFoundException e) {
                        System.err.println("Could not write PropertyStore!!!");
                        e.printStackTrace();
                } catch (IOException e) {
                        System.err.println("Could not write PropertyStore!!!");
                        e.printStackTrace();
                }

        }

        /**
         * Sets the Property file. Notice that this has only an effect if you call
         * load afterwards.
         *
         * @param file
         */
        public void setPropertyFile(File file) {
                this.file = file;
        }

        /**
         * loads the Properties from the Propertyfile. No loaded values are deleted -
         * only existing ones are overwritten;
         */
        public void load() {
                try {
                        propStore.load(new FileInputStream(file));
                } catch (FileNotFoundException e) {
                        System.err.println("Property file with name '" + file
                                        + "' not found");
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }

        /**
         * inserts the property value with the specified key into the
         * {@link XuluConfig}
         *
         * @param key
         *            the key
         * @param value
         *            the value associated with the key
         */
        public void setProperty(String key, String value) {
                if (!key.contains("."))
                        System.out
                                        .println("WARNING for key "
                                                        + key
                                                        + ": Propertykeys in XuluConfig should have at least one '.' ! ");
                propStore.setProperty(key, value);
        }

        /***************************************************************************
         * @return the property associated with the provided key. If not found the
         *         defaults are searched. If still not found, null is returned.
         *         Gives out a warning to console if the key was not found
         **************************************************************************/
        public String getProperty(String key) {
                String value = propStore.getProperty(key);
                if (value == null)
                        System.err.println("Warning! Value for property '" + key
                                        + "' was not found in property file!");
                return value;
        }

        /***************************************************************************
         * Same as {@link #getProperty(String)}, but you can disable the warning
         * message
         *
         * @param giveWarning
         *            if true, a warning is given to the console if the specified
         *            entry was not found
         * @return the property associated with the provided key. If not found the
         *         defaults are searched. If still not found, null is returned.
         *         Gives out a warning to console if the key was not found
         **************************************************************************/
        public String getProperty(String key, boolean giveWarning) {
                String value = propStore.getProperty(key);
                if (value == null && giveWarning)
                        System.err.println("Warning! Value for property '" + key
                                        + "' was not found in property file!");
                return value;
        }

        /***************************************************************************
         *
         * @return the property associated with the provided key as integer value.
         *         If not found the defaults are searched. If not found or the value
         *         is in a wrong format 0 is returned and a warning is given to the
         *         console
         **************************************************************************/
        public int getIntProperty(String key) {
                String value = propStore.getProperty(key);
                if (value == null) {
                        System.err.println("Error! Value for property '" + key
                                        + "' was not found in property file!");
                        return 0;
                }
                int returnvalue = 0;
                try {
                        returnvalue = Integer.valueOf(value);
                } catch (java.lang.NumberFormatException e) {
                        System.err
                                        .println("Error! Value for property '"
                                                        + key
                                                        + "' was not in the right format. Should be a Integer value! - Returning 0");
                }
                return returnvalue;
        }

        /***************************************************************************
         * @return the property associated with the provided key as double value. If
         *         not found the defaults are searched. If not found or the value is
         *         in a wrong format 0 is returned and a warning is given to the
         *         console
         **************************************************************************/
        public double getDoubleProperty(String key) {
                String value = propStore.getProperty(key);
                if (value == null) {
                        System.err.println("Error! Value for property '" + key
                                        + "' was not found in property file!");
                        return 0;
                }
                double returnvalue = 0;
                try {
                        returnvalue = Double.valueOf(value);
                } catch (java.lang.NumberFormatException e) {
                        System.err
                                        .println("Error! Value for property '"
                                                        + key
                                                        + "' was not in the right format. Should be a Integer value! - Returning 0");
                }
                return returnvalue;
        }

        /**
         * inserts the property value with the specified key into the
         * {@link XuluConfig}
         *
         * @param key
         *            the key
         * @param value
         *            the value associated with the key
         */
        public void setBooleanProperty(String key, boolean value) {
                this.setProperty(key, String.valueOf(value));
        }

        /**
         * inserts the property value with the specified key into the
         * {@link XuluConfig}
         *
         * @param key
         *            the key
         * @param value
         *            the value associated with the key
         */
        public void setIntProperty(String key, int value) {
                this.setProperty(key, String.valueOf(value));
        }

        /***************************************************************************
         * @return the property associated with the provided key as boolean value.
         *         If not found the defaults are searched. If still not found or
         *         null then false is returned. Gives out a warning to console if
         *         the key was not found
         **************************************************************************/
        public boolean getBooleanProperty(String key) {
                String value = propStore.getProperty(key);
                if (value == null) {
                        System.err.println("Error! Value for property '" + key
                                        + "' was not found in property file!");
                        return false;
                }
                if(value.equals("1"))
                        return true;
                boolean bool = false;
                try {
                        bool = Boolean.valueOf(value);
                } catch (Exception e) {
                        System.err.println("Error! Value for property '" + key
                                        + "' was not a valid boolean value");
                }
                return bool;
        }

        /**
         * A multiproperty stores multiple values for one key. These values are
         * internaly seperated with spaces, so see that you dont use spaces in your
         * values.
         *
         * @param key
         *            the key
         * @param values
         *            array of the values which should be associated with the key
         */
        public void setMultiProperty(String key, String values[]) {
                if (!key.contains("."))
                        System.out
                                        .println("WARNING for key "
                                                        + key
                                                        + ": Propertykeys in XuluConfig should have at least one '.' ! ");
                String value = "";
                if (values != null)
                        for (String string : values) {
                                value += (string + delimiter);
                        }
                propStore.setProperty(key, value);
        }

        /***************************************************************************
         * A multiproperty stores multiple values for one key. These values are
         * internaly seperated with ';', so do not use ';' in your values. if the
         * key was not found it gives out a warning to console and a empty array is
         * retured.
         *
         * @return the multiProperty associated with the provided key, which is in
         *         this case just a String array
         **************************************************************************/

        public String[] getMultiProperty(String key) {
                String value = propStore.getProperty(key);
                if (value != null)
                        return value.split(delimiter);
                System.err.println("Error! Value for property '" + key
                                + "' was not found in property file!");
                return new String[0];
        }

        /**
         * removes the Property from the list
         *
         * @param key
         */
        public void removeProperty(String key) {
                propStore.remove(key);
        }

        /**
         * removes all keys starting with the value given. USE WITH CAUTION! If you
         * give a String "a" all entrys starting with "a" will be removed from the
         * registry
         *
         * @param key
         */
        public void removeAll(String key) {
                if (key == null)
                        return;

                Enumeration keys = propStore.propertyNames();
                while (keys.hasMoreElements()) {
                        String propKey = (String) keys.nextElement();
                        if (propKey == null)
                                continue;
                        if (propKey.startsWith(key))
                                propStore.remove(propKey);
                }
        }

        /**
         * Gets all prefixes. A Prefix is the string of all characters up to the
         * first dot. A Suffix is the string of all characters following this dot.
         *
         * @return the prefixes
         *
         */
        public Set<String> getPrefixes() {
                TreeSet set = new TreeSet();
                Enumeration keys = propStore.propertyNames();
                while (keys.hasMoreElements()) {
                        String propKey = (String) keys.nextElement();
                        String[] strings = propKey.split("\\.");
                        set.add(strings[0]);
                }
                return set;
        }

        /**
         * Gets all suffixes for one prefix. A Prefix is the string of all
         * characters up to the first dot. A Suffix is the string of all characters
         * following this dot. The Strings are ordered alphabeticly
         *
         * @param prefix
         *            the prefix.
         */
        public Set<String> getSuffixesOfPrefix(String prefix) {
                TreeSet set = new TreeSet();
                Enumeration keys = propStore.propertyNames();
                while (keys.hasMoreElements()) {
                        String propKey = (String) keys.nextElement();
                        String[] strings = propKey.split("\\.");
                        if (strings.length > 1 && strings[0].equals(prefix))
                                set.add(propKey.substring(strings[0].length() + 1));
                }
                return set;
        }

        /**
         * Gets all entries starting with the given {@link String}
         *
         * @param startingString
         *            the prefixstring
         * @return all keys starting the given prefix
         */
        public Set<String> getKeysStartingWith(String startingString) {
                TreeSet set = new TreeSet();
                Enumeration keys = propStore.propertyNames();
                while (keys.hasMoreElements()) {
                        String propKey = (String) keys.nextElement();
                        if (propKey.startsWith(startingString))
                                set.add(propKey);
                }
                return set;
        }

        /**
         * Just for testing.
         *
         * @deprecated
         */
        public static void main(String[] args) {
                XuluConfig config = XuluConfig.getXuluConfig();
                config.setProperty("atest2", "test3");
                config.setProperty("test4.testproperty", "test");
                String[] multiTest = { "value1", "value2", "value3" };
                config.setMultiProperty("multiproperty.1", multiTest);
                String[] multioutput = config.getMultiProperty("multiproperty.1");
                for (String string : multioutput) {
                        System.out.println("Multivalue: " + string);
                }
                config.store();
                config.setPropertyFile(new File("XuluTestfile"));
                config.load();
                String[] multiTest2 = { "value1", "value2", "value3" };
                config.setMultiProperty("multiproperty.2", multiTest);
                config.removeAll("multiproperty");
                config.removeProperty("atest2");
                config.store();
        }
}
1	mojays	2	package appl.ext;
2
3			import java.io.File;
4			import java.io.FileInputStream;
5			import java.io.FileNotFoundException;
6			import java.io.FileOutputStream;
7			import java.io.IOException;
8			import java.util.Enumeration;
9			import java.util.Iterator;
10			import java.util.Properties;
11			import java.util.Set;
12			import java.util.SortedSet;
13			import java.util.TreeSet;
14
15			import org.geotools.io.DefaultFileFilter;
16
17			/**
18			* Simple Property store, which is loaded at each Xulu start and saved at each
19			* Xulu exit. Every class or plugin can store and retrieve configuration
20			* information easy through a static method. To keep the property file readable
21			* and to avoid conflicts with other plugins please prefix the key-name with a
22			* unique name, which identifies your class, followed by a dot and the property.
23			* This is important for correct display in a User-GUI (which could be
24			* implemented). <br>
25			* <br>
26			* Keyformat: <code>domain.property</code> <br>
27			* Example key: <code>DiscoveryService.className</code> <br>
28			* <br>
29			* There could be no double entries.But you can save multiple values to one key
30			* using the {@link #setMultiProperty(String, String[]) setMultiProperty}
31			* method. <br>
32			* <b>These values are internally separated with ';', so see that you don't use
33			* ';' in your values of {@link #setMultiProperty(String, String[]) Multi
34			* Properties}</b> <br>
35			* <br>
36			* First the settings of the file "DefaultProperties" are loaded. After that the
37			* values are possibly overwritten by the loading of the file "XuluProperties"
38			* in which is intended to store a actual user configuration.
39			* <b>"DefaultPropoerties" should never be modified by the user.</b> The
40			* programmer should store all default values there. <br>
41			* <br>
42			* The user may change values through the {@link ConfigurationEditorGUI}.
43			*
44			* @see ConfigurationEditorGUI
45			* @see ConfigurationEditorEngine
46			* @author Dominik Appl
47			*/
48			public class XuluConfig {
49
50			private final String delimiter = ";";
51
52			// File for default values
53			File defaultFile = new File("DefaultProperties");
54
55			// File in which the props are stored
56			File file = new File("XuluProperties");
57
58			Properties propStore = null;
59
60			private static XuluConfig instance = null;
61
62			private XuluConfig() {
63			this(null);
64			}
65
66			private XuluConfig(File rootDir) {
67			if ( rootDir != null && rootDir.isDirectory() ) {
68			defaultFile = new File(rootDir, defaultFile.getName());
69			file = new File(rootDir, file.getName());
70			}
71			// try to read defaults
72			Properties defaults = new Properties();
73			try {
74			defaults.load(new FileInputStream(defaultFile));
75			} catch (Exception e) {
76			System.out
77			.println("Warning: defaults could not be loaded from file '"
78			+ defaultFile + "'");
79			System.out.println(e.getMessage());
80			}
81			propStore = new Properties(defaults);
82			if (file.exists())
83			load();
84			else
85			store();
86			}
87
88			public static XuluConfig getXuluConfig() {
89			return getXuluConfig(null);
90			}
91
92			public static XuluConfig getXuluConfig(File rootDir) {
93			if (instance == null)
94			instance = new XuluConfig(rootDir);
95			return instance;
96			}
97
98			/**
99			* Saves the configuration to the file system
100			*/
101			public void store() {
102			try {
103			propStore.store(new FileOutputStream(file),
104			"Stored properties of the Xulu modelling platform");
105			} catch (FileNotFoundException e) {
106			System.err.println("Could not write PropertyStore!!!");
107			e.printStackTrace();
108			} catch (IOException e) {
109			System.err.println("Could not write PropertyStore!!!");
110			e.printStackTrace();
111			}
112
113			}
114
115			/**
116			* Sets the Property file. Notice that this has only an effect if you call
117			* load afterwards.
118			*
119			* @param file
120			*/
121			public void setPropertyFile(File file) {
122			this.file = file;
123			}
124
125			/**
126			* loads the Properties from the Propertyfile. No loaded values are deleted -
127			* only existing ones are overwritten;
128			*/
129			public void load() {
130			try {
131			propStore.load(new FileInputStream(file));
132			} catch (FileNotFoundException e) {
133			System.err.println("Property file with name '" + file
134			+ "' not found");
135			} catch (IOException e) {
136			// TODO Auto-generated catch block
137			e.printStackTrace();
138			}
139			}
140
141			/**
142			* inserts the property value with the specified key into the
143			* {@link XuluConfig}
144			*
145			* @param key
146			* the key
147			* @param value
148			* the value associated with the key
149			*/
150			public void setProperty(String key, String value) {
151			if (!key.contains("."))
152			System.out
153			.println("WARNING for key "
154			+ key
155			+ ": Propertykeys in XuluConfig should have at least one '.' ! ");
156			propStore.setProperty(key, value);
157			}
158
159			/***************************************************************************
160			* @return the property associated with the provided key. If not found the
161			* defaults are searched. If still not found, null is returned.
162			* Gives out a warning to console if the key was not found
163			**************************************************************************/
164			public String getProperty(String key) {
165			String value = propStore.getProperty(key);
166			if (value == null)
167			System.err.println("Warning! Value for property '" + key
168			+ "' was not found in property file!");
169			return value;
170			}
171
172			/***************************************************************************
173			* Same as {@link #getProperty(String)}, but you can disable the warning
174			* message
175			*
176			* @param giveWarning
177			* if true, a warning is given to the console if the specified
178			* entry was not found
179			* @return the property associated with the provided key. If not found the
180			* defaults are searched. If still not found, null is returned.
181			* Gives out a warning to console if the key was not found
182			**************************************************************************/
183			public String getProperty(String key, boolean giveWarning) {
184			String value = propStore.getProperty(key);
185			if (value == null && giveWarning)
186			System.err.println("Warning! Value for property '" + key
187			+ "' was not found in property file!");
188			return value;
189			}
190
191			/***************************************************************************
192			*
193			* @return the property associated with the provided key as integer value.
194			* If not found the defaults are searched. If not found or the value
195			* is in a wrong format 0 is returned and a warning is given to the
196			* console
197			**************************************************************************/
198			public int getIntProperty(String key) {
199			String value = propStore.getProperty(key);
200			if (value == null) {
201			System.err.println("Error! Value for property '" + key
202			+ "' was not found in property file!");
203			return 0;
204			}
205			int returnvalue = 0;
206			try {
207			returnvalue = Integer.valueOf(value);
208			} catch (java.lang.NumberFormatException e) {
209			System.err
210			.println("Error! Value for property '"
211			+ key
212			+ "' was not in the right format. Should be a Integer value! - Returning 0");
213			}
214			return returnvalue;
215			}
216
217			/***************************************************************************
218			* @return the property associated with the provided key as double value. If
219			* not found the defaults are searched. If not found or the value is
220			* in a wrong format 0 is returned and a warning is given to the
221			* console
222			**************************************************************************/
223			public double getDoubleProperty(String key) {
224			String value = propStore.getProperty(key);
225			if (value == null) {
226			System.err.println("Error! Value for property '" + key
227			+ "' was not found in property file!");
228			return 0;
229			}
230			double returnvalue = 0;
231			try {
232			returnvalue = Double.valueOf(value);
233			} catch (java.lang.NumberFormatException e) {
234			System.err
235			.println("Error! Value for property '"
236			+ key
237			+ "' was not in the right format. Should be a Integer value! - Returning 0");
238			}
239			return returnvalue;
240			}
241
242			/**
243			* inserts the property value with the specified key into the
244			* {@link XuluConfig}
245			*
246			* @param key
247			* the key
248			* @param value
249			* the value associated with the key
250			*/
251			public void setBooleanProperty(String key, boolean value) {
252			this.setProperty(key, String.valueOf(value));
253			}
254
255			/**
256			* inserts the property value with the specified key into the
257			* {@link XuluConfig}
258			*
259			* @param key
260			* the key
261			* @param value
262			* the value associated with the key
263			*/
264			public void setIntProperty(String key, int value) {
265			this.setProperty(key, String.valueOf(value));
266			}
267
268			/***************************************************************************
269			* @return the property associated with the provided key as boolean value.
270			* If not found the defaults are searched. If still not found or
271			* null then false is returned. Gives out a warning to console if
272			* the key was not found
273			**************************************************************************/
274			public boolean getBooleanProperty(String key) {
275			String value = propStore.getProperty(key);
276			if (value == null) {
277			System.err.println("Error! Value for property '" + key
278			+ "' was not found in property file!");
279			return false;
280			}
281			if(value.equals("1"))
282			return true;
283			boolean bool = false;
284			try {
285			bool = Boolean.valueOf(value);
286			} catch (Exception e) {
287			System.err.println("Error! Value for property '" + key
288			+ "' was not a valid boolean value");
289			}
290			return bool;
291			}
292
293			/**
294			* A multiproperty stores multiple values for one key. These values are
295			* internaly seperated with spaces, so see that you dont use spaces in your
296			* values.
297			*
298			* @param key
299			* the key
300			* @param values
301			* array of the values which should be associated with the key
302			*/
303			public void setMultiProperty(String key, String values[]) {
304			if (!key.contains("."))
305			System.out
306			.println("WARNING for key "
307			+ key
308			+ ": Propertykeys in XuluConfig should have at least one '.' ! ");
309			String value = "";
310			if (values != null)
311			for (String string : values) {
312			value += (string + delimiter);
313			}
314			propStore.setProperty(key, value);
315			}
316
317			/***************************************************************************
318			* A multiproperty stores multiple values for one key. These values are
319			* internaly seperated with ';', so do not use ';' in your values. if the
320			* key was not found it gives out a warning to console and a empty array is
321			* retured.
322			*
323			* @return the multiProperty associated with the provided key, which is in
324			* this case just a String array
325			**************************************************************************/
326
327			public String[] getMultiProperty(String key) {
328			String value = propStore.getProperty(key);
329			if (value != null)
330			return value.split(delimiter);
331			System.err.println("Error! Value for property '" + key
332			+ "' was not found in property file!");
333			return new String[0];
334			}
335
336			/**
337			* removes the Property from the list
338			*
339			* @param key
340			*/
341			public void removeProperty(String key) {
342			propStore.remove(key);
343			}
344
345			/**
346			* removes all keys starting with the value given. USE WITH CAUTION! If you
347			* give a String "a" all entrys starting with "a" will be removed from the
348			* registry
349			*
350			* @param key
351			*/
352			public void removeAll(String key) {
353			if (key == null)
354			return;
355
356			Enumeration keys = propStore.propertyNames();
357			while (keys.hasMoreElements()) {
358			String propKey = (String) keys.nextElement();
359			if (propKey == null)
360			continue;
361			if (propKey.startsWith(key))
362			propStore.remove(propKey);
363			}
364			}
365
366			/**
367			* Gets all prefixes. A Prefix is the string of all characters up to the
368			* first dot. A Suffix is the string of all characters following this dot.
369			*
370			* @return the prefixes
371			*
372			*/
373			public Set<String> getPrefixes() {
374			TreeSet set = new TreeSet();
375			Enumeration keys = propStore.propertyNames();
376			while (keys.hasMoreElements()) {
377			String propKey = (String) keys.nextElement();
378			String[] strings = propKey.split("\\.");
379			set.add(strings[0]);
380			}
381			return set;
382			}
383
384			/**
385			* Gets all suffixes for one prefix. A Prefix is the string of all
386			* characters up to the first dot. A Suffix is the string of all characters
387			* following this dot. The Strings are ordered alphabeticly
388			*
389			* @param prefix
390			* the prefix.
391			*/
392			public Set<String> getSuffixesOfPrefix(String prefix) {
393			TreeSet set = new TreeSet();
394			Enumeration keys = propStore.propertyNames();
395			while (keys.hasMoreElements()) {
396			String propKey = (String) keys.nextElement();
397			String[] strings = propKey.split("\\.");
398			if (strings.length > 1 && strings[0].equals(prefix))
399			set.add(propKey.substring(strings[0].length() + 1));
400			}
401			return set;
402			}
403
404			/**
405			* Gets all entries starting with the given {@link String}
406			*
407			* @param startingString
408			* the prefixstring
409			* @return all keys starting the given prefix
410			*/
411			public Set<String> getKeysStartingWith(String startingString) {
412			TreeSet set = new TreeSet();
413			Enumeration keys = propStore.propertyNames();
414			while (keys.hasMoreElements()) {
415			String propKey = (String) keys.nextElement();
416			if (propKey.startsWith(startingString))
417			set.add(propKey);
418			}
419			return set;
420			}
421
422			/**
423			* Just for testing.
424			*
425			* @deprecated
426			*/
427			public static void main(String[] args) {
428			XuluConfig config = XuluConfig.getXuluConfig();
429			config.setProperty("atest2", "test3");
430			config.setProperty("test4.testproperty", "test");
431			String[] multiTest = { "value1", "value2", "value3" };
432			config.setMultiProperty("multiproperty.1", multiTest);
433			String[] multioutput = config.getMultiProperty("multiproperty.1");
434			for (String string : multioutput) {
435			System.out.println("Multivalue: " + string);
436			}
437			config.store();
438			config.setPropertyFile(new File("XuluTestfile"));
439			config.load();
440			String[] multiTest2 = { "value1", "value2", "value3" };
441			config.setMultiProperty("multiproperty.2", multiTest);
442			config.removeAll("multiproperty");
443			config.removeProperty("atest2");
444			config.store();
445			}
446			}