moving the libraries

processing/net/Server.java

@@ -0,0 +1,233 @@
+/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  PServer - basic network server implementation
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2004 Ben Fry
+  The previous version of this code was developed by Hernando Barragan
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/
+
+package processing.net;
+import processing.core.*;
+
+import java.awt.event.*;
+import java.util.*;
+import java.awt.*;
+import java.io.*;
+import java.lang.reflect.*;
+import java.net.*;
+
+
+public class Server implements Runnable {
+
+  PApplet parent;
+  Method serverEventMethod;
+
+  Thread thread;
+  ServerSocket server;
+  int port;
+  Vector clients;  // people payin the bills
+
+
+  public Server(PApplet parent, int port) {
+    this.parent = parent;
+    this.port = port;
+
+    //parent.attach(this);
+
+    try {
+      server = new ServerSocket(this.port);
+      clients = new Vector();
+
+      thread = new Thread(this);
+      thread.start();
+
+      parent.registerDispose(this);
+
+      // reflection to check whether host applet has a call for
+      // public void serverEvent(Server s, Client c);
+      // which is called when a new guy connects
+      try {
+        serverEventMethod =
+          parent.getClass().getMethod("serverEvent",
+                                      new Class[] { Server.class,
+                                                    Client.class });
+      } catch (Exception e) {
+        // no such method, or an error.. which is fine, just ignore
+      }
+
+    } catch (IOException e) {
+      errorMessage("<init>", e);
+    }
+  }
+
+
+  /**
+   * Disconnect a particular client.
+   */
+  public void disconnect(Client client) {
+    //client.stop();
+    client.dispose();
+    clients.removeElement(client);
+  }
+
+
+  // the last index used for available. can't just cycle through
+  // the clients in order from 0 each time, because if client 0 won't
+  // shut up, then the rest of the clients will never be heard from.
+  int lastAvailable = -1;
+
+  /**
+   * Returns the next client in line that has something to say.
+   */
+  public Client available() {
+    synchronized (clients) {
+      int clientCount = clients.size();
+      int index = lastAvailable + 1;
+      if (index >= clientCount) index = 0;
+
+      for (int i = 0; i < clientCount; i++) {
+        int which = (index + i) % clientCount;
+        Client client = (Client) clients.elementAt(which);
+        if (client.available() > 0) {
+          lastAvailable = which;
+          return client;
+        }
+      }
+    }
+    return null;
+  }
+
+
+  /**
+   * Disconnect all clients and stop the server.
+   * <P>
+   * Use this to shut down the server if you finish using it
+   * while your applet is still running. Otherwise, it will be
+   * automatically be shut down by the host PApplet
+   * (using dispose, which is identical)
+   */
+  public void stop() {
+    dispose();
+  }
+
+
+  /**
+   * Disconnect all clients and stop the server: internal use only.
+   */
+  public void dispose() {
+    try {
+      thread = null;
+
+      if (clients != null) {
+        Enumeration en = clients.elements();
+        while (en.hasMoreElements()) {
+          disconnect((Client) en.nextElement());
+        }
+        clients = null;
+      }
+
+      if (server != null) {
+        server.close();
+        server = null;
+      }
+
+    } catch (IOException e) {
+      errorMessage("stop", e);
+    }
+  }
+
+
+  public void run() {
+    while (Thread.currentThread() == thread) {
+      try {
+        Socket socket = server.accept();
+        Client client = new Client(parent, socket);
+        synchronized (clients) {
+          clients.addElement(client);
+          if (serverEventMethod != null) {
+            try {
+              serverEventMethod.invoke(parent, new Object[] { this, client });
+            } catch (Exception e) {
+              System.err.println("error, disabling serverEvent() " +
+                                 " for port " + port);
+              e.printStackTrace();
+              serverEventMethod = null;
+            }
+          }
+        }
+      } catch (IOException e) {
+        errorMessage("run", e);
+      }
+      try {
+        Thread.sleep(8);
+      } catch (InterruptedException ex) { }
+    }
+  }
+
+
+  /**
+   * Write a value to all the connected clients.
+   * See Client.write() for operational details.
+   */
+  public void write(int what) {  // will also cover char
+    Enumeration en = clients.elements();
+    while (en.hasMoreElements()) {
+      Client client = (Client) en.nextElement();
+      client.write(what);
+    }
+  }
+
+
+  /**
+   * Write a byte array to all the connected clients.
+   * See Client.write() for operational details.
+   */
+  public void write(byte bytes[]) {
+    Enumeration en = clients.elements();
+    while (en.hasMoreElements()) {
+      Client client = (Client) en.nextElement();
+      client.write(bytes);
+    }
+  }
+
+
+  /**
+   * Write a String to all the connected clients.
+   * See Client.write() for operational details.
+   */
+  public void write(String what) {
+    Enumeration en = clients.elements();
+    while (en.hasMoreElements()) {
+      Client client = (Client) en.nextElement();
+      client.write(what);
+    }
+  }
+
+
+  /**
+   * General error reporting, all corraled here just in case
+   * I think of something slightly more intelligent to do.
+   */
+  public void errorMessage(String where, Exception e) {
+    parent.die("Error inside Server." + where + "()", e);
+    //System.err.println("Error inside Server." + where + "()");
+    //e.printStackTrace(System.err);
+  }
+}