path: root/NET/worlds/scape/SuperRoot.java

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));
      }
   }
}