Initial check-in.

git-svn-id: http://svn.igniterealtime.org/svn/repos/smack/trunk@2369 b35dd754-fafc-0310-a699-88a17e54d16e

source/org/jivesoftware/smackx/workgroup/util/ListenerEventDispatcher.java

@@ -0,0 +1,131 @@
+/**
+ * $RCSfile$
+ * $Revision$
+ * $Date$
+ *
+ * Copyright (C) 1999-2003 Jive Software. All rights reserved.
+ *
+ * This software is the proprietary information of Jive Software.
+ * Use is subject to license terms.
+ */
+package org.jivesoftware.smackx.workgroup.util;
+
+import java.lang.reflect.Method;
+import java.util.*;
+
+/**
+ * This class is a very flexible event dispatcher which implements Runnable so that it can
+ *  dispatch easily from a newly created thread. The usage of this in code is more or less:
+ *  create a new instance of this class, use addListenerTriplet to add as many listeners
+ *  as desired to be messaged, create a new Thread using the instance of this class created
+ *  as the argument to the constructor, start the new Thread instance.<br>
+ *
+ * Also, this is intended to be used to message methods that either return void, or have
+ *  a return which the developer using this class is uninterested in receiving.<br>
+ *
+ * @author loki der quaeler
+ */
+public class ListenerEventDispatcher
+    implements Runnable {
+
+    protected transient ArrayList triplets;
+
+    protected transient boolean hasFinishedDispatching;
+    protected transient boolean isRunning;
+
+    public ListenerEventDispatcher () {
+        super();
+
+        this.triplets = new ArrayList();
+
+        this.hasFinishedDispatching = false;
+        this.isRunning = false;
+    }
+
+    /**
+     * Add a listener triplet - the instance of the listener to be messaged, the Method on which
+     *  the listener should be messaged, and the Object array of arguments to be supplied to the
+     *  Method. No attempts are made to determine whether this triplet was already added.<br>
+     *
+     * Messages are dispatched in the order in which they're added via this method; so if triplet
+     *  X is added after triplet Z, then triplet Z will undergo messaging prior to triplet X.<br>
+     *
+     * This method should not be called once the owning Thread instance has been started; if it
+     *  is called, the triplet will not be added to the messaging queue.<br>
+     *
+     * @param listenerInstance the instance of the listener to receive the associated notification
+     * @param listenerMethod the Method instance representing the method through which notification
+     *                          will occur
+     * @param methodArguments the arguments supplied to the notification method
+     */
+    public void addListenerTriplet (Object listenerInstance, Method listenerMethod,
+                                    Object[] methodArguments) {
+        if (! this.isRunning) {
+            this.triplets.add(new TripletContainer(listenerInstance, listenerMethod,
+                                                   methodArguments));
+        }
+    }
+
+    /**
+     * @return whether this instance has finished dispatching its messages
+     */
+    public boolean hasFinished () {
+        return this.hasFinishedDispatching;
+    }
+
+    /**
+     *
+     * Runnable implementation
+     *
+     */
+    public void run () {
+        ListIterator li = null;
+
+        this.isRunning = true;
+
+        li = this.triplets.listIterator();
+        while (li.hasNext()) {
+            TripletContainer tc = (TripletContainer)li.next();
+
+            try {
+                tc.getListenerMethod().invoke(tc.getListenerInstance(), tc.getMethodArguments());
+            } catch (Exception e) {
+                System.err.println("Exception dispatching an event: " + e);
+
+                e.printStackTrace();
+            }
+        }
+
+        this.hasFinishedDispatching = true;
+    }
+
+
+    protected class TripletContainer {
+
+        protected Object listenerInstance;
+        protected Method listenerMethod;
+        protected Object[] methodArguments;
+
+        protected TripletContainer (Object inst, Method meth, Object[] args) {
+            super();
+
+            this.listenerInstance = inst;
+            this.listenerMethod = meth;
+            this.methodArguments = args;
+        }
+
+        protected Object getListenerInstance () {
+            return this.listenerInstance;
+        }
+
+        protected Method getListenerMethod () {
+            return this.listenerMethod;
+        }
+
+        protected Object[] getMethodArguments () {
+            return this.methodArguments;
+        }
+
+    }
+
+}

source/org/jivesoftware/smackx/workgroup/util/MetaDataUtils.java

@@ -0,0 +1,90 @@
+/**
+ * $RCSfile$
+ * $Revision$
+ * $Date$
+ *
+ * Copyright (C) 1999-2003 Jive Software. All rights reserved.
+ *
+ * This software is the proprietary information of Jive Software.
+ * Use is subject to license terms.
+ */
+
+package org.jivesoftware.smackx.workgroup.util;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.util.Map;
+import java.util.Iterator;
+import java.util.Hashtable;
+import java.util.Collections;
+import java.io.IOException;
+
+import org.jivesoftware.smackx.workgroup.MetaData;
+
+/**
+ * Utility class for meta-data parsing and writing.
+ *
+ * @author MattTucker
+ */
+public class MetaDataUtils {
+
+    /**
+     * Parses any available meta-data and returns it as a Map of String name/value pairs. The
+     * parser must be positioned at an opening meta-data tag, or the an empty map will be returned.
+     *
+     * @param parser the XML parser positioned at an opening meta-data tag.
+     * @return the meta-data.
+     * @throws XmlPullParserException if an error occurs while parsing the XML.
+     * @throws IOException if an error occurs while parsing the XML.
+     */
+    public static Map parseMetaData(XmlPullParser parser) throws XmlPullParserException, IOException {
+        int eventType = parser.getEventType();
+
+        // If correctly positioned on an opening meta-data tag, parse meta-data.
+        if ((eventType == XmlPullParser.START_TAG)
+                && parser.getName().equals(MetaData.ELEMENT_NAME)
+                && parser.getNamespace().equals(MetaData.NAMESPACE)) {
+            Map metaData = new Hashtable();
+
+            eventType = parser.nextTag();
+
+            // Keep parsing until we've gotten to end of meta-data.
+            while ((eventType != XmlPullParser.END_TAG)
+                  || (! parser.getName().equals(MetaData.ELEMENT_NAME))) {
+                String name = parser.getAttributeValue(0);
+                String value = parser.nextText();
+
+                metaData.put(name, value);
+
+                eventType = parser.nextTag();
+            }
+
+            return metaData;
+        }
+
+        return Collections.EMPTY_MAP;
+    }
+
+    /**
+     * Serializes a Map of String name/value pairs into the meta-data XML format.
+     *
+     * @param metaData the Map of meta-data.
+     * @return the meta-data values in XML form.
+     */
+    public static String serializeMetaData(Map metaData) {
+        StringBuffer buf = new StringBuffer();
+        if (metaData != null && metaData.size() > 0) {
+            buf.append("<metadata xmlns=\"http://www.jivesoftware.com/workgroup/metadata\">");
+            for (Iterator i=metaData.keySet().iterator(); i.hasNext(); ) {
+                Object key = i.next();
+                String value = metaData.get(key).toString();
+                buf.append("<value name=\"").append(key).append("\">");
+                buf.append(value);
+                buf.append("</value>");
+            }
+            buf.append("</metadata>");
+        }
+        return buf.toString();
+    }
+}