Initial commit

1 files changed, 388 insertions, 0 deletions

diff --git a/NET/worlds/scape/SuperRoot.java b/NET/worlds/scape/SuperRoot.java
new file mode 100644
index 0000000..384bf05
--- /dev/null
+++ b/NET/worlds/scape/SuperRoot.java
@@ -0,0 +1,388 @@
+package NET.worlds.scape;
+
+import NET.worlds.console.Console;
+import NET.worlds.network.URL;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.text.MessageFormat;
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+public class SuperRoot implements Properties, Persister {
+   private String name;
+   protected static String helpURL = "home:internal/";
+   private SuperRoot owner;
+   protected URL sourceURL;
+   private static Object classCookie = new Object();
+   static Hashtable<Class<? extends Object>, Integer> finalizedClasses = new Hashtable<Class<? extends Object>, Integer>();
+   static Hashtable<Class<? extends Object>, Integer> classCounter = new Hashtable<Class<? extends Object>, Integer>();
+
+   public final String getShortClassName() {
+      String s = this.getClass().getName();
+      int index;
+      if ((index = s.lastIndexOf(46)) != -1) {
+         s = s.substring(index + 1);
+      }
+
+      return s;
+   }
+
+   public String getName() {
+      if (this.name == null) {
+         int digits = 0;
+         String classname = this.getShortClassName();
+         Enumeration<Object> en = this.getRoot().getDeepOwned();
+
+         while (en.hasMoreElements()) {
+            SuperRoot x = (SuperRoot)en.nextElement();
+            if (x.name != null && x.name.startsWith(classname)) {
+               try {
+                  int tmp = Integer.valueOf(x.name.substring(classname.length()));
+                  if (tmp > digits) {
+                     digits = tmp;
+                  }
+               } catch (NumberFormatException var6) {
+               }
+            }
+         }
+
+         this.name = classname + ++digits;
+      }
+
+      return this.name;
+   }
+
+   public String getNameMaybeNull() {
+      return this.name;
+   }
+
+   public void setName(String v) {
+      if (v == null && this.owner != null) {
+         Object[] arguments = new Object[]{new String(this.owner.getName())};
+         Console.println(MessageFormat.format(Console.message("Warning-null-name"), arguments));
+      }
+
+      this.name = v;
+   }
+
+   public static SuperRoot nameSearch(Enumeration<?> enumeration, String name) {
+      while (enumeration.hasMoreElements()) {
+         SuperRoot n = (SuperRoot)enumeration.nextElement();
+         if (name.equals(n.name)) {
+            return n;
+         }
+      }
+
+      return null;
+   }
+
+   public URL getHelpURL() {
+      String helpString = helpURL + this.getClass().getName() + Console.message(".html");
+      URL helpPage = URL.make(helpString);
+      if (Console.wasHttpNoSuchFile(helpString)) {
+         helpPage = URL.make(helpURL + this.getClass().getName() + ".html");
+      }
+
+      return helpPage;
+   }
+
+   public URL getHelpURL(Property p) {
+      String namesub = p.getName().replace(' ', '_');
+      String helpString = helpURL + this.getClass().getName() + "#" + namesub + Console.message(".html");
+      URL helpPage = URL.make(helpString);
+      if (Console.wasHttpNoSuchFile(helpString)) {
+         helpPage = URL.make(helpURL + this.getClass().getName() + "#" + namesub + ".html");
+      }
+
+      return helpPage;
+   }
+
+   @Override
+   public String toString() {
+      return this.isActive() ? this.getName() : this.getName() + "(inactive)";
+   }
+
+   @Override
+   public Object properties(int index, int offset, int mode, Object value) throws NoSuchPropertyException {
+      Object ret = null;
+      switch (index - offset) {
+         case 0:
+            if (mode == 0) {
+               ret = StringPropertyEditor.make(new Property(this, index, "Name"));
+            } else if (mode == 1) {
+               ret = this.getName();
+            } else if (mode == 4) {
+               this.setName(null);
+            } else if (mode == 2) {
+               String s = (String)value;
+               if (!s.equals(this.name) && this.owner != null && nameSearch(this.getRoot().getDeepOwned(), s) != null) {
+                  Object[] arguments = new Object[]{new String(s), new String(this.getRoot().getName())};
+                  Console.println(MessageFormat.format(Console.message("Name-in-use"), arguments));
+               } else {
+                  this.setName((String)value);
+               }
+            }
+            break;
+         case 1:
+            if (mode == 0) {
+               ret = URLPropertyEditor.make(new Property(this, index, "Source URL").allowSetNull(), "*wob", false);
+            } else if (mode == 1) {
+               ret = this.sourceURL;
+            } else if (mode == 2) {
+               this.setSourceURL((URL)value);
+            }
+            break;
+         default:
+            throw new NoSuchPropertyException();
+      }
+
+      return ret;
+   }
+
+   @Override
+   public Object propertyParent() {
+      return this.owner;
+   }
+
+   public SuperRoot getOwner() {
+      return this.owner;
+   }
+
+   public void discard() {
+      this.detach();
+   }
+
+   protected void add(SuperRoot x) {
+      if (x.owner != null && x.owner != this) {
+         System.out.println("double-setting owner of " + x + " from " + x.owner + " to " + this);
+         throw new Error("double-setting owner of " + x);
+      } else {
+         x.noteAddingTo(this);
+         x.owner = this;
+      }
+   }
+
+   public void detach() {
+      if (this.owner != null) {
+         this.owner.noteUnadding(this);
+         this.owner = null;
+      }
+   }
+
+   protected void noteAddingTo(SuperRoot s) {
+   }
+
+   protected void noteUnadding(SuperRoot s) {
+   }
+
+   public Enumeration<Object> getOwned() {
+      return new ShallowEnumeration(this);
+   }
+
+   public Enumeration<Object> getDeepOwned() {
+      return new DeepEnumeration<Object>(this);
+   }
+
+   public void getChildren(DeepEnumeration<?> d) {
+   }
+
+   public World getWorld() {
+      SuperRoot owner = this.getOwner();
+      return owner == null ? null : owner.getWorld();
+   }
+
+   public Room getRoom() {
+      SuperRoot owner = this.getOwner();
+      return owner == null ? null : owner.getRoom();
+   }
+
+   public SuperRoot getRoot() {
+      SuperRoot owner = this.getOwner();
+      return owner == null ? this : owner.getRoot();
+   }
+
+   public boolean isActive() {
+      return this.getWorld() != null;
+   }
+
+   public URL getSourceURL() {
+      return this.sourceURL;
+   }
+
+   public void setSourceURL(URL s) {
+      this.sourceURL = s;
+   }
+
+   public URL getContainingSourceURL() {
+      if (this.sourceURL != null) {
+         return this.sourceURL;
+      } else {
+         return this.owner != null ? this.owner.getContainingSourceURL() : null;
+      }
+   }
+
+   public void markEdited() {
+      if (this.owner != null) {
+         this.owner.markEdited();
+      }
+   }
+
+   public static SuperRoot readFile(String urlLocal, URL url) {
+      try {
+         Restorer r = new Restorer(urlLocal, url);
+         SuperRoot o = (SuperRoot)r.restore();
+         r.done();
+         o.setSourceURL(url);
+         return o;
+      } catch (FileNotFoundException var5) {
+      } catch (ClassCastException var6) {
+      } catch (IOException var7) {
+      } catch (TooNewException var8) {
+      } catch (BadFormatException var9) {
+      }
+
+      return null;
+   }
+
+   public static SuperRoot readFile(URL url) {
+      return readFile(url.unalias(), url);
+   }
+
+   public void loadInit() {
+   }
+
+   public void saveFile(URL url) throws IOException {
+      if (this instanceof NonPersister) {
+         throw new IOException("Can't save NonPersister");
+      } else {
+         Saver s = new Saver(url);
+         s.save(this);
+         s.done();
+         this.setSourceURL(url);
+      }
+   }
+
+   @Override
+   public Object clone() {
+      byte[] b = this.getByteCopy();
+      return getCopyFromBytes(b);
+   }
+
+   public byte[] getByteCopy() {
+      if (this instanceof NonPersister) {
+         return null;
+      } else {
+         ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+
+         try {
+            Saver saver = new Saver(new DataOutputStream(buffer));
+            saver.save(this);
+            saver.done();
+            return buffer.toByteArray();
+         } catch (Exception var3) {
+            var3.printStackTrace(System.out);
+            throw new Error("Can't save");
+         }
+      }
+   }
+
+   public static SuperRoot getCopyFromBytes(byte[] b) {
+      if (b == null) {
+         return null;
+      } else {
+         try {
+            Restorer r = new Restorer(new DataInputStream(new ByteArrayInputStream(b)));
+            SuperRoot obj = (SuperRoot)r.restore();
+            r.done();
+            return obj;
+         } catch (Exception var3) {
+            var3.printStackTrace(System.out);
+            throw new Error("Can't restore");
+         }
+      }
+   }
+
+   @Override
+   public void saveState(Saver s) throws IOException {
+      s.saveVersion(2, classCookie);
+      s.saveString(this.name);
+   }
+
+   @Override
+   public void restoreState(Restorer r) throws IOException, TooNewException {
+      this.restoreStateSuperRoot(r);
+   }
+
+   protected final void restoreStateSuperRoot(Restorer r) throws IOException, TooNewException {
+      switch (r.restoreVersion(classCookie)) {
+         case 0:
+            r.setOldFlag();
+         case 2:
+            String n;
+            if ((n = r.restoreString()) != null) {
+               this.setName(n);
+            }
+            break;
+         case 1:
+            r.setOldFlag();
+            String nx;
+            if ((nx = r.restoreString()) != null) {
+               this.setName(nx);
+            }
+
+            r.restoreMaybeNull();
+            break;
+         default:
+            throw new TooNewException();
+      }
+   }
+
+   @Override
+   public void postRestore(int version) {
+   }
+
+   public static void finalizeCounter(Object o) {
+      Class<? extends Object> c = (Class<? extends Object>)o.getClass();
+      Integer icnt = finalizedClasses.get(c);
+      int cnt = 0;
+      if (icnt != null) {
+         cnt = icnt;
+      }
+
+      if (++cnt == 1000) {
+         System.out.println("Finalized 1000 times: " + c);
+         cnt = 0;
+      }
+
+      finalizedClasses.put((Class<? extends Object>)o.getClass(), new Integer(cnt));
+   }
+
+   @Override
+   protected void finalize() {
+   }
+
+   public static void countClass(Object o, int inc) {
+      Class<? extends Object> c = (Class<? extends Object>)o.getClass();
+      Integer icnt = classCounter.get(c);
+      int cnt = 0;
+      if (icnt != null) {
+         cnt = icnt;
+      }
+
+      cnt += inc;
+      classCounter.put(c, new Integer(cnt));
+   }
+
+   public static void printClassCounts() {
+      Enumeration<Class<? extends Object>> e = classCounter.keys();
+
+      while (e.hasMoreElements()) {
+         Class<?> c = e.nextElement();
+         System.out.println("Class " + c.getName() + " has " + classCounter.get(c));
+      }
+   }
+}